1318 lines
24 KiB
Plaintext
1318 lines
24 KiB
Plaintext
/* GENERATED FILE, DO NOT EDIT */
|
|
/* @(#)pr_lint.c 1.1 94/10/31 SMI */
|
|
|
|
/*
|
|
* Copyright 1987 by Sun Microsystems, Inc.
|
|
*/
|
|
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/*
|
|
* pixrect creation
|
|
*/
|
|
Pixrect *
|
|
pr_open(fbname)
|
|
char *fbname;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
/*
|
|
* unstructured pixrect ops
|
|
*/
|
|
pr_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
pr_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
pr_batchrop(dpr, x, y, op, items, n)
|
|
Pixrect *dpr;
|
|
int x, y, op, n;
|
|
struct pr_prpos items[];
|
|
{ return 0; }
|
|
|
|
pr_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
pr_close(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
pr_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
pr_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
pr_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
pr_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
pr_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
pr_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
pr_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
pr_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
|
|
/*
|
|
* structured pixrect ops
|
|
*/
|
|
|
|
prs_rop(dstreg, op, srcprpos)
|
|
struct pr_subregion dstreg;
|
|
int op;
|
|
struct pr_prpos srcprpos;
|
|
{ return 0; }
|
|
|
|
prs_stencil(dstreg, op, stenprpos, srcprpos)
|
|
struct pr_subregion dstreg;
|
|
int op;
|
|
struct pr_prpos stenprpos, srcprpos;
|
|
{ return 0; }
|
|
|
|
prs_batchrop(dstprpos, op, items, n)
|
|
struct pr_prpos dstprpos, items[];
|
|
int op, n;
|
|
{ return 0; }
|
|
|
|
prs_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
prs_get(srcprpos)
|
|
struct pr_prpos srcprpos;
|
|
{ return 0; }
|
|
|
|
prs_put(dstprpos, val)
|
|
struct pr_prpos dstprpos;
|
|
int val;
|
|
{ return 0; }
|
|
|
|
prs_vector(pr, pos0, pos1, op, color)
|
|
Pixrect *pr;
|
|
struct pr_pos pos0, pos1;
|
|
int op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
prs_region(dstreg)
|
|
struct pr_subregion dstreg;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
prs_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
prs_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
prs_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
prs_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
/*
|
|
* non-ops vector
|
|
*/
|
|
|
|
pr_line(pr, x0, y0, x1, y1, brush, tex, op)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1;
|
|
struct pr_brush *brush;
|
|
Pr_texture *tex;
|
|
{ return 0; }
|
|
|
|
pr_polygon_2(dpr, dx, dy, nbnds, npts, vlist, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, nbnds, npts[], op, sx, sy;
|
|
struct pr_pos *vlist;
|
|
{ return 0; }
|
|
|
|
pr_polyline(pr, dx, dy, npts, ptlist, mvlist, brush, tex, op)
|
|
Pixrect *pr;
|
|
int dx, dy, npts;
|
|
struct pr_pos *ptlist;
|
|
u_char *mvlist;
|
|
struct pr_brush *brush;
|
|
Pr_texture *tex;
|
|
{ return 0; }
|
|
|
|
pr_polypoint(pr, x, y, n, ptlist, op)
|
|
Pixrect *pr;
|
|
int x, y, n, op;
|
|
struct pr_pos *ptlist;
|
|
{ return 0; }
|
|
|
|
pr_replrop(dpr, dx, dy, dw, dh, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, dw, dh, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
prs_replrop(dstreg, op, srcprpos)
|
|
struct pr_subregion dstreg;
|
|
int op;
|
|
struct pr_prpos srcprpos;
|
|
{ return 0; }
|
|
|
|
pr_texvec(pr, x0, y0, x1, y1, tex, op)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op;
|
|
Pr_texture *tex;
|
|
{ return 0; }
|
|
|
|
pr_traprop(dpr, dx, dy, t, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, op, sx, sy;
|
|
struct pr_trap t;
|
|
{ return 0; }
|
|
|
|
/*
|
|
* undocumented
|
|
*/
|
|
|
|
pr_getfbtype_from_fd(fd)
|
|
int fd;
|
|
{ return 0; }
|
|
|
|
pr_gen_batchrop(dpr, dx, dy, op, src, count)
|
|
Pixrect *dpr;
|
|
int dx, dy, op, count;
|
|
struct pr_prpos *src;
|
|
{ return 0; }
|
|
|
|
/*
|
|
* monochrome colormaps
|
|
*/
|
|
pr_blackonwhite(pr, min, max)
|
|
Pixrect *pr;
|
|
int min, max;
|
|
{ return 0; }
|
|
|
|
pr_whiteonblack(pr, min, max)
|
|
Pixrect *pr;
|
|
int min, max;
|
|
{ return 0; }
|
|
|
|
pr_reversevideo(pr, min, max)
|
|
Pixrect *pr;
|
|
int min, max;
|
|
{ return 0; }
|
|
|
|
/*
|
|
* plane groups
|
|
*/
|
|
pr_available_plane_groups(pr, maxgroups, groups)
|
|
Pixrect *pr;
|
|
int maxgroups;
|
|
char *groups;
|
|
{ return 0; }
|
|
|
|
pr_get_plane_group(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
void
|
|
pr_set_plane_group(pr, group)
|
|
Pixrect *pr;
|
|
int group;
|
|
{ return; }
|
|
|
|
void
|
|
pr_set_planes(pr, group, planes)
|
|
Pixrect *pr;
|
|
int group, planes;
|
|
{ return; }
|
|
|
|
/*
|
|
* double buffering
|
|
*/
|
|
|
|
pr_dbl_get(pr, attr)
|
|
Pixrect *pr;
|
|
int attr;
|
|
{ return 0; }
|
|
|
|
/*VARARGS2*/
|
|
pd_dbl_set(pr, attr)
|
|
Pixrect *pr;
|
|
int attr;
|
|
{ return 0; }
|
|
|
|
/*
|
|
* pixrect I/O
|
|
*/
|
|
|
|
pr_dump(input_pr, output, colormap, type, copy_flag)
|
|
Pixrect *input_pr;
|
|
FILE *output;
|
|
colormap_t *colormap;
|
|
int type, copy_flag;
|
|
{ return 0; }
|
|
|
|
pr_dump_header(output, rh, colormap)
|
|
FILE *output;
|
|
struct rasterfile *rh;
|
|
colormap_t *colormap;
|
|
{ return 0; }
|
|
|
|
pr_dump_image(pr, output, rh)
|
|
Pixrect *pr;
|
|
FILE *output;
|
|
struct rasterfile *rh;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
pr_dump_init(input_pr, rh, colormap, type, copy_flag)
|
|
Pixrect *input_pr;
|
|
struct rasterfile *rh;
|
|
colormap_t *colormap;
|
|
int type, copy_flag;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
Pixrect *
|
|
pr_load(input, colormap)
|
|
FILE *input;
|
|
colormap_t *colormap;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
pr_load_colormap(input, rh, colormap)
|
|
FILE *input;
|
|
struct rasterfile *rh;
|
|
colormap_t *colormap;
|
|
{ return 0; }
|
|
|
|
pr_load_header(input, rh)
|
|
FILE *input;
|
|
struct rasterfile *rh;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
pr_load_image(input, rh, colormap)
|
|
FILE *input;
|
|
struct rasterfile *rh;
|
|
colormap_t *colormap;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
Pixrect *
|
|
pr_load_std_image(input, rh, colormap)
|
|
FILE *input;
|
|
struct rasterfile *rh;
|
|
colormap_t *colormap;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
/*
|
|
* pixfonts
|
|
*/
|
|
|
|
Pixfont *
|
|
pf_open(fontname)
|
|
char *fontname;
|
|
{ return (Pixfont *) 0; }
|
|
|
|
Pixfont *
|
|
pf_open_private(fontname)
|
|
char *fontname;
|
|
{ return (Pixfont *) 0; }
|
|
|
|
Pixfont *
|
|
pf_default()
|
|
{ return (Pixfont *) 0; }
|
|
|
|
pf_close(pf)
|
|
Pixfont *pf;
|
|
{ return 0; }
|
|
|
|
pf_text(where, op, font, text)
|
|
struct pr_prpos where;
|
|
int op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
pf_ttext(where, op, font, text)
|
|
struct pr_prpos where;
|
|
int op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
struct pr_size
|
|
pf_textbatch(where, lengthp, font, text)
|
|
struct pr_prpos where[];
|
|
int *lengthp;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ static struct pr_size prs; return prs; }
|
|
|
|
pf_textbound(bound, len, font, text)
|
|
struct pr_subregion *bound;
|
|
int len;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
struct pr_size
|
|
pf_textwidth(len, font, text)
|
|
int len;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ static struct pr_size prs; return prs; }
|
|
|
|
pr_text(pr, x, y, op, font, text)
|
|
Pixrect *pr;
|
|
int x, y, op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
pr_ttext(pr, x, y, op, font, text)
|
|
Pixrect *pr;
|
|
int x, y, op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
prs_text(where, op, font, text)
|
|
struct pr_prpos where;
|
|
int op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
prs_ttext(where, op, font, text)
|
|
struct pr_prpos where;
|
|
int op;
|
|
Pixfont *font;
|
|
char *text;
|
|
{ return 0; }
|
|
|
|
/* pixrect implementation */
|
|
|
|
char pr_reversedst[16];
|
|
char pr_reversesrc[16];
|
|
|
|
pr_clip(dstsubregion, srcprpos)
|
|
struct pr_subregion *dstsubregion;
|
|
struct pr_prpos *srcprpos;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
pr_makefromfd(fd, size, depth, devdata, curdd,
|
|
mmapbytes, privdatabytes, mmapoffsetbytes)
|
|
int fd;
|
|
struct pr_size size;
|
|
int depth;
|
|
struct pr_devdata **devdata, **curdd;
|
|
int mmapbytes, privdatabytes, mmapoffsetbytes;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
pr_unmakefromfd(fd, devdata)
|
|
struct pr_devdata **devdata;
|
|
int fd;
|
|
{ return 0; }
|
|
|
|
|
|
/*
|
|
* Global data
|
|
*/
|
|
|
|
short pr_tex_dotted[1];
|
|
short pr_tex_dashed[1];
|
|
short pr_tex_dashdot[1];
|
|
short pr_tex_dashdotdotted[1];
|
|
short pr_tex_longdashed[1];
|
|
/* bw2_lint.c 1.1 of 10/31/94
|
|
* @(#)bw2_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* bw2 specific functions */
|
|
|
|
Pixrect *
|
|
bw2_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
bw2_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
/* cg2_lint.c 1.1 of 10/31/94
|
|
* @(#)cg2_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* cg2 specific functions */
|
|
|
|
Pixrect *
|
|
cg2_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg2_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg2_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg2_batchrop(dpr, x, y, op, items, n)
|
|
Pixrect *dpr;
|
|
int x, y, op, n;
|
|
struct pr_prpos items[];
|
|
{ return 0; }
|
|
|
|
cg2_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
cg2_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
cg2_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
cg2_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg2_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg2_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg2_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg2_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg2_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
/*
|
|
* @(#)cg3_lint.c 1.1 94/10/31 SMI
|
|
*/
|
|
|
|
#ifndef LINT_INCLUDE
|
|
#include <sys/types.h>
|
|
#include <pixrect/pixrect.h>
|
|
#include <pixrect/cg3var.h>
|
|
#endif LINT_INCLUDE
|
|
|
|
struct pixrectops cg3_ops;
|
|
|
|
Pixrect *
|
|
cg3_make(w, h, depth)
|
|
int w, h, depth;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg3_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg3_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg3_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg3_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
/* cg4_lint.c 1.1 of 10/31/94
|
|
* @(#)cg4_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* cg4 specific functions */
|
|
|
|
Pixrect *
|
|
cg4_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg4_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg4_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg4_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg4_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg4_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg4_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg4_ioctl(pr, cmd, data, flag)
|
|
Pixrect *pr;
|
|
int cmd;
|
|
char *data;
|
|
int flag;
|
|
{ return 0; }
|
|
/* @(#)cg6_lint.c 1.1 94/10/31 SMI */
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* cg6 specific functions */
|
|
|
|
Pixrect *
|
|
cg6_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg6_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg6_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg6_batchrop(dpr, x, y, op, items, n)
|
|
Pixrect *dpr;
|
|
int x, y, op, n;
|
|
struct pr_prpos items[];
|
|
{ return 0; }
|
|
|
|
cg6_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
cg6_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
cg6_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
cg6_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg6_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg6_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg6_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg6_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg6_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
/* @(#)cg8_lint.c 1.1 94/10/31 */
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* cg8 specific functions */
|
|
|
|
Pixrect *
|
|
cg8_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg8_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
cg8_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg8_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg8_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg8_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg8_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg8_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg8_ioctl(pr, cmd, data, flag)
|
|
Pixrect *pr;
|
|
int cmd;
|
|
char *data;
|
|
int flag;
|
|
{ return 0; }
|
|
/* "@(#)cg9_lint.c 1.1 94/10/31 SMI */
|
|
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif LINT_INCLUDE
|
|
|
|
|
|
/* cg9 specific functions */
|
|
|
|
Pixrect *
|
|
cg9_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg9_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
cg9_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg9_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg9_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg9_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
|
|
Pixrect *
|
|
cg9_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg9_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg9_ioctl(pr, cmd, data, flag)
|
|
Pixrect *pr;
|
|
int cmd;
|
|
char *data;
|
|
int flag;
|
|
{ return 0; }
|
|
/* @(#)cg12_lint.c 1.1 94/10/31 SMI */
|
|
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif LINT_INCLUDE
|
|
|
|
/* cg12 specific functions */
|
|
|
|
Pixrect *
|
|
cg12_make(fd, size, depth, attr)
|
|
int fd;
|
|
struct pr_size size;
|
|
int depth;
|
|
struct fbgattr *attr;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg12_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
cg12_batchrop(dpr, dx, dy, op, src, count)
|
|
Pixrect *dpr;
|
|
int dx, dy, op;
|
|
struct pr_prpos *src;
|
|
int count;
|
|
{ return 0; }
|
|
|
|
cg12_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg12_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
cg12_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg12_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
cg12_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return mem_get(pr, x, y); }
|
|
|
|
cg12_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
cg12_ioctl(pr, cmd, data, flag)
|
|
Pixrect *pr;
|
|
int cmd;
|
|
char *data;
|
|
int flag;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
cg12_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
cg12_replrop(dpr, dx, dy, dw, dh, op, spr, sx, sy)
|
|
Pixrect *dpr;
|
|
int dx, dy, dw, dh, op;
|
|
Pixrect *spr;
|
|
int sx, sy;
|
|
{ return 0; }
|
|
|
|
cg12_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
cg12_stencil(dpr, dx, dy, dw, dh, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr;
|
|
int dx, dy, dw, dh, op;
|
|
Pixrect *stpr;
|
|
int stx, sty;
|
|
Pixrect *spr;
|
|
int sx, sy;
|
|
{ return 0; }
|
|
|
|
cg12_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
/* gp1_lint.c 1.1 of 10/31/94
|
|
* @(#)gp1_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* gp1 specific functions */
|
|
|
|
Pixrect *
|
|
gp1_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
gp1_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
gp1_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
gp1_batchrop(dpr, x, y, op, items, n)
|
|
Pixrect *dpr;
|
|
int x, y, op, n;
|
|
struct pr_prpos items[];
|
|
{ return 0; }
|
|
|
|
gp1_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
gp1_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
gp1_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
gp1_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
gp1_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
gp1_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
gp1_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
gp1_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
gp1_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
gp1_line(pr, x0, y0, x1, y1, brush, tex, op)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1;
|
|
struct pr_brush *brush;
|
|
Pr_texture *tex;
|
|
{ return 0; }
|
|
|
|
gp1_polygon_2(dpr, dx, dy, nbnds, npts, vlist, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, nbnds, npts[], op, sx, sy;
|
|
struct pr_pos *vlist;
|
|
{ return 0; }
|
|
|
|
gp1_polyline(pr, dx, dy, npts, ptlist, mvlist, brush, tex, op)
|
|
Pixrect *pr;
|
|
int dx, dy, npts;
|
|
struct pr_pos *ptlist;
|
|
u_char *mvlist;
|
|
struct pr_brush *brush;
|
|
Pr_texture *tex;
|
|
{ return 0; }
|
|
|
|
gp1_replrop(dpr, dx, dy, dw, dh, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, dw, dh, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
gp1_ioctl(pr, cmd, data, flag)
|
|
Pixrect *pr;
|
|
int cmd;
|
|
char *data;
|
|
int flag;
|
|
{ return 0; }
|
|
|
|
/* gp1 low level functions */
|
|
|
|
gp1_alloc(shmem, nblocks, bitvec, minordev, fd)
|
|
caddr_t shmem;
|
|
int nblocks, minordev, fd;
|
|
unsigned int *bitvec;
|
|
{ return 0; }
|
|
|
|
gp1_post(shmem, offset, fd)
|
|
caddr_t shmem;
|
|
short offset;
|
|
int fd;
|
|
{ return 0; }
|
|
|
|
gp1_sync(shmem, fd)
|
|
caddr_t shmem;
|
|
int fd;
|
|
{ return 0; }
|
|
|
|
/* mem_lint.c 1.1 of 10/31/94
|
|
* @(#)mem_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* memory pixrect specific functions */
|
|
|
|
mem_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
mem_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
mem_batchrop(dpr, x, y, op, items, n)
|
|
Pixrect *dpr;
|
|
int x, y, op, n;
|
|
struct pr_prpos items[];
|
|
{ return 0; }
|
|
|
|
mem_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
mem_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
mem_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
mem_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
mem_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
mem_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
mem_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
mem_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
mem_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
/*
|
|
* memory pixrects
|
|
*/
|
|
|
|
struct pixrectops mem_ops;
|
|
|
|
Pixrect *
|
|
mem_create(w, h, depth)
|
|
int w, h, depth;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
Pixrect *
|
|
mem_point(w, h, depth, data)
|
|
int w, h, depth;
|
|
short *data;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
short *
|
|
_mprs_addr(memprs)
|
|
struct pr_prpos *memprs;
|
|
{ return (short *) 0; }
|
|
|
|
u_char *
|
|
_mprs8_addr(memprs)
|
|
struct pr_prpos *memprs;
|
|
{ return (u_char *) 0; }
|
|
|
|
_mprs_skew(memprs)
|
|
struct pr_prpos *memprs;
|
|
{ return 0; }
|
|
|
|
/* tv1_lint.c 1.1 of 10/31/94
|
|
* @(#)tv1_lint.c 1.1
|
|
*/
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* tv1 specific functions */
|
|
|
|
Pixrect *
|
|
tv1_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
tv1_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
tv1_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
tv1_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
tv1_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
tv1_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
tv1_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)gt_lint.c 1.1 94/10/31 SMI";
|
|
#endif
|
|
|
|
#ifndef LINT_INCLUDE
|
|
#define LINT_INCLUDE
|
|
#include <pixrect/pixrect_hs.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
/* gt specific functions */
|
|
|
|
Pixrect *
|
|
gt_make(fd, size, depth)
|
|
int fd, depth;
|
|
struct pr_size size;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
gt_rop(dpr, dx, dy, w, h, op, spr, sx, sy)
|
|
Pixrect *dpr, *spr;
|
|
int dx, dy, w, h, op, sx, sy;
|
|
{ return 0; }
|
|
|
|
gt_stencil(dpr, dx, dy, w, h, op, stpr, stx, sty, spr, sx, sy)
|
|
Pixrect *dpr, *stpr, *spr;
|
|
int dx, dy, w, h, op, stx, sty, sx, sy;
|
|
{ return 0; }
|
|
|
|
gt_destroy(pr)
|
|
Pixrect *pr;
|
|
{ return 0; }
|
|
|
|
gt_get(pr, x, y)
|
|
Pixrect *pr;
|
|
int x, y;
|
|
{ return 0; }
|
|
|
|
gt_put(pr, x, y, value)
|
|
Pixrect *pr;
|
|
int x, y, value;
|
|
{ return 0; }
|
|
|
|
gt_vector(pr, x0, y0, x1, y1, op, color)
|
|
Pixrect *pr;
|
|
int x0, y0, x1, y1, op, color;
|
|
{ return 0; }
|
|
|
|
Pixrect *
|
|
gt_region(pr, x, y, w, h)
|
|
Pixrect *pr;
|
|
int x, y, w, h;
|
|
{ return (Pixrect *) 0; }
|
|
|
|
gt_putcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
gt_getcolormap(pr, index, count, red, green, blue)
|
|
Pixrect *pr;
|
|
int index, count;
|
|
unsigned char red[], green[], blue[];
|
|
{ return 0; }
|
|
|
|
gt_putattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|
|
|
|
gt_getattributes(pr, planes)
|
|
Pixrect *pr;
|
|
int *planes;
|
|
{ return 0; }
|