#ifndef lint
static char sccsid[] = "@(#)llib-lcore 1.5 84/04/20 Copyr 1984 Sun Micro";
#endif


/*
 * Copyright (c) 1984 by Sun Microsystems, Inc.
 */

/* LINTLIBRARY */
/* For libcore.a */

#include <usercore.h>

set_drag( drag) 
	int drag; {return(0);}

set_line_index(color) 
	int color; {return(0);}

set_fill_index(color) 
	int color; {return(0);}

set_text_index(color) 
	int color; {return(0);}

set_linestyle(linestyl) 
	int linestyl; {return(0);}

set_polygon_interior_style(polyintstyl) 
	int polyintstyl; {return(0);}

set_polygon_edge_style(polyedgstyl) 
	int polyedgstyl; {return(0);}

set_linewidth( linwidth) 
	float linwidth; {return(0);}

set_pen(pen) 
	int pen; {return(0);}

set_font(font) 
	int font; {return(0);}

set_charsize(chwidth,cheight) 
	float chwidth,cheight; {return(0);}

set_charup_3(dx,dy,dz) 
	float dx,dy,dz; {return(0);}

set_charup_2(dx,dy) 
	float dx,dy; {return(0);}

set_charpath_2(dx,dy) 
	float dx,dy; {return(0);}

set_charpath_3(dx,dy,dz) 
	float dx,dy,dz; {return(0);}

set_charspace(space) 
	float space; {return(0);}

set_charjust(chjust)
   int chjust; {return(0);} 

set_charprecision(chqualty)
   int chqualty; {return(0);} 

set_marker_symbol(mark) 
	int mark; {return(0);}

set_pick_id(pickid) 
	int pickid; {return(0);}

set_rasterop(flag) 
	int flag; {return(0);}

define_color_indices(surf, i1, i2, red, grn, blu)
	struct vwsurf *surf;  int i1, i2;  float *red, *grn, *blu; {return(0);}

set_primitive_attributes(defprim) 
struct {
   int lineindx, fillindx, textindx;
   int linestyl, polyintstyl, polyedgstyl;
   float linwidth;
   int pen, font;
   float charwidth, charheight;
   float charupx, charupy, charupz, charupw;
   float charpathx, charpathy, charpathz, charpathw;
   float charspacex, charspacey, charspacez, charspacew;
   int chjust, chqualty;
   int marker, pickid, rasterop;
   } *defprim;
	{return(0);} 

inquire_color_indices(surf, i1, i2, red, grn, blu)
	struct vwsurf *surf;  int i1, i2;  float *red, *grn, *blu; {return(0);}

inquire_line_index(color) 
	int *color; {return(0);}

inquire_fill_index(color) 
	int *color; {return(0);}

inquire_text_index(color) 
	int *color; {return(0);}

inquire_linestyle(linestyl) 
	int *linestyl; {return(0);}

inquire_polygon_interior_style(polyintstyl) 
	int *polyintstyl; {return(0);}

inquire_polygon_edge_style(polyedgstyl) 
	int *polyedgstyl; {return(0);}

inquire_linewidth(linwidth) 
	float *linwidth; {return(0);}

inquire_pen(pen) 
	int *pen; {return(0);}

inquire_font(font) 
	int *font; {return(0);}

inquire_charsize(chwidth,cheight) 
	float *chwidth,*cheight; {return(0);}

inquire_charup_3( dx, dy, dz) 
	float *dx,*dy,*dz; {return(0);}

inquire_charup_2( dx, dy) 
	float *dx,*dy; {return(0);}

inquire_charpath_3( dx, dy, dz) 
	float *dx,*dy,*dz; {return(0);}

inquire_charpath_2( dx, dy) 
	float *dx,*dy; {return(0);}

inquire_charspace(space) 
	float *space; {return(0);}

inquire_charjust(chjust) 
	int *chjust; {return(0);}

inquire_charprecision(chqualty) 
	int *chqualty; {return(0);}

inquire_marker_symbol(mark) 
	int *mark; {return(0);}
   
inquire_pick_id(pickid) 
	int *pickid; {return(0);}

inquire_rasterop(rasterop) 
	int *rasterop; {return(0);}

inquire_primitive_attributes(defprim)
struct {
   int lineindx, fillindx, textindx;
   int linestyl, polyintstyl, polyedgstyl;
   float linwidth;
   int pen, font;
   float charwidth, charheight;
   float charupx, charupy, charupz, charupw;
   float charpathx, charpathy, charpathz, charpathw;
   float charspacex, charspacey, charspacez, charspacew;
   int chjust, chqualty;
   int marker, pickid, rasterop;
   } *defprim;
	{return(0);}

initialize_view_surface(surfname, type) 
	struct vwsurf *surfname; int type; {return(0);}

get_view_surface(vsptr,argv)
	struct vwsurf *vsptr; char **argv; {return(0);}

select_view_surface(surfname) 
	struct vwsurf *surfname; {return(0);}

deselect_view_surface(surfname) 
	struct vwsurf *surfname; {return(0);}

terminate_view_surface(surfname) 
	struct vwsurf *surfname; {return(0);}

text(string) 
	char *string; { return(0);   }

marker_abs_2(mx,my) 
	float mx,my; {return(0);}

marker_rel_2(dx,dy) 
	float dx,dy; {return(0);}

polymarker_abs_2(xcoord,ycoord,n) 
	float xcoord[],ycoord[]; short n; {return(0);}

polymarker_rel_2(xcoord,ycoord,n) 
	float xcoord[],ycoord[]; int n; {return(0);}

marker_abs_3(mx,my,mz) 
	float mx,my,mz; {return(0); }

marker_rel_3(dx,dy,dz) 
	float dx,dy,dz; {return(0); }

polymarker_abs_3(xcoord,ycoord,zcoord,n)
	float xcoord[],ycoord[],zcoord[]; int n; {return(0);}

polymarker_rel_3(xcoord,ycoord,zcoord,n)
	float xcoord[],ycoord[],zcoord[]; int n; {return(0);}

inquire_text_extent_3( s, dx, dy, dz) 
	char *s; float *dx,*dy,*dz; {return(0);}

inquire_text_extent_2( s, dx, dy) 
	char *s; float *dx,*dy; {return(0);}

inquire_current_position_2(x,y) 
	float *x,*y; {return(0);}

line_abs_2(x,y) 
	float x,y; {return(0);}

line_rel_2(dx,dy) 
	float dx,dy; {return(0);}

move_abs_2(x,y) 
	float x,y; {return(0);}

move_rel_2(dx,dy) 
	float dx,dy; {return(0);}

polyline_abs_2(xcoord,ycoord,n) 
	float xcoord[],ycoord[]; int n; {return(0);}

polyline_rel_2(xcoord,ycoord,n) 
	float xcoord[],ycoord[]; int n; {return(0);}

inquire_current_position_3(x,y,z) 
	float *x,*y,*z; {return(0);}

line_abs_3(x,y,z) 
	float x,y,z; {return(0);}

line_rel_3(dx,dy,dz) 
	float dx,dy,dz; {return(0);}

move_abs_3(x,y,z) 
	float x,y,z; {return(0);}

move_rel_3(dx,dy,dz) 
	float dx,dy,dz; {return(0);}

polyline_abs_3(xcoord,ycoord,zcoord,n) 
	float xcoord[],ycoord[],zcoord[]; int n; {return(0);}


polyline_rel_3(xcoord,ycoord,zcoord,n)
	float xcoord[],ycoord[],zcoord[]; int n; {return(0);}

initialize_device( devclass, devnum) 
	int devclass, devnum; {}

terminate_device( devclass, devnum) 
	int devclass, devnum; {}

get_mouse_state( devclass, devnum,  x, y, buttons) 
	int devclass, devnum; float *x, *y; int *buttons; {return(0);}

await_any_button( tim, butnum) 
	int tim;  int *butnum; {return(0);}

await_pick(tim, picknum, segnam, pickid) 
	int tim; int picknum, *segnam, *pickid; {return(0);}

await_keyboard( tim, keynum, string, length)
	int tim, keynum;  char *string;  int *length; {return(0);}
await_stroke_2( tim, strokenum, arrsize, xarray, yarray, numxy)
    int tim, strokenum, arrsize, *numxy; float xarray[], yarray[]; {return(0);}

await_any_button_get_locator_2( tim, locnum, butnum, x, y) 
	int tim, locnum, *butnum; float *x, *y; {return(0);}

await_any_button_get_valuator( tim, valnum, butnum, val) 
	int tim, valnum, *butnum;  float *val; {return(0);}


set_echo_group( class, devnum, n, echotype) 
	int class, devnum[], n, echotype; {}

set_echo( devclass, devnum, echotype) 
	int devclass, devnum, echotype; {return(0);}

set_echo_position( devclass, devnum, x, y) 
	int devclass, devnum; float x, y; {}

set_echo_surface( devclass, devnum, surfname)
	int devclass, devnum;  struct vwsurf *surfname; {}

set_locator_2( locnum, x, y) 
	int locnum; float x, y; {}

set_valuator( valnum, init, low, high) 
	int valnum; float init, low, high; {return(0);}

set_stroke( strokenum, bufsize, dist, time) 
	int strokenum, bufsize, time; float dist; {return(0);}

set_keyboard( keynum, bufsize, istr, pos) 
	int keynum, bufsize, pos; char *istr; {return(0);}

inquire_echo( devclass, devnum, echotype) 
	int devclass, devnum, *echotype; {}

inquire_echo_position( devclass, devnum, x, y)
	int devclass, devnum; float *x, *y; {}

inquire_echo_surface( devclass, devnum, surfname)
	int devclass, devnum;  struct vwsurf *surfname; {}

inquire_locator_2( locnum, x, y) 
	int locnum; float *x, *y; {}

inquire_valuator( valnum, init, low, high) 
	int valnum; float *init, *low, *high; {}

inquire_stroke( strokenum, bufsize, dist, time)
	    int strokenum, *bufsize, *time; float *dist; {}

inquire_keyboard( keynum, bufsize, istr, pos)
    int keynum, *bufsize, *pos; char *istr; {return(0);}

polygon_rel_2( xlist, ylist, n) 
	float *xlist, *ylist;  short n; {return (0);}

polygon_abs_2( xlist, ylist, n) 
	float *xlist, *ylist;  short n; {return (0);}

set_shading_parameters( amb, dif, spec, flood, bump, hue, style)
	float amb, dif, spec, flood, bump; int  hue, style; {}

set_light_direction( dx, dy, dz) 
	float dx, dy, dz; {return(0);}

set_vertex_indices( indxlist, n)
	int *indxlist, n; {return(0);}

set_vertex_normals( dxlist, dylist, dzlist, n)
	float *dxlist, *dylist, *dzlist; int n; {return(0);}

polygon_rel_3( xlist, ylist, zlist, n) 
	float *xlist, *ylist, *zlist;  int n; {return(0);}

polygon_abs_3( xlist, ylist, zlist, n) 
	float *xlist, *ylist, *zlist;  int n; {return(0);}

free_raster( rptr) 
struct {
	int width, height, depth;
	short *bits;
	} *rptr;
	{}

get_raster( surfname, xmin, xmax, ymin, ymax, xd, yd, raster)
struct vwsurf *surfname;
float xmin, ymin, xmax, ymax;int xd, yd;
struct {
	int width, height, depth;
	short *bits;
	} *raster;
	{return(0);}

put_raster( srast) 
struct {
	int width, height, depth;
	short *bits;
	} *srast;
	{return(0);}

size_raster( surfname, xmin, xmax, ymin, ymax, raster)
struct vwsurf *surfname;
float xmin, ymin, xmax, ymax;
struct {
	int width, height, depth;
	short *bits;
	} *raster;
	{return(0);}

allocate_raster( rptr) 
struct {
	int width, height, depth;
	short *bits;
	} *rptr;
	{return(0);}

raster_to_file( raster, map, rasfid, n)
struct {
	int width, height, depth;
	short *bits;
	} *raster;
struct {
	int type, nbytes;
	char *data;
	} *map;
int rasfid, n;
	{return(0);}

file_to_raster( rasfid, raster, map)
int rasfid;
struct {
	int width, height, depth;
	short *bits;
	} *raster;
struct {
	int type, nbytes;
	char *data;
	} *map;
	{return(0);}

set_zbuffer_cut(surf, xarr, zarr, n) 
	struct vwsurf *surf; float xarr[], zarr[];  int n; {return(0);}

delete_retained_segment(segname) 
	int segname; {return(0);}

delete_all_retained_segments()
	{return(0);}

rename_retained_segment(segname,newname) 
	int segname, newname; {return(0);}

set_image_transformation_type(type) 
	int type; {return(0);}

create_retained_segment(segname) 
	int segname; {return(0);}

create_temporary_segment()
	{return(0);}

close_temporary_segment()
	{return(0);}

close_retained_segment()
	{return(0);}

set_segment_image_transformation_3(segname,sx,sy,sz,rx,ry,rz,tx,ty,tz)
	int segname; float sx,sy,sz,rx,ry,rz,tx,ty,tz; {return(0);}

set_segment_image_translate_3(segname,dx,dy,dz)
	int segname; float dx,dy,dz; {return(0);}

inquire_segment_image_transformation_3(segname,sx,sy,sz,rx,ry,rz,tx,ty,tz)
	int segname; float *sx,*sy,*sz,*rx,*ry,*rz,*tx,*ty,*tz; {return(0);}

inquire_segment_image_translate_3(segname,tx,ty,tz)
	int segname; float *tx,*ty,*tz; {return(0);}

set_segment_visibility(segname,visbilty) 
	int segname; int visbilty; {return(0);}

set_segment_detectability(segname,detectbl) 
	int segname; int detectbl; {return(0);}

set_segment_highlighting(segname,highlght) 
	int segname; int highlght; {return(0);}

set_segment_image_transformation_2(segname,sx,sy,a,tx,ty)
	int segname; float sx,sy,a,tx,ty; {return(0);}

set_segment_image_translate_2(segname,tx,ty) 
	int segname; float tx,ty;{return(0);}

inquire_segment_detectability(segname,detectbl) 
	int segname; int *detectbl; {return(0);}

inquire_segment_highlighting(segname,highlght) 
	int segname; int *highlght; {return(0);}

inquire_image_transformation_type(segtype) 
	int *segtype; {return(0);}

inquire_segment_visibility(segname,visbilty) 
	int segname; int *visbilty; {return(0);}

inquire_segment_image_transformation_2(segname,sx,sy,a,tx,ty)
	int segname; float *sx,*sy,*a,*tx,*ty; {return(0);}

inquire_segment_image_translate_2(segname,tx,ty)
	int segname; float *tx,*ty; {return(1);}

inquire_viewing_parameters(viewparm) 
struct {
      float vwrefpt[3];
      float vwplnorm[3];
      float viewdis;
      float frontdis;
      float backdis;
      int projtype;
      float projdir[3];
      float window[4];
      float vwupdir[3];
      float viewport[6];
      } *viewparm;
	{return(0);}

inquire_window(umin, umax, vmin, vmax)
	float *umin, *umax, *vmin, *vmax; {}

inquire_view_up_2(dx_up, dy_up)
	float *dx_up, *dy_up;	{}

inquire_ndc_space_2(width, height)
	float *width, *height; {}

inquire_viewport_2(xmin, xmax, ymin, ymax)
	float *xmin, *xmax, *ymin, *ymax; {}

inquire_view_reference_point(x_ref, y_ref, z_ref)
	float *x_ref, *y_ref, *z_ref; {}

inquire_view_plane_normal(dx_norm, dy_norm, dz_norm)
	float *dx_norm, *dy_norm, *dz_norm; {}

inquire_view_plane_distance(view_distance)
	float *view_distance; {}

inquire_view_depth(front_distance, back_distance)
	float *front_distance, *back_distance; {}

inquire_projection(projection_type, dx_proj, dy_proj, dz_proj)
	int *projection_type; {}

inquire_view_up_3(dx_up, dy_up, dz_up)
	float *dx_up, *dy_up, *dz_up; {}

inquire_ndc_space_3(width, height, depth)
	float *width, *height, *depth; {}

inquire_viewport_3(xmin, xmax, ymin, ymax, zmin, zmax)
	float *xmin, *xmax, *ymin, *ymax, *zmin, *zmax; {}

inquire_inverse_composite_matrix(arrayptr) 
	float *arrayptr; {return(0);}

inquire_world_coordinate_matrix_2(arr) 
	float *arr; {return(0);}

inquire_world_coordinate_matrix_3(arrayptr) 
	float *arrayptr; {return(0);}

inquire_viewing_control_parameters(windowclip, frontclip, backclip, type)
	int *windowclip, *frontclip, *backclip, *type; {}

inquire_retained_segment_surfaces(segname,arraycnt,surfaray,surfnum)
	int segname,arraycnt; struct vwsurf surfaray[]; int *surfnum; {return(0);}

inquire_retained_segment_names(listcnt, seglist, segcnt)
   int seglist[],listcnt,*segcnt; {return(0);}

inquire_open_retained_segment( segname) 
	int *segname; {return(0);}

inquire_open_temporary_segment( open) 
	int *open; {return(0);}

begin_batch_of_updates()
	{return(0);}

end_batch_of_updates()
	{return(0);}

new_frame()
	{return(0);}

save_segment( segnum, filename) 
	int segnum; char *filename; {return(0);}

restore_segment( segname, filename) 
	int segname; char *filename; {return(0);}

set_ndc_space_2(width, height)
	float width, height; {return(0);}

set_ndc_space_3(width, height, depth)
	float width, height, depth; {return(0);}

set_viewing_parameters(viewparm)
struct {
      float vwrefpt[3];
      float vwplnorm[3];
      float viewdis;
      float frontdis;
      float backdis;
      int projtype;
      float projdir[3];
      float window[4];
      float vwupdir[3];
      float viewport[6];
      } *viewparm;
	{return(0);}

set_view_reference_point( x, y, z) 
	float x, y, z; {return(0);}

set_view_plane_normal( dx, dy, dz) 
	float dx, dy, dz; {return(0);}

set_view_plane_distance( dist) 
	float dist; {return(0);}

set_view_up_2(dx,dy) 
	float dx, dy; {return(0);}

set_view_up_3( dx, dy, dz) 
	float dx, dy, dz; {return(0);}

set_window( umin, umax, vmin, vmax) 
	float umin, umax, vmin, vmax; {return(0);}

set_viewport_2( xmin, xmax, ymin, ymax) 
	float xmin, xmax, ymin, ymax; {return(0);}

set_viewport_3( xmin, xmax, ymin, ymax, zmin, zmax ) 
	float xmin, xmax, ymin, ymax, zmin, zmax; {return(0);}

set_view_depth( near, far) 
	float near, far; {return(0);}

set_projection( projtype, dx, dy, dz) 
	int projtype; float dx, dy, dz; {return(0);}

map_ndc_to_world_2(ndcx,ndcy,wldx,wldy)
	float ndcx,ndcy,*wldx,*wldy; {return(0);}

map_world_to_ndc_2(wldx,wldy,ndcx,ndcy) 
	float wldx,wldy,*ndcx,*ndcy; {return(0);}

map_ndc_to_world_3(ndcx,ndcy,ndcz,wldx,wldy,wldz)
	float ndcx,ndcy,ndcz, *wldx,*wldy,*wldz; {return(0);}

map_world_to_ndc_3(wldx,wldy,wldz,ndcx,ndcy,ndcz)
   float wldx,wldy,wldz,  *ndcx,*ndcy,*ndcz; {return(0);}

set_visibility(visibility)
	int visibility; {return(0);}

set_highlighting(highlighting)
	int highlighting; {return(0);}

set_detectability(detectability)
	int detectability; {return(0);}

set_image_translate_2(tx, ty)
	float tx, ty; {return(0);}

set_image_translate_3(tx, ty, tz)
	float tx, ty, tz; {return(0);}

set_image_transformation_2(sx, sy, a, tx, ty)
	float sx, sy, a, tx, ty; {return(0);}

set_image_transformation_3(sx, sy, sz, ax, ay, az, tx, ty, tz)
	float sx, sy, sz, ax, ay, az, tx, ty, tz; {return(0);}

inquire_visibility(visibility)
	int *visibility; {}

inquire_highlighting(highlighting)
	int *highlighting; {}

inquire_detectability(detectability)
	int *detectability; {}

inquire_image_translate_2(tx, ty)
	float *tx, *ty; {}

inquire_image_translate_3(tx, ty, tz)
	float *tx, *ty, *tz; {}

inquire_image_transformation_2(sx, sy, a, tx, ty)
	float *sx, *sy, *a, *tx, *ty; {}

inquire_image_transformation_3(sx, sy, sz, ax, ay, az, tx, ty, tz)
	float *sx, *sy, *sz, *ax, *ay, *az, *tx, *ty, *tz; {}

report_most_recent_error(error) 
	int *error; {return(0);}

print_error(string, error) 
	char *string; int error; {return(0);}

initialize_core( outlev, inlev, dim) 
	int outlev, inlev, dim; {return(0);}

terminate_core()
	{return(0);}

set_output_clipping(onoff) 
	int onoff; {return(0);}

set_window_clipping(onoff) 
	int onoff; {return(0);}

set_front_plane_clipping(onoff) 
	int onoff; {return(0);}

set_back_plane_clipping(onoff) 
	int onoff; {return(0);}

set_coordinate_system_type(type) 
	int type; {return(0);}

set_world_coordinate_matrix_2(array) 
	float *array; {}

set_world_coordinate_matrix_3(array) 
	float *array; {}
