R6.6 is the Xorg base-line

parents
This diff is collapsed.
This diff is collapsed.
/*\
* $Xorg: utils.c,v 1.5 2000/08/17 19:54:50 cpqbld Exp $
*
* COPYRIGHT 1990
* DIGITAL EQUIPMENT CORPORATION
* MAYNARD, MASSACHUSETTS
* ALL RIGHTS RESERVED.
*
* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
* SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
* DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE
* FOR ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED
* WARRANTY.
*
* IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
* RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
* ADDITION TO THAT SET FORTH ABOVE.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Digital Equipment Corporation not be
* used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission.
\*/
#include "utils.h"
#include <ctype.h>
#ifndef X_NOT_STDC_ENV
#include <stdlib.h>
#else
char *malloc();
#endif
/***====================================================================***/
Opaque
uAlloc(size)
unsigned size;
{
return((Opaque)malloc(size));
}
/***====================================================================***/
Opaque
uCalloc(n,size)
unsigned n;
unsigned size;
{
return((Opaque)calloc(n,size));
}
/***====================================================================***/
Opaque
uRealloc(old,newSize)
Opaque old;
unsigned newSize;
{
if (old==NULL)
return((Opaque)malloc(newSize));
else return((Opaque)realloc((char *)old,newSize));
}
/***====================================================================***/
Opaque
uRecalloc(old,nOld,nNew,itemSize)
Opaque old;
unsigned nOld;
unsigned nNew;
unsigned itemSize;
{
char *rtrn;
if (old==NULL)
rtrn= (char *)calloc(nNew,itemSize);
else {
rtrn= (char *)realloc((char *)old,nNew*itemSize);
if ((rtrn)&&(nNew>nOld)) {
bzero(&rtrn[nOld*itemSize],(nNew-nOld)*itemSize);
}
}
return (Opaque)rtrn;
}
/***====================================================================***/
void
uFree(ptr)
Opaque ptr;
{
if (ptr!=(Opaque)NULL)
free((char *)ptr);
return;
}
/***====================================================================***/
/*** FUNCTION ENTRY TRACKING ***/
/***====================================================================***/
static FILE *entryFile= stderr;
int uEntryLevel;
Boolean
uSetEntryFile(name)
char *name;
{
if ((entryFile!=NULL)&&(entryFile!=stderr)) {
fprintf(entryFile,"switching to %s\n",name?name:"stderr");
fclose(entryFile);
}
if (name!=NullString) entryFile= fopen(name,"w");
else entryFile= stderr;
if (entryFile==NULL) {
entryFile= stderr;
return(False);
}
return(True);
}
void
uEntry(l,s,a1,a2,a3,a4,a5,a6,a7,a8)
int l;
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
int i;
for (i=0;i<uEntryLevel;i++) {
putc(' ',entryFile);
}
fprintf(entryFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
uEntryLevel+= l;
return;
}
void
uExit(l,rtVal)
int l;
char * rtVal;
{
int i;
uEntryLevel-= l;
if (uEntryLevel<0) uEntryLevel= 0;
for (i=0;i<uEntryLevel;i++) {
putc(' ',entryFile);
}
fprintf(entryFile,"---> 0x%p\n",rtVal);
return;
}
/***====================================================================***/
/*** PRINT FUNCTIONS ***/
/***====================================================================***/
FILE *uDebugFile= stderr;
int uDebugIndentLevel= 0;
int uDebugIndentSize= 4;
Boolean
uSetDebugFile(name)
char *name;
{
if ((uDebugFile!=NULL)&&(uDebugFile!=stderr)) {
fprintf(uDebugFile,"switching to %s\n",name?name:"stderr");
fclose(uDebugFile);
}
if (name!=NullString) uDebugFile= fopen(name,"w");
else uDebugFile= stderr;
if (uDebugFile==NULL) {
uDebugFile= stderr;
return(False);
}
return(True);
}
void
uDebug(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
int i;
for (i=(uDebugIndentLevel*uDebugIndentSize);i>0;i--) {
putc(' ',uDebugFile);
}
fprintf(uDebugFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(uDebugFile);
return;
}
void
uDebugNOI(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(uDebugFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(uDebugFile);
return;
}
/***====================================================================***/
static FILE *errorFile= stderr;
Boolean
uSetErrorFile(name)
char *name;
{
if ((errorFile!=NULL)&&(errorFile!=stderr)) {
fprintf(errorFile,"switching to %s\n",name?name:"stderr");
fclose(errorFile);
}
if (name!=NullString) errorFile= fopen(name,"w");
else errorFile= stderr;
if (errorFile==NULL) {
errorFile= stderr;
return(False);
}
return(True);
}
void
uInformation(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(errorFile);
return;
}
/***====================================================================***/
void
uAction(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile," ");
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(errorFile);
return;
}
/***====================================================================***/
void
uWarning(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile,"Warning: ");
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(errorFile);
return;
}
/***====================================================================***/
void
uError(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile,"Error: ");
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(errorFile);
return;
}
/***====================================================================***/
void
uFatalError(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile,"Fatal Error: ");
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fprintf(errorFile," Exiting\n");
fflush(errorFile);
exit(1);
/* NOTREACHED */
}
/***====================================================================***/
void
uInternalError(s,a1,a2,a3,a4,a5,a6,a7,a8)
char *s;
Opaque a1,a2,a3,a4,a5,a6,a7,a8;
{
fprintf(errorFile,"Internal error: ");
fprintf(errorFile,s,a1,a2,a3,a4,a5,a6,a7,a8);
fflush(errorFile);
return;
}
/***====================================================================***/
#ifndef HAVE_STRDUP
char *
uStringDup(str)
char *str;
{
char *rtrn;
if (str==NULL)
return NULL;
rtrn= (char *)uAlloc(strlen(str)+1);
strcpy(rtrn,str);
return rtrn;
}
#endif
#ifndef HAVE_STRCASECMP
int
uStrCaseCmp(str1, str2)
char *str1, *str2;
{
char buf1[512],buf2[512];
char c, *s;
register int n;
for (n=0, s = buf1; (c = *str1++); n++) {
if (isupper(c))
c = tolower(c);
if (n>510)
break;
*s++ = c;
}
*s = '\0';
for (n=0, s = buf2; (c = *str2++); n++) {
if (isupper(c))
c = tolower(c);
if (n>510)
break;
*s++ = c;
}
*s = '\0';
return (strcmp(buf1, buf2));
}
int
uStrCasePrefix(prefix, str)
char *prefix, *str;
{
char c1;
char c2;
while (((c1=*prefix)!='\0')&&((c2=*str)!='\0')) {
if (isupper(c1)) c1= tolower(c1);
if (isupper(c2)) c2= tolower(c2);
if (c1!=c2)
return 0;
prefix++; str++;
}
if (c1!='\0')
return 0;
return 1;
}
#endif
#ifndef UTILS_H
#define UTILS_H 1
/*\
* $Xorg: utils.h,v 1.3 2000/08/17 19:54:50 cpqbld Exp $
*
* COPYRIGHT 1990
* DIGITAL EQUIPMENT CORPORATION
* MAYNARD, MASSACHUSETTS
* ALL RIGHTS RESERVED.
*
* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
* SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
* DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE
* FOR ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED
* WARRANTY.
*
* IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT
* RIGHTS, APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN
* ADDITION TO THAT SET FORTH ABOVE.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Digital Equipment Corporation not be
* used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission.
\*/
/***====================================================================***/
#include <stdio.h>
#include <X11/Xos.h>
#include <X11/Xfuncproto.h>
#include <X11/Xfuncs.h>
_XFUNCPROTOBEGIN
#ifndef NULL
#define NULL 0
#endif
#ifndef NUL
#define NUL '\0'
#endif
/***====================================================================***/
#ifndef OPAQUE_DEFINED
typedef void *Opaque;
#endif
#ifndef NullOpaque
#define NullOpaque ((Opaque)NULL)
#endif
#ifndef BOOLEAN_DEFINED
typedef char Boolean;
#endif
#ifndef True
#define True ((Boolean)1)
#define False ((Boolean)0)
#endif /* ndef True */
#define booleanText(b) ((b)?"True":"False")
#ifndef COMPARISON_DEFINED
typedef int Comparison;
#define Greater ((Comparison)1)
#define Equal ((Comparison)0)
#define Less ((Comparison)-1)
#define CannotCompare ((Comparison)-37)
#define comparisonText(c) ((c)?((c)<0?"Less":"Greater"):"Equal")
#endif
typedef union {
int i;
unsigned u;
void *p;
void *(*fp)();
} Union;
/***====================================================================***/
extern Opaque uAlloc(
#if NeedFunctionPrototypes
unsigned /* size */
#endif
);
extern Opaque uCalloc(
#if NeedFunctionPrototypes
unsigned /* n */,
unsigned /* size */
#endif
);
extern Opaque uRealloc(
#if NeedFunctionPrototypes
Opaque /* old */,
unsigned /* newSize */
#endif
);
extern Opaque uRecalloc(
#if NeedFunctionPrototypes
Opaque /* old */,
unsigned /* nOld */,
unsigned /* nNew */,
unsigned /* newSize */
#endif
);
extern void uFree(
#if NeedFunctionPrototypes
Opaque /* ptr */
#endif
);
#define uTypedAlloc(t) ((t *)uAlloc((unsigned)sizeof(t)))
#define uTypedCalloc(n,t) ((t *)uCalloc((unsigned)n,(unsigned)sizeof(t)))
#define uTypedRealloc(pO,n,t) ((t *)uRealloc((Opaque)pO,((unsigned)n)*sizeof(t)))
#define uTypedRecalloc(pO,o,n,t) ((t *)uRecalloc((Opaque)pO,((unsigned)o),((unsigned)n),sizeof(t)))
#if (defined mdHasAlloca) && (mdHasAlloca)
#define uTmpAlloc(n) ((Opaque)alloca((unsigned)n))
#define uTmpFree(p)
#else
#define uTmpAlloc(n) uAlloc(n)
#define uTmpFree(p) uFree(p)
#endif
/***====================================================================***/
extern Boolean uSetErrorFile(
#if NeedFunctionPrototypes
char * /* name */
#endif
);
extern void uInformation();
extern void uAction();
extern void uWarning();
extern void uError();
extern void uFatalError();
extern void uInternalError();
/***====================================================================***/
#define NullString ((char *)NULL)
#define uStringText(s) ((s)==NullString?"<NullString>":(s))
#define uStringEqual(s1,s2) (uStringCompare(s1,s2)==Equal)
#define uStringPrefix(p,s) (strncmp(p,s,strlen(p))==0)
#define uStringCompare(s1,s2) (strcmp(s1,s2))
#define uStrCaseEqual(s1,s2) (uStrCaseCmp(s1,s2)==0)
#ifdef HAVE_STRCASECMP
#define uStrCaseCmp(s1,s2) (strcasecmp(s1,s2))
#define uStrCasePrefix(p,s) (strncasecmp(p,s,strlen(p))==0)
#else
extern int uStrCaseCmp(
#if NeedFunctionPrototypes
char * /* s1 */,
char * /* s2 */
#endif
);
extern int uStrCasePrefix(
#if NeedFunctionPrototypes
char * /* p */,
char * /* str */
#endif
);
#endif
#ifdef HAVE_STRDUP
#define uStringDup(s1) (strdup(s1))
#else
extern char *uStringDup(
#if NeedFunctionPrototypes
char * /* s1 */
#endif
);
#endif
/***====================================================================***/
#ifdef ASSERTIONS_ON
#define uASSERT(where,why) \
{if (!(why)) uFatalError("assertion botched in %s ( why )\n",where);}
#else
#define uASSERT(where,why)
#endif
/***====================================================================***/
#ifndef DEBUG_VAR
#define DEBUG_VAR debugFlags
#endif
#ifdef DEBUG_VAR_NOT_LOCAL
extern
#endif
unsigned int DEBUG_VAR;
extern void uDebug();
extern void uDebugNOI(); /* no indent */
extern Boolean uSetDebugFile(
#if NeedFunctionPrototypes
char *name
#endif
);
extern FILE *uDebugFile;
extern int uDebugIndentLevel;
extern int uDebugIndentSize;
#define uDebugIndent(l) (uDebugIndentLevel+=(l))
#define uDebugOutdent(l) (uDebugIndentLevel-=(l))
#ifdef DEBUG_ON
#define uDEBUG(f,s) { if (DEBUG_VAR&(f)) uDebug(s);}
#define uDEBUG1(f,s,a) { if (DEBUG_VAR&(f)) uDebug(s,a);}
#define uDEBUG2(f,s,a,b) { if (DEBUG_VAR&(f)) uDebug(s,a,b);}
#define uDEBUG3(f,s,a,b,c) { if (DEBUG_VAR&(f)) uDebug(s,a,b,c);}
#define uDEBUG4(f,s,a,b,c,d) { if (DEBUG_VAR&(f)) uDebug(s,a,b,c,d);}
#define uDEBUG5(f,s,a,b,c,d,e) { if (DEBUG_VAR&(f)) uDebug(s,a,b,c,d,e);}
#define uDEBUG_NOI(f,s) { if (DEBUG_VAR&(f)) uDebug(s);}
#define uDEBUG_NOI1(f,s,a) { if (DEBUG_VAR&(f)) uDebugNOI(s,a);}
#define uDEBUG_NOI2(f,s,a,b) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b);}
#define uDEBUG_NOI3(f,s,a,b,c) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c);}
#define uDEBUG_NOI4(f,s,a,b,c,d) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c,d);}
#define uDEBUG_NOI5(f,s,a,b,c,d,e) { if (DEBUG_VAR&(f)) uDebugNOI(s,a,b,c,d,e);}
#else
#define uDEBUG(f,s)
#define uDEBUG1(f,s,a)
#define uDEBUG2(f,s,a,b)
#define uDEBUG3(f,s,a,b,c)
#define uDEBUG4(f,s,a,b,c,d)
#define uDEBUG5(f,s,a,b,c,d,e)
#define uDEBUG_NOI(f,s)
#define uDEBUG_NOI1(f,s,a)
#define uDEBUG_NOI2(f,s,a,b)
#define uDEBUG_NOI3(f,s,a,b,c)
#define uDEBUG_NOI4(f,s,a,b,c,d)
#define uDEBUG_NOI5(f,s,a,b,c,d,e)
#endif
extern Boolean uSetEntryFile(
#if NeedFunctionPrototypes
char *name
#endif
);
extern void uEntry();
extern void uExit(
#if NeedFunctionPrototypes
int l,char *rtVal
#endif
);
#ifdef ENTRY_TRACKING_ON
#define ENTRY_BIT 0x10
#define LOW_ENTRY_BIT 0x1000
#define ENTER (DEBUG_VAR&ENTRY_BIT)
#define FLAG(fLag) (DEBUG_VAR&(fLag))
extern int uEntryLevel;
#define uENTRY(s) { if (ENTER) uEntry(1,s);}
#define uENTRY1(s,a) { if (ENTER) uEntry(1,s,a);}
#define uENTRY2(s,a,b) { if (ENTER) uEntry(1,s,a,b);}
#define uENTRY3(s,a,b,c) { if (ENTER) uEntry(1,s,a,b,c);}
#define uENTRY4(s,a,b,c,d) { if (ENTER) uEntry(1,s,a,b,c,d);}
#define uENTRY5(s,a,b,c,d,e) { if (ENTER) uEntry(1,s,a,b,c,d,e);}
#define uENTRY6(s,a,b,c,d,e,f) { if (ENTER) uEntry(1,s,a,b,c,d,e,f);}
#define uENTRY7(s,a,b,c,d,e,f,g) { if (ENTER) uEntry(1,s,a,b,c,d,e,f,g);}
#define uRETURN(v) { if (ENTER) uEntryLevel--; return(v); }
#define uVOIDRETURN { if (ENTER) uEntryLevel--; return; }
#define uFLAG_ENTRY(w,s) { if (FLAG(w)) uEntry(0,s);}
#define uFLAG_ENTRY1(w,s,a) { if (FLAG(w)) uEntry(0,s,a);}
#define uFLAG_ENTRY2(w,s,a,b) { if (FLAG(w)) uEntry(0,s,a,b);}
#define uFLAG_ENTRY3(w,s,a,b,c) { if (FLAG(w)) uEntry(0,s,a,b,c);}
#define uFLAG_ENTRY4(w,s,a,b,c,d) { if (FLAG(w)) uEntry(0,s,a,b,c,d);}
#define uFLAG_ENTRY5(w,s,a,b,c,d,e) { if (FLAG(w)) uEntry(0,s,a,b,c,d,e);}
#define uFLAG_ENTRY6(w,s,a,b,c,d,e,f) { if (FLAG(w)) uEntry(0,s,a,b,c,d,e,f);}
#define uFLAG_ENTRY7(w,s,a,b,c,d,e,f,g) { if(FLAG(w))uEntry(0,s,a,b,c,d,e,f,g);}
#define uFLAG_RETURN(v) { return(v);}
#define uFLAG_VOIDRETURN { return; }
#else
#define uENTRY(s)
#define uENTRY1(s,a)
#define uENTRY2(s,a1,a2)
#define uENTRY3(s,a1,a2,a3)
#define uENTRY4(s,a1,a2,a3,a4)
#define uENTRY5(s,a1,a2,a3,a4,a5)
#define uENTRY6(s,a1,a2,a3,a4,a5,a6)
#define uENTRY7(s,a1,a2,a3,a4,a5,a6,a7)
#define uRETURN(v) { return(v); }
#define uVOIDRETURN { return; }
#define uFLAG_ENTRY(f,s)
#define uFLAG_ENTRY1(f,s,a)
#define uFLAG_ENTRY2(f,s,a,b)
#define uFLAG_ENTRY3(f,s,a,b,c)
#define uFLAG_ENTRY4(f,s,a,b,c,d)
#define uFLAG_ENTRY5(f,s,a,b,c,d,e)
#define uFLAG_ENTRY6(f,s,a,b,c,d,e,g)
#define uFLAG_ENTRY7(f,s,a,b,c,d,e,g,h)
#define uFLAG_RETURN(v) { return(v);}
#define uFLAG_VOIDRETURN { return; }
#endif
_XFUNCPROTOEND
#endif /* UTILS_H */
This diff is collapsed.
#ifndef _XKBPRINT_H_
#define _XKBPRINT_H_ 1
/* $Xorg: xkbprint.h,v 1.3 2000/08/17 19:54:50 cpqbld Exp $ */
/************************************************************
Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc.
Permission to use, copy, modify, and distribute this
software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting
documentation, and that the name of Silicon Graphics not be
used in advertising or publicity pertaining to distribution
of the software without specific prior written permission.
Silicon Graphics makes no representation about the suitability
of this software for any purpose. It is provided "as is"
without any express or implied warranty.
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
THE USE OR PERFORMANCE OF THIS SOFTWARE.
********************************************************/
#define LABEL_AUTO -1
#define LABEL_NONE 0
#define LABEL_KEYNAME 1
#define LABEL_KEYCODE 2
#define LABEL_SYMBOLS 3
#define NO_SYMBOLS 0
#define COMMON_SYMBOLS 1
#define ALL_SYMBOLS 2
typedef struct _XKBPrintArgs {
int copies;
int grid;
int label;
int baseLabelGroup;
int nLabelGroups;
int nTotalGroups;
int nKBPerPage;
int labelLevel;
int wantSymbols;
Bool wantKeycodes;
Bool wantDiffs;
Bool scaleToFit;
Bool wantColor;
Bool level1;
Bool wantEPS;
} XKBPrintArgs;
extern Bool
DumpInternalFont(
#if NeedFunctionPrototypes
FILE * /* out */,
char * /* fontName */
#endif
);
extern Bool
GeometryToPostScript(
#if NeedFunctionPrototypes
FILE * /* out */,
XkbFileInfo * /* result */,
XKBPrintArgs * /* args */
#endif
);
#endif /* _XKBPRINT_H_ */
.\" $Xorg: xkbprint.man,v 1.3 2000/08/17 19:54:50 cpqbld Exp $
.TH XKBPRINT 1 "Release 6.4" "X Version 11"
.SH NAME
xkbprint \- print an XKB keyboard description
.SH SYNOPSIS
.B xkbprint
[options] source [ output_file ]
.SH DESCRIPTION
.PP
The
.I xkbprint
comman generates a printable or encapsulated PostScript description of the
XKB keyboard description specifed by \fIsource\fP. The \fIsource\fP can be
any compiled keymap (.xkm) file that includes a geometry description or an
X display specification. If an \fIoutput_file\fP is specified, xkbprint
writes to it. If no output file is specified, xkbprint creates replaces