diff options
Diffstat (limited to 'xc/config/pswrap')
| -rw-r--r-- | xc/config/pswrap/Imakefile | 21 | ||||
| -rw-r--r-- | xc/config/pswrap/lexer.l | 787 | ||||
| -rw-r--r-- | xc/config/pswrap/main.c | 232 | ||||
| -rw-r--r-- | xc/config/pswrap/psw.c | 1952 | ||||
| -rw-r--r-- | xc/config/pswrap/psw.h | 84 | ||||
| -rw-r--r-- | xc/config/pswrap/pswdict.c | 176 | ||||
| -rw-r--r-- | xc/config/pswrap/pswdict.h | 74 | ||||
| -rw-r--r-- | xc/config/pswrap/pswfile.c | 121 | ||||
| -rw-r--r-- | xc/config/pswrap/pswparser.y | 271 | ||||
| -rw-r--r-- | xc/config/pswrap/pswpriv.h | 129 | ||||
| -rw-r--r-- | xc/config/pswrap/pswrap.man | 141 | ||||
| -rw-r--r-- | xc/config/pswrap/pswsemantics.c | 574 | ||||
| -rw-r--r-- | xc/config/pswrap/pswsemantics.h | 63 | ||||
| -rw-r--r-- | xc/config/pswrap/pswstring.c | 135 | ||||
| -rw-r--r-- | xc/config/pswrap/pswtypes.h | 50 | ||||
| -rw-r--r-- | xc/config/pswrap/pswversion.h | 41 | ||||
| -rw-r--r-- | xc/config/pswrap/sysname_gen.c | 429 | ||||
| -rw-r--r-- | xc/config/pswrap/systemnames.c | 46 | ||||
| -rw-r--r-- | xc/config/pswrap/yyerror.c | 84 |
19 files changed, 5410 insertions, 0 deletions
diff --git a/xc/config/pswrap/Imakefile b/xc/config/pswrap/Imakefile new file mode 100644 index 000000000..36de5c172 --- /dev/null +++ b/xc/config/pswrap/Imakefile @@ -0,0 +1,21 @@ +XCOMM $XFree86: xc/config/pswrap/Imakefile,v 1.1 2000/02/13 00:12:28 dawes Exp $ + + FRIENDSDEF = -DFRIENDSFILE='"<DPS/dpsfriends.h>"' + DEFINES = -DXENVIRONMENT + DEPLIBS = + YFLAGS = -d + +SRCS = main.c pswdict.c pswfile.c yyerror.c \ + systemnames.c psw.c pswstring.c pswsemantics.c + +OBJS = main.o pswparser.o lexer.o pswdict.o pswfile.o yyerror.o \ + systemnames.o psw.o pswstring.o pswsemantics.o + +ComplexProgramTarget(pswrap) + +SpecialObjectRule(pswfile.o,NullParameter,$(FRIENDSDEF)) + +LexFile(lexer) + +YaccFile(pswparser,$(YFLAGS)) + diff --git a/xc/config/pswrap/lexer.l b/xc/config/pswrap/lexer.l new file mode 100644 index 000000000..7dd8b5ecc --- /dev/null +++ b/xc/config/pswrap/lexer.l @@ -0,0 +1,787 @@ +%{ +/* + * lexer.l + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86: xc/config/pswrap/lexer.l,v 1.6 2000/02/18 12:18:42 tsi Exp $ */ + +#include <ctype.h> +#include <stdlib.h> +#include "pswpriv.h" +#include "pswparser.h" + +#if defined(FLEX_SCANNER) && !defined(YY_FLEX_LEX_COMPAT) +int yylineno = 1; +#endif + +extern int outlineno; /* output line number */ + +extern int maxstring; /* max PS string length to scan (-s) */ +extern char *string_temp; /* buffer of that size for scanning strings */ +extern char *psw_malloc(); +extern void stringerr(); /* report string overflow */ +extern char *ifile; /* input file name for error messages */ + +static int parens = 0; /* current paren balancing */ +static char *sbody; /* cur pointer into string_temp */ +static int curleng = 0; /* current scanned string length */ +static int strlineno; /* start line of current string */ + +static int nonComment = true; /* are we outside C comments? */ +static int newLine = true; /* are we starting a new line? */ +static int hexstringerrs = 0; /* found an error in this hex string */ + +int errorCount = 0; /* number of non-fatal errors */ + +#ifdef PSWDEBUG +int lexdebug = 1; /* debug flag */ +#define DEBUGP(x) {if (lexdebug) { fprintf x ; };} +#else /* PSWDEBUG */ +#define DEBUGP(x) +#endif /* PSWDEBUG */ + +#undef YYLMAX +#define YYLMAX 16384 +%} + +%o 3500 +%a 2500 + +%START PS STR HEX DEF SUB + +DIGIT ([0-9]) +HEXDIGIT ([a-fA-F0-9]) +RADIXDIGIT ([a-zA-Z0-9]) +LETTER ([a-zA-Z]) +SIGN ([+-]) +EXP ([eE]{SIGN}?{DIGIT}+) +W ([ \t\n\r]) + +%% + +<PS>^defineps { /* inside a wrap - just a PS token */ + if (nonComment) { + newLine = false; + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + DEBUGP((stderr,"PSNAME ->%s\n",yytext)); + return PSNAME; + } +} + +<DEF>^defineps { /* treat as a C name inside the def part */ + if (nonComment) { + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + DEBUGP((stderr,"CNAME ->%s\n",yytext)); + return CNAME; + } +} + +<STR>^defineps { /* part of string text */ + register int i = yyleng; + register unsigned char *c = (unsigned char *) yytext; + + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + for (; i > 0; --i) *sbody++ = *c++; +} + +^{W}*defineps { /* start of a wrap definition */ + if (nonComment) { + BEGIN DEF; + DEBUGP((stderr,"DEFINEPS\n")); + return DEFINEPS; + } else ECHO; +} + +<PS>endps { /* end of a wrap */ + if (nonComment){ + if (newLine) { + newLine = false; + DEBUGP((stderr,"ENDPS\n")); + BEGIN 0; + return ENDPS; + } else { + DEBUGP((stderr,"PSNAME %s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + return PSNAME; + } + } +} + +<DEF>^endps { /* treat as a C name inside the def part? */ + if (nonComment) { + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + DEBUGP((stderr,"CNAME ->%s\n",yytext)); + return CNAME; + } +} + +<STR>^defineps { /* part of string text */ + register int i = yyleng; + register unsigned char *c = (unsigned char *) yytext; + + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + for (; i > 0; --i) *sbody++ = *c++; +} + +endps { /* BOGUS end of a wrap */ + if (nonComment) { + ErrIntro(yylineno); + fprintf(stderr,"endps without matching defineps\n"); + } else ECHO; +} + +%{ + /* real definition stuff */ +%} + +<DEF>"/*" { /* C comments on */ + nonComment = false; +} + +<DEF>"*/" { /* C comments off */ + nonComment = true; +} + +<DEF>"(" { /* formals start */ + if (nonComment) { + DEBUGP((stderr,"DEF ->(\n")); + return '('; + } +} + +<DEF>")" { /* formals end */ + if (nonComment) { + DEBUGP((stderr,"DEF ->)\n")); + BEGIN PS; + return ')'; + } +} + +<DEF>[|,;[\]*:] { /* special single chars */ + if (nonComment) { + DEBUGP((stderr,"DEF ->%c\n",yytext[0])); + return (yytext[0]); + } +} + +%{ + /* formals type names */ +%} + +<DEF>"static" { + if (nonComment) { + DEBUGP((stderr,"DEF ->static\n")); + return STATIC; + } +} + +<DEF>"boolean" { + if (nonComment) { + DEBUGP((stderr,"DEF ->boolean\n")); + return BOOLEAN; + } +} + +<DEF>"char" { + if (nonComment) { + DEBUGP((stderr,"DEF ->char\n")); + return CHAR; + } +} + +<DEF>"int" { + if (nonComment) { + DEBUGP((stderr,"DEF ->int\n")); + return INT; + } +} + +<DEF>"short" { + if (nonComment) { + DEBUGP((stderr,"DEF ->short\n")); + return SHORT; + } +} + +<DEF>"long" { + if (nonComment) { + DEBUGP((stderr,"DEF ->long\n")); + return LONG; + } +} + +<DEF>"unsigned" { + if (nonComment) { + DEBUGP((stderr,"DEF ->unsigned\n")); + return UNSIGNED; + } +} + +<DEF>"float" { + if (nonComment) { + DEBUGP((stderr,"DEF ->float\n")); + return FLOAT; + } +} + +<DEF>"double" { + if (nonComment) { + DEBUGP((stderr,"DEF ->double\n")); + return DOUBLE; + } +} + +<DEF>"userobject" { + if (nonComment) { + DEBUGP((stderr,"DEF ->userobject\n")); + return USEROBJECT; + } +} + +<DEF>"numstring" { + if (nonComment) { + DEBUGP((stderr,"DEF ->numstring\n")); + return NUMSTRING; + } +} + +<DEF>"DPSContext" { + if (nonComment) { + DEBUGP((stderr,"DEF ->DPScontext\n")); + return PSCONTEXT; + } +} + +%{ + /* C format numbers in formals part */ +%} + +<DEF>[1-9]{DIGIT}* { /* base 10 number */ + if (nonComment) { + DEBUGP((stderr,"DEF ->CINTEGER %s\n",yytext)); + yylval.intobj = atoi((char *) yytext); + return CINTEGER; + } +} + +<DEF>0{DIGIT}* { /* octal number (and zero) */ + if (nonComment) { + DEBUGP((stderr,"DEF ->CINTEGER %s\n",yytext)); + /* I have no idea why the cast is needed in the next line, + but it seems to make the compiler happy on alpha */ + sscanf((char *) yytext,"%lo",&yylval.intobj); + return CINTEGER; + } +} + +<DEF>0[xX]{HEXDIGIT}+ { /* hex number */ + if (nonComment) { + DEBUGP((stderr,"DEF ->CINTEGER %s\n",yytext)); + /* See previous comment... */ + sscanf((char *) yytext,"0x%lx",&yylval.intobj); + return CINTEGER; + } +} + +<DEF>[a-zA-Z_][a-zA-Z0-9_]* { /* C identifier */ + if (nonComment) { + DEBUGP((stderr,"DEF ->CNAME %s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + return CNAME; + } +} + +<DEF>{W}+ { +} + +<DEF>[^a-zA-Z0-9_|,;[\]*:\(\)/ \t\n\r]+ { /* all else - ERROR */ + if (nonComment) { + DEBUGP((stderr,"DEF ->JUNK %s\n",yytext)); + ErrIntro(yylineno); + fprintf(stderr,"invalid characters '%s' in definition\n", + yytext); + } +} + + +%{ + /* body part - PostScript code */ +%} + +<PS>\%.* { /* a PS comment, ignore */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"comment %s\n",yytext)); + /* yylval = yytext; return PSCOMMENT; */ + } +} + +<PS>{SIGN}?{DIGIT}+ { /* a decimal integer */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSINTEGER ->%s\n",yytext)); + yylval.intobj = atoi((char *) yytext); + return PSINTEGER; + } +} + +<PS>{DIGIT}+#{RADIXDIGIT}+ { /* a radix number */ +#define MAX_ULONG ((unsigned long) -1) + int base = 0; + unsigned char *s = (unsigned char *) yytext; + register unsigned long x, limit; + register unsigned long i = 0; + + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSINTEGER radix->%s\n",yytext)); + while (*s != '#') { + base *= 10; + base += *s++ - '0'; + if (base > 32) break; + } + + if ((base < 2) || (base > 36)) {goto error;} + else { + limit = MAX_ULONG / base; + s++; /* skip # sign */ + while (*s != '\0') { + if (i > limit) goto error; + i *= base; + if (isdigit(*s)) { x = *s - '0';} + else { x = (*s | 040) - ('a'-10);} + if (x >= base) goto error; + if (x > (MAX_ULONG - i)) goto error; + i += x; + s++; + } + } + yylval.intobj = i; + return PSINTEGER; + + error:; + ErrIntro(yylineno); + fprintf(stderr,"invalid radix number %s\n",yytext); + yylval.intobj = 0; /* ERROR */ + return PSINTEGER; + } +} + +<PS>(({SIGN}?{DIGIT}+(\.{DIGIT}*)?{EXP}?)|({SIGN}?{DIGIT}*\.{DIGIT}+{EXP}?)) { + /* a float */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSREAL ->%s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object,yytext); + return PSREAL; + } +} + +<PS>"(" { /* start PS string */ + if (nonComment) { + newLine = false; + BEGIN STR; + parens=1; + sbody = string_temp; + curleng = 0; + strlineno = yylineno; + *sbody = '\0'; + } +} + +%{ + /* inside PS strings */ +%} + +<STR>"(" { /* balancing parens */ + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + parens++; + *sbody++ = '('; +} + +<STR>")" { /* balancing parens or end string */ + if ((--parens) == 0) { + BEGIN PS; + *sbody = '\0'; + yylval.object = psw_malloc(strlen(string_temp) + 1); + strcpy(yylval.object, string_temp); + DEBUGP((stderr,"PSSTRING ->%s\n",string_temp)); + return PSSTRING; + } + else if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + *sbody++ = ')'; +} + +<STR>"\\"[0-7]([0-7]?)([0-7]?) { /* quoted octal byte */ + if (4 + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += 4; + sprintf(sbody,"\\%03.3s",(yytext + 1)); + sbody += 4; +} + + +<STR>"\\\n" { /* ignore quoted newline */ +} + +<STR>"\\\\" { /* keep quoted backslashes in */ + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + *sbody++ = '\\'; + *sbody++ = '\\'; + curleng += 2; +} + + +<STR>("\\".) { /* other quoted char, including parens */ + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + switch (yytext[1]) { + case 'b': + *sbody++ = '\b'; + break; + case 'f': + *sbody++ = '\f'; + break; + case 'n': + *sbody++ = '\012'; + break; + case 'r': + *sbody++ = '\015'; + break; + case 't': + *sbody++ = '\t'; + break; + default: + *sbody++ = yytext[1]; + break; + } + curleng++; +} + + +<STR>"\n" { /* newline in a string */ + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + + *sbody++ = '\n'; +} + +<STR>[^()\\\n]+ { /* anything else */ + register int i = yyleng; + register unsigned char *c = (unsigned char *) yytext; + + if (yyleng + curleng >= maxstring) { + stringerr(1); + BEGIN PS; + *sbody = '\0'; + return PSSTRING; + } + curleng += yyleng; + for (; i > 0; --i) *sbody++ = *c++; +} + +%{ + /* hexidecimal strings "< >" */ +%} + +<PS>"<" { /* begin hex string */ + if (nonComment) { + newLine = false; + BEGIN HEX; + sbody = string_temp; + *sbody = '\0'; + curleng = 0; + strlineno = yylineno; + hexstringerrs = 0; + } +} + +<HEX>{W}+ { /* hex whitespace */ + /* ignore */ +} + +<HEX>[0-9A-Fa-f]+ { /* hex string data */ + if (yyleng + curleng >= maxstring) { + stringerr(2); + *sbody = '\0'; + BEGIN PS; + return PSHEXSTRING; + } + curleng += yyleng; + strcpy(sbody,yytext); + sbody += yyleng; +} + +<HEX>">" { /* end hex string */ + BEGIN PS; + *sbody = '\0'; + DEBUGP((stderr,"PSHEXSTRING ->%s\n",string_temp)); + yylval.object = psw_malloc(strlen(string_temp) + 1); + strcpy(yylval.object, string_temp); + return PSHEXSTRING; +} + +<HEX>[^a-fA-F0-9> \t\n\r]+ { /* ERROR */ + if (hexstringerrs == 0) { /* only complain once per string */ + ErrIntro(yylineno); + fprintf(stderr,"invalid characters in hex string '%s'\n",yytext); + hexstringerrs++; + } +} + + +%{ + /* straight postscript */ +%} + +<PS>"<<" { /* just a PS token (for level 2 compatablity) */ + if (nonComment) { + newLine = false; + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + DEBUGP((stderr,"PSNAME ->%s\n",yytext)); + return PSNAME; + } +} + +<PS>">>" { /* just a PS token (for level 2 compatablity) */ + if (nonComment) { + newLine = false; + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + DEBUGP((stderr,"PSNAME ->%s\n",yytext)); + return PSNAME; + } +} + +<PS>[\[\]\{\}] { /* PS self delimiter */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PS ->%s\n",yytext)); + return (yytext[0]); + } +} + +<PS>"true"|"false" { /* boolean */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSBOOLEAN %s\n",yytext)); + yylval.intobj = (*yytext == 't'); + return PSBOOLEAN; + } +} + +<PS>"/"[^ <>\(\)\[\]\{\}\%\/\t\n\r]* { /* literal name */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSLITNAME %s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext)); + strcpy(yylval.object, yytext+1); + return PSLITNAME; + } +} + +<PS>[^ <>\(\)\[\]\{\}\%\/\\\t\n\r]+ { /* executable name */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PSNAME %s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext) + 1); + strcpy(yylval.object, yytext); + return PSNAME; + } +} + +<PS>"*/" { /* special case */ + if (nonComment) { + newLine = false; + unput('/'); + yylval.object = psw_malloc(2); + strcpy(yylval.object, "*"); + return PSNAME; + } +} + +<PS>"\\"[^ <>\(\)\[\]\{\}\%\/\\\t\n\r]+/"[" { /* \name[index] */ + if (nonComment) { + DEBUGP((stderr,"\\PSNAME %s\n",yytext)); + yylval.object = psw_malloc(strlen(yytext)); + strcpy(yylval.object, yytext+1); + BEGIN SUB; + return PSSUBNAME; + } +} + +<SUB>[\[][^ \t\]]*[\]] { /* [index] */ + if (nonComment) { + int len = strlen(yytext); + DEBUGP((stderr,"PSINDEX %s\n",yytext)); + if (len == 2) { + ErrIntro(yylineno); + fprintf(stderr,"parameter index expression empty\n"); + yylval.object = "0"; + } + else { + yylval.object = psw_malloc(len); + strncpy(yylval.object, yytext+1, len-2); + yylval.object[len-2] = '\0'; + } + BEGIN PS; + return PSINDEX; + } +} + +<SUB>[\[][^\]]*[\]] { /* error */ + if (nonComment) { + ErrIntro(yylineno); + fprintf(stderr,"parameter index expression error\n"); + yylval.object = "0"; + BEGIN PS; + return PSINDEX; + } +} + +<PS>[\)\>\\]+ { /* ERROR */ + if (nonComment) { + newLine = false; + DEBUGP((stderr,"PS JUNK ->%s\n",yytext)); + ErrIntro(yylineno); + fprintf(stderr,"invalid characters '%s'\n",yytext); + } +} + +<PS>[ \t\r]+ { } + +<PS>[\n]+ { + newLine = true; +} + +[ \t]+ { /* passthru stuff */ + ECHO; +} + +\n { + outlineno++; + ECHO; +}; + +"/*" { /* C comments on */ + nonComment = false; + ECHO; +} + +"*/" { /* C comments off */ + if (!nonComment) { + nonComment = true; + ECHO; + } +} + +%% + +int yywrap () { + if (!feof(yyin)) + return (0); +/* The following appears not to work with flex. As it is error + handling code, we just comment it out. */ +#if !defined(FLEX_SCANNER) + if (yybgin != (yysvec+1)) { /* make sure we are in state 0 */ + ErrIntro(yylineno); + fprintf(stderr,"end of input file/missing endps\n"); + } +#endif + return (1); +} + +void stringerr(type) + int type; +{ + extern char *currentPSWName; + extern char *ifile; + + ErrIntro(strlineno); + fprintf(stderr,"%sstring too long (caught at line %d)\n", + ((type==1)?"":"hex "),yylineno); + errorCount++; + return; +} diff --git a/xc/config/pswrap/main.c b/xc/config/pswrap/main.c new file mode 100644 index 000000000..7d940b45d --- /dev/null +++ b/xc/config/pswrap/main.c @@ -0,0 +1,232 @@ +/* + * main.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ +/* $XFree86: xc/config/pswrap/main.c,v 1.2 2000/02/18 12:18:43 tsi Exp $ */ + +#include <stdio.h> + +#ifdef XENVIRONMENT +#include <X11/Xos.h> +#else +#include <string.h> +#endif + +#define SLASH '/' +#include <ctype.h> +#include <stdlib.h> +#include "pswpriv.h" + +#define MIN_MAXSTRING 80 /* min allowable value of maxstring */ + +/* global data */ +char *prog; /* program name */ +char *hfile = NULL; /* name of -h file */ +char *ofile = NULL; /* name of -o file */ +char *ifile = NULL; /* name of input file */ +int gotInFile = 0; /* got an explicit input file name */ +int doANSI = 0; /* got -a (ansi) flag for -h file */ +int pad = 0; /* got -p (padding) flag */ +boolean noUserNames = false; /* got -n (don't use usernames) flag */ +int reentrant = 0; /* automatic vars for generated BOS */ +int bigFile = 0; /* got -b flag => call free */ +FILE *header; /* stream for -h file output */ +char headid[200]; /* id for header file #include */ +int maxstring = 2000; /* -s max string length to scan */ +char *string_temp; /* string buffer of above size */ +int outlineno = 1; /* output line number */ +int nWraps = 0; /* total number of wraps */ +#ifdef __MACH__ +char *shlibInclude = NULL; /* special file to be #included at top of */ + /* file. Used only when building shlibs */ +#endif /* __MACH__ */ + +extern char *psw_malloc(); +extern void InitWellKnownPSNames(); + +static void ScanArgs(); +static void Usage(); +static void FatalError(); + +main(argc,argv) +int argc; char *argv[]; +{ + extern int errorCount; /* non-fatal errs */ + int retval; /* return from yyparse */ + + ScanArgs(argc, argv); + + if (ifile == NULL) + ifile = "stdin"; + else { + gotInFile = 1; + if (freopen(ifile,"r",stdin) == NULL) + FatalError("can't open %s for input",ifile); + } + if ((string_temp = (char *) malloc((unsigned) (maxstring+1))) == 0) + FatalError("can't allocate %d char string; try a smaller -s value",maxstring); + if (ofile == NULL) + ofile = "stdout"; + else { +#ifdef __MACH__ + (void)unlink(ofile); +#endif /* __MACH__ */ + if (freopen(ofile,"w",stdout) == NULL) + FatalError("can't open %s for output",ofile); + } + InitOFile(); + + if (hfile != NULL) { +#ifdef __MACH__ + (void)unlink(hfile); +#endif /* __MACH__ */ + if ((header = fopen(hfile,"w")) == NULL) + FatalError("can't open %s for output",hfile); + } + if (header != NULL) InitHFile(); + + InitWellKnownPSNames(); + + if ((retval = yyparse()) != 0) + fprintf(stderr,"%s: error in parsing %s\n",prog,ifile); + else if (errorCount != 0) { + fprintf(stderr,"%s: errors were encountered\n",prog); + retval = errorCount; + } + + if (hfile != NULL) FinishHFile(); + + exit (retval); +} + +static void ScanArgs(argc, argv) + int argc; + char *argv[]; +{ + extern int lexdebug; /* debug flag for lexer */ + char *slash; /* index of last / in hfile */ + char *c; /* pointer into headid for conversion */ + int i = 0; + + prog = argv[i++]; + slash = rindex(prog,SLASH); + if (slash) + prog = slash + 1; + while (i < argc) { + if (*argv[i] != '-') { + if (ifile != NULL) Usage("Only one input file can be specified."); + else ifile = argv[i]; + } else { + switch (*(argv[i]+1)) { + case 'a': + doANSI++; + reentrant++; + break; + case 'b': + bigFile++; + break; +#ifdef PSWDEBUG + case 'd': + lexdebug++; + break; +#endif /* PSWDEBUG */ + case 'h': + hfile = argv[++i]; + slash = rindex(hfile,SLASH); + strcpy(headid, slash ? slash+1 : hfile); + for (c = headid; *c != '\0'; c++) { + if (*c == '.') *c = '_'; + else isascii(*c) && islower(*c) && (*c = toupper(*c)); + } + break; + case 'o': + ofile = argv[++i]; + break; + case 'r': + reentrant++; + break; + case 's': + if ((maxstring = atoi(argv[++i])) < MIN_MAXSTRING) { + fprintf(stderr,"%s: -s %d is the minimum\n", prog, MIN_MAXSTRING); + maxstring = MIN_MAXSTRING; + } + break; + case 'w': + break; +#ifdef __MACH__ + case 'S': + shlibInclude = argv[++i]; + break; +#endif /* __MACH__ */ + case 'n': + noUserNames = true; + break; + case 'p': + pad++; + break; + default: + Usage("bad option '-%c'", *(argv[i]+1)); + break; + } /* switch */ + } /* else */ + i++; + } /* while */ +} /* ScanArgs */ + +static void Usage(msg, arg1, arg2, arg3, arg4) + char *msg; +{ + fprintf(stderr,"%s: ", prog); + fprintf(stderr, msg, arg1, arg2, arg3, arg4); + fprintf(stderr,"\nUsage: pswrap [options] [input-file]\n"); + fprintf(stderr," -a produce ANSI C procedure prototypes\n"); + fprintf(stderr," -b process a big file\n"); + fprintf(stderr," -h filename specify header filename\n"); + fprintf(stderr," -o filename specify output C filename\n"); + fprintf(stderr," -r make wraps re-entrant\n"); + fprintf(stderr," -s length set maximum string length\n"); + exit(1); +} + +/* a - d are optional args for fprintf */ +static void FatalError(msg, a, b, c, d) + char *msg; +{ + fprintf(stderr,"%s: ", prog); + fprintf(stderr, msg, a, b, c, d); + fprintf(stderr, "\n"); + exit(1); +} /* FatalError */ diff --git a/xc/config/pswrap/psw.c b/xc/config/pswrap/psw.c new file mode 100644 index 000000000..c4839db94 --- /dev/null +++ b/xc/config/pswrap/psw.c @@ -0,0 +1,1952 @@ +/* + * psw.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +/***********/ +/* Imports */ +/***********/ + +#include <stdio.h> + +#ifdef XENVIRONMENT +#include <X11/Xos.h> +#else +#include <string.h> +#endif + +#include "pswdict.h" +#include "pswpriv.h" + +char *psw_malloc(); +char *psw_calloc(); + +extern FILE *header; +extern PSWDict wellKnownPSNames; +extern int PSWStringLength(); +extern int PSWHexStringLength(); +extern void PSWOutputStringChars(); +extern void PSWOutputHexStringChars(); +extern int outlineno; +extern int reentrant; +extern int maxstring; + +extern Token PSWToken(/* type, val */); + +extern int doANSI; /* -a flag */ +extern int pad; /* -p flag */ +extern boolean noUserNames; /* -n flag */ + +#define DPS_HEADER_SIZE 4 +#define DPS_LONG_HEADER_SIZE 8 +#define DPS_BINOBJ_SIZE 8 /* sizeof(DPSBinObjGeneric) */ +#define WORD_ALIGN 3 +#define HNUMTOKEN 149 +#define NUMSTR_HEADER_SIZE 4 +#define MAXSTRINGS 256 /* maximum number of non-duplcated strings */ + +#define datafil stdout /* send statics to stdout (with code) */ + +/********************/ +/* Global Variables */ +/********************/ + +/* Wrap-specific globals */ + +static char *ctxName; + +static TokenList nameTokens; +static int nNames; +static TokenList namedInputArrays, namedInputStrings; +static TokenList literalStrings; +static boolean writable; /* encoding is not constant */ +static boolean twoStatics; /* true if strings are separate from objects */ +static boolean large; +static int dpsHeaderSize; +static int stringBytes; + +/**************************/ +/* Procedure Declarations */ +/**************************/ + + +/**********************/ +/* Utility procedures */ + + +static void CantHappen() { + int *p; + fprintf(stderr, "CantHappen"); + /* now dump core with the following gross and disgusting kludge */ + p = (int *) (-1); + *p = 0; + } + +#define Assert(b) if (!(b)) CantHappen(); else ; + +#define SafeStrCpy(dst,src) \ + dst = psw_malloc(strlen(src)+1) , \ + strcpy(dst, src) + +static int NumArgs(args) Args args; { + register int n = 0; + register Arg arg; + register Item item; + for (arg = args; arg; arg = arg->next) + for (item = arg->items; item; item = item->next) + n++; + return n; + } + +static int NumTokens(body) register Body body; { + register int n = 0; + while (body) { n++; body = body->next; } + return n; + } + +static TokenList ConsToken (t, ll) Token t; TokenList ll; { + TokenList tt = (TokenList) psw_calloc(sizeof(TokenListRec), 1); + tt->token = t; + tt->next = ll; + return tt; + } + +static TokenList ConsNameToken (t, ll) Token t; TokenList ll; { + TokenList temp, tt = (TokenList) psw_calloc(sizeof(TokenListRec), 1); + + tt->token = t; + tt->next = ll; + if(ll == NULL) + return (tt); + temp = ll; + while((temp->next != NULL) && strcmp((char *)(temp->token->val), (char *)(t->val))) + temp = temp->next; + tt->next = temp->next; + temp->next = tt; + return (ll); + } + +static boolean IsCharType(t) Type t; { + return (t == T_CHAR || t == T_UCHAR); + } + +static boolean IsNumStrType(t) Type t; { + return (t == T_NUMSTR + || t == T_FLOATNUMSTR + || t == T_LONGNUMSTR + || t == T_SHORTNUMSTR); +} + +static boolean IsPadNumStrType(t) Type t; { + return (t == T_NUMSTR || t == T_SHORTNUMSTR); +} + +/*************************/ +/* Type-code conversions */ + +static char *TypeToText(type) Type type; { + switch ((int) type) { + case T_CONTEXT: + return "DPSContext"; + case T_BOOLEAN: + return "int"; + case T_FLOAT: + return "float"; + case T_DOUBLE: + return "double"; + case T_CHAR: + return "char"; + case T_UCHAR: + return "unsigned char"; + case T_USEROBJECT: + case T_INT: + return "int"; + case T_LONGINT: + return "long int"; + case T_SHORTINT: + return "short int"; + case T_ULONGINT: + return "unsigned long int"; + case T_USHORTINT: + return "unsigned short int"; + case T_UINT: + return "unsigned int"; + case T_NUMSTR: + return "int"; + case T_FLOATNUMSTR: + return "float"; + case T_LONGNUMSTR: + return "long int"; + case T_SHORTNUMSTR: + return "short int"; + default: + CantHappen(); + } + /*NOTREACHED*/ + } + +static char *CTypeToDPSType(type) int type; { + switch (type) { + case T_BOOLEAN: + return("DPS_BOOL"); + case T_INT: + case T_LONGINT: + case T_SHORTINT: + case T_UINT: + case T_ULONGINT: + case T_USHORTINT: + case T_USEROBJECT: + return("DPS_INT"); + case T_FLOAT: + case T_DOUBLE: + return("DPS_REAL"); + case T_CHAR: + case T_UCHAR: + return("DPS_STRING"); + default: CantHappen(); + } + /*NOTREACHED*/ + } + +static char *CTypeToResultType(type) int type; { + switch (type) { + case T_BOOLEAN: + return("dps_tBoolean"); + case T_USEROBJECT: + case T_INT: + return("dps_tInt"); + case T_LONGINT: + return("dps_tLong"); + case T_SHORTINT: + return("dps_tShort"); + case T_UINT: + return("dps_tUInt"); + case T_ULONGINT: + return("dps_tULong"); + case T_USHORTINT: + return("dps_tUShort"); + case T_FLOAT: + return("dps_tFloat"); + case T_DOUBLE: + return("dps_tDouble"); + case T_CHAR: + return("dps_tChar"); + case T_UCHAR: + return("dps_tUChar"); + case T_NUMSTR: + return("dps_tInt"); + case T_FLOATNUMSTR: + return("dps_tFloat"); + case T_LONGNUMSTR: + return("dps_tLong"); + case T_SHORTNUMSTR: + return("dps_tShort"); + default: CantHappen(); + } + /*NOTREACHED*/ + } + +static void FreeTokenList(tokenList) + register TokenList tokenList; +{ + extern int bigFile; + register TokenList tl; + if (bigFile) + while (tokenList) { + tl = tokenList->next; + free((char *)tokenList); + tokenList = tl; + } +} + + +/********************************************/ +/* Support procedures that generate no code */ + +static void SetNameTag(t) Token t; { + PSWDictValue tag; + Assert(t->type == T_NAME || t->type == T_LITNAME); + tag = PSWDictLookup(wellKnownPSNames, (char *)(t->val)); + if (tag == -1) { /* this is not a well-known name */ + if (noUserNames) + t->wellKnownName = false; + else { + nameTokens = ConsNameToken(t, nameTokens); + nNames++; + } + } + else { /* a well-known (system) name */ + t->wellKnownName = true; + t->body.cnst = tag; + } + } + +/* If the wrap has result parameters, DPSAwaitReturnValues + must be told when execution if the body is complete. The + following boilerplate is tacked on to the end of the body + for this purpose by AppendResultFlush: + 0 doneTag printobject flush + where doneTag = (last result parameter tag + 1). +*/ +static Body AppendResultFlush(body, n) Body body; int n; { + Token t, token; + char *ss; + + if (body == NULL) return NULL; + for (t = body; t->next; t = t->next) ; + + token = PSWToken(T_INT, 0L); + token->next = PSWToken(T_INT, (char *) n); + + SafeStrCpy(ss, "printobject"); + token->next->next = PSWToken(T_NAME, ss); + + SafeStrCpy(ss, "flush"); + token->next->next->next = PSWToken(T_NAME, ss); + + t->next = token; + return body; + } + + +/*****************************************/ +/* Support procedures that generate code */ + +static void EmitArgPrototypes(stm, hdr) FILE *stm; Header hdr; { + register Arg arg; + register Item item; + for (arg = hdr->inArgs; arg; arg = arg->next) { + fprintf(stm, "%s ", TypeToText(arg->type)); + for (item = arg->items; item; item = item->next) { + if (item->starred) fprintf(stm, "*"); + fprintf(stm, item->name); + if (item->subscripted) fprintf(stm, "[]"); + if (item->next) fprintf(stm, ", "); + } + fprintf(stm, "; "); + } + for (arg = hdr->outArgs; arg; arg = arg->next) { + fprintf(stm, "%s ", TypeToText(arg->type)); + for (item = arg->items; item; item = item->next) { + if (item->starred) fprintf(stm, "*"); + fprintf(stm, item->name); + if (item->subscripted) fprintf(stm, "[]"); + if (item->next) fprintf(stm, ", "); + } + fprintf(stm, "; "); + } + } + +static void EmitANSIPrototypes(stm, hdr) FILE *stm; Header hdr; { + register Arg arg; + register Item item; + register char *type; + + if ((hdr->inArgs == NULL) && (hdr->outArgs == NULL)) { + fprintf(stm, " void "); return; + } + for (arg = hdr->inArgs; arg; arg = arg->next) { + type = TypeToText(arg->type); + for (item = arg->items; item; item = item->next) { + if (arg->type == T_CONTEXT) ctxName = item->name; + fprintf(stm, "%s%s %s%s", item->starred || item-> subscripted ? "const " : "", type, item->starred ? "*" : "", item->name); + if (item->subscripted) fprintf(stm, "[]"); + if (item->next) fprintf(stm, ", "); + } + if (arg->next) fprintf(stm, ", "); + } + if (hdr->inArgs && hdr->outArgs) fprintf(stm, ", "); + for (arg = hdr->outArgs; arg; arg = arg->next) { + type = TypeToText(arg->type); + for (item = arg->items; item; item = item->next) { + fprintf(stm, "%s %s%s", type, item->starred ? "*" : "", item->name); + if (item->subscripted) fprintf(stm, "[]"); + if (item->next) fprintf(stm, ", "); + } + if (arg->next) fprintf(stm, ", "); + } + } + +/* Procedures for generating type declarations in the body */ + +static void StartBinObjSeqDef() +{ + /* start type defn of binobjseq */ + printf(" typedef struct {\n"); + printf(" unsigned char tokenType;\n"); + if(large) { + printf(" unsigned char sizeFlag;\n"); + printf(" unsigned short topLevelCount;\n"); + printf(" unsigned int nBytes;\n\n"); + outlineno++; + } else { + printf(" unsigned char topLevelCount;\n"); + printf(" unsigned short nBytes;\n\n"); + } + outlineno += 5; +} + +static void EmitFieldType(t) Token t; { + if ((t->type == T_FLOAT) + || (t->type == T_NAME && t->namedFormal + && (!t->namedFormal->subscripted) + && (t->namedFormal->type == T_FLOAT || t->namedFormal->type == T_DOUBLE)) + || ((t->type == T_SUBSCRIPTED) && ((t->namedFormal->type == T_FLOAT) + || (t->namedFormal->type == T_DOUBLE)))) + { + printf(" DPSBinObjReal"); + } else { + printf(" DPSBinObjGeneric"); + } + printf (" obj%d;\n", t->tokenIndex); outlineno++; + } + +static int CheckSize(body) + Body body; +{ + Adr nextAdr; + register TokenList bodies = NULL; + register TokenList tl; + boolean firstBody = true; + PSWDict wrapDict; + int strCount = 0; + + bodies = ConsToken(body, (TokenList) NULL); /* the work list */ + + wrapDict = CreatePSWDict(MAXSTRINGS); /* dictionary of strings in the wrap */ + + nextAdr.cnst = 0; + nextAdr.var = NULL; + namedInputArrays = NULL; + namedInputStrings = NULL; + literalStrings = NULL; + + while (bodies) { + register Token t; + register TokenList c = bodies; + bodies = c->next; + + if (firstBody) firstBody = false; + else { + c->token->body = nextAdr; + c->token = (Body)c->token->val; + } + for (t = c->token; t; t = t->next) { + /* foreach token in this body */ + nextAdr.cnst += DPS_BINOBJ_SIZE; + + + switch (t->type) { + case T_STRING: /* token is a string literal */ + case T_HEXSTRING: /* token is a hexstring literal */ + if (t->namedFormal == NULL) { + if ((t->type == T_STRING) ? PSWStringLength(t->val) + : PSWHexStringLength(t->val)) + literalStrings = ConsToken(t, literalStrings); + } + else { + Assert(IsCharType(t->namedFormal->type)); + namedInputStrings = ConsToken(t, namedInputStrings); + } + break; + + case T_NAME: + if (t->namedFormal != NULL) { + if (IsCharType(t->namedFormal->type) || + IsNumStrType(t->namedFormal->type)) + namedInputStrings = ConsToken(t, namedInputStrings); + else + if (t->namedFormal->subscripted) + namedInputArrays = ConsToken(t, namedInputArrays); + } else { + if (noUserNames) { + SetNameTag(t); + if (!t->wellKnownName) + literalStrings = ConsToken(t, literalStrings); + } + } + break; + + case T_LITNAME: + if (t->namedFormal != NULL) { + namedInputStrings = ConsToken(t, namedInputStrings); + writable = true; + } else { + if (noUserNames) { + SetNameTag(t); + if (!t->wellKnownName) + literalStrings = ConsToken(t, literalStrings); + } + } + break; + + case T_SUBSCRIPTED: + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + break; + + case T_ARRAY: + bodies = ConsToken(t, bodies); + break; + case T_PROC: + bodies = ConsToken(t, bodies); + break; + default: + CantHappen(); + } /* switch */ + } /* for */ + free(c); + } /* while */ + + + for (tl = namedInputArrays; tl; tl = tl->next) { + Token t = tl->token; + if (t->namedFormal->subscript->constant) + nextAdr.cnst += t->namedFormal->subscript->val * DPS_BINOBJ_SIZE; + } + + for (tl = literalStrings; tl; tl = tl->next) { + Token t = tl->token; + int ln; + if (PSWDictLookup(wrapDict, (char *)t->val) == -1) { + if (strCount <= MAXSTRINGS) { + PSWDictEnter(wrapDict, t->val, 0); + strCount++; + } + if (t->type == T_STRING || t->type == T_NAME || t->type == T_LITNAME) + ln = PSWStringLength((char *)t->val); + else + ln = PSWHexStringLength((char *)t->val); + nextAdr.cnst += ln; + } + } + + /* process name and litname tokens that reference formal string arguments */ + for (tl = namedInputStrings; tl; tl = tl->next) { + Token t = tl->token; + if (t->namedFormal->subscripted && t->namedFormal->subscript->constant) { + if (IsNumStrType(t->namedFormal->type)) + nextAdr.cnst += NUMSTR_HEADER_SIZE; + else + if(pad) { + int length; + length = t->namedFormal->subscript->val + WORD_ALIGN; + length &= ~WORD_ALIGN; + nextAdr.cnst += length; + } else + nextAdr.cnst += t->namedFormal->subscript->val; + } + } + + DestroyPSWDict(wrapDict); + if (nextAdr.cnst > 0xffff) + return(1); + else + return(0); + +} /* CheckSize */ + +static void BuildTypesAndAssignAddresses(body, sz, nObjs, psize) + Body body; Adr *sz; long int *nObjs; unsigned *psize; +{ + long int objN = 0; + Adr nextAdr; + register TokenList bodies = NULL; + register TokenList tl; + boolean firstBody = true; + extern int yylineno; + PSWDict wrapDict; + int strCount = 0; + + bodies = ConsToken(body, (TokenList) NULL); /* the work list */ + + wrapDict = CreatePSWDict(MAXSTRINGS); /* dictionary of strings in the wrap */ + + nextAdr.cnst = 0; + nextAdr.var = NULL; + namedInputArrays = NULL; + namedInputStrings = NULL; + literalStrings = NULL; + writable = false; + stringBytes = 0; + + /* emit boilerplate for the binobjseq record type */ + StartBinObjSeqDef(); + + while (bodies) { + register Token t; + register TokenList c = bodies; + bodies = c->next; + + if (firstBody) firstBody = false; + else { + c->token->body = nextAdr; + c->token = (Body)c->token->val; + } + for (t = c->token; t; t = t->next) { + /* foreach token in this body */ + t->adr = nextAdr; + nextAdr.cnst += DPS_BINOBJ_SIZE; + t->tokenIndex = objN++; + + /* emit the token type as the next record field */ + EmitFieldType(t); + + switch (t->type) { + case T_STRING: /* token is a string literal */ + case T_HEXSTRING: /* token is a hexstring literal */ + if (t->namedFormal == NULL) { + if ((t->type == T_STRING) ? PSWStringLength(t->val) + : PSWHexStringLength(t->val)) + literalStrings = ConsToken(t, literalStrings); + } + else { + Assert(IsCharType(t->namedFormal->type)); + namedInputStrings = ConsToken(t, namedInputStrings); + if (!(t->namedFormal->subscripted && t->namedFormal->subscript->constant)) + writable = true; + } + break; + + case T_NAME: + if (t->namedFormal == NULL) { + SetNameTag(t); + if(noUserNames) { + if (!t->wellKnownName) + literalStrings = ConsToken(t, literalStrings); + } + } else + if (IsCharType(t->namedFormal->type) + || IsNumStrType(t->namedFormal->type)) { + namedInputStrings = ConsToken(t, namedInputStrings); + if (!(t->namedFormal->subscripted + && t->namedFormal->subscript->constant)) + writable = true; + } else + if (t->namedFormal->subscripted) { + namedInputArrays = ConsToken(t, namedInputArrays); + if (!(t->namedFormal->subscript->constant)) + writable = true; + } else + writable = true; + break; + + case T_LITNAME: + Assert(t->namedFormal == NULL || IsCharType(t->namedFormal->type)); + if (t->namedFormal == NULL) { + SetNameTag(t); + if (noUserNames) { + if (!t->wellKnownName) + literalStrings = ConsToken(t, literalStrings); + } + } else { + namedInputStrings = ConsToken(t, namedInputStrings); + writable = true; + } + break; + + case T_SUBSCRIPTED: + writable = true; + break; + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + break; + + case T_ARRAY: + bodies = ConsToken(t, bodies); + break; + case T_PROC: + bodies = ConsToken(t, bodies); + break; + default: + CantHappen(); + } /* switch */ + } /* for */ + free(c); + } /* while */ + +*psize = nextAdr.cnst; + +if(nNames) + writable = true; /* SetNameTag couldn't find the name */ + + if (namedInputArrays && literalStrings) { + twoStatics = true; + printf(" } _dpsQ;\n\n"); + printf(" typedef struct {\n"); + outlineno += 3; + } + else twoStatics = false; + + for (tl = namedInputArrays; tl; tl = tl->next) { + Token t = tl->token; + Assert(t && t->type == T_NAME && t->namedFormal); + Assert(t->namedFormal->subscripted && !t->namedFormal->starred); + + /* this input array token requires its own write binobjs call */ + t->body = nextAdr; + if (t->namedFormal->subscript->constant) + nextAdr.cnst += t->namedFormal->subscript->val * DPS_BINOBJ_SIZE; + } + + for (tl = literalStrings; tl; tl = tl->next) { + Token t = tl->token; + int ln; + PSWDictValue loc; + + loc = PSWDictLookup(wrapDict, (char *)t->val); + if (loc == -1) { + t->body = nextAdr; + if (strCount <= MAXSTRINGS) { + PSWDictEnter(wrapDict, (char *)t->val, nextAdr.cnst); + strCount++; + } + if (t->type == T_STRING || t->type == T_NAME || t->type == T_LITNAME) + ln = PSWStringLength((char *)t->val); + else + ln = PSWHexStringLength((char *)t->val); + nextAdr.cnst += ln; + stringBytes += ln; + + /* emit the string type as the next record field */ + printf(" char obj%d[%d];\n", objN++, ln); outlineno++; + } else { + t->body = nextAdr; + t->body.cnst = loc; + } + } + + /* process name and litname tokens that reference formal string arguments */ + for (tl = namedInputStrings; tl; tl = tl->next) { + Token t = tl->token; + t->body = nextAdr; + if (t->namedFormal->subscripted && t->namedFormal->subscript->constant) { + if (IsNumStrType(t->namedFormal->type)) { + nextAdr.cnst += NUMSTR_HEADER_SIZE; + writable = true; + } else + if(pad) { + int length; + length = t->namedFormal->subscript->val + WORD_ALIGN; + length &= ~WORD_ALIGN; + nextAdr.cnst += length; + } else + nextAdr.cnst += t->namedFormal->subscript->val; + } + } + + /* emit boilerplate to end the last record type */ + if (twoStatics) printf(" } _dpsQ1;\n"); + else printf(" } _dpsQ;\n"); + outlineno++; + + *nObjs = objN; + /* total number of objects plus string bodies in objrecs */ + + *sz = nextAdr; + DestroyPSWDict(wrapDict); +} /* BuildTypesAndAssignAddresses */ + + +/* Procedures for generating static declarations for local types */ + +static void StartStatic(first) boolean first; { + /* start static def for bin obj seq or for array data (aux) */ + if (first) { + if(reentrant && writable) { + if(doANSI) + printf(" static const _dpsQ _dpsStat = {\n"); + else + printf(" static _dpsQ _dpsStat = {\n"); + } else { + if (doANSI) + printf(" static const _dpsQ _dpsF = {\n"); + else + printf(" static _dpsQ _dpsF = {\n"); + } + } else { + if(doANSI) + printf(" static const _dpsQ1 _dpsF1 = {\n"); + else + printf(" static _dpsQ1 _dpsF1 = {\n"); + } + + outlineno++; +} + +static void FirstStatic(nTopObjects, sz) + int nTopObjects; Adr *sz; { + char *numFormat = "DPS_DEF_TOKENTYPE"; + + outlineno++; + if(large) { + fprintf(datafil, " %s, 0, %d, ", numFormat, nTopObjects); + fprintf(datafil, "%d,\n", sz->cnst + dpsHeaderSize); + } else { + fprintf(datafil, " %s, %d, ", numFormat, nTopObjects); + fprintf(datafil, "%d,\n", sz->cnst + dpsHeaderSize); + } +} + +static void EndStatic(first) boolean first; { + /* end static template defn */ + if (first) + printf(" }; /* _dpsQ */\n"); + else + printf(" }; /* _dpsQ1 */\n"); + outlineno++; + } + +/* char that separates object attributes */ +#define ATT_SEP '|' + +static void EmitFieldConstructor(t) register Token t; { + char *comment = NULL, *commentName = NULL; + fprintf(datafil, " {"); + + switch (t->type) { + case T_BOOLEAN: + fprintf(datafil, "DPS_LITERAL%cDPS_BOOL, 0, 0, %d", ATT_SEP, t->val); + break; + case T_INT: + fprintf(datafil, "DPS_LITERAL%cDPS_INT, 0, 0, %d", ATT_SEP, t->val); + break; + case T_FLOAT: + fprintf(datafil, "DPS_LITERAL%cDPS_REAL, 0, 0, %s", ATT_SEP, (char *)t->val); + break; + + case T_ARRAY: + fprintf(datafil, "DPS_LITERAL%cDPS_ARRAY, 0, %d, %d", ATT_SEP, + NumTokens((Body) (t->val)), t->body.cnst); + break; + case T_PROC: + fprintf(datafil, "DPS_EXEC%cDPS_ARRAY, 0, %d, %d", ATT_SEP, + NumTokens((Body) (t->val)), t->body.cnst); + break; + + case T_STRING: + case T_HEXSTRING: + if (t->namedFormal == NULL) { + int ln; + if (t->type == T_STRING) + ln = PSWStringLength((char *)t->val); + else ln = PSWHexStringLength((char *)t->val); + fprintf(datafil, "DPS_LITERAL%cDPS_STRING, 0, %d, %d", ATT_SEP, + ln, t->body.cnst); + } else { + Item item = t->namedFormal; + if (item->subscripted && item->subscript->constant) { + fprintf(datafil, "DPS_LITERAL%cDPS_STRING, 0, %d, %d", + ATT_SEP,item->subscript->val, t->body.cnst); + comment = "param[const]: "; + } else { + fprintf(datafil, "DPS_LITERAL%cDPS_STRING, 0, 0, %d", + ATT_SEP,t->body.cnst); + comment = "param "; + } + commentName = (char *)t->val; + } + break; + + case T_LITNAME: + commentName = (char *)t->val; + if (t->wellKnownName) { + fprintf(datafil, "DPS_LITERAL%cDPS_NAME, 0, DPSSYSNAME, %d", ATT_SEP, t->body.cnst); + } + else if (t->namedFormal == NULL) { + int ln; + if (noUserNames) { + ln = PSWStringLength((char *)t->val); + fprintf(datafil, "DPS_LITERAL%cDPS_NAME, 0, %d, %d", ATT_SEP, ln, t->body.cnst); + } else + fprintf(datafil, "DPS_LITERAL%cDPS_NAME, 0, 0, 0", ATT_SEP); + } + else { + fprintf(datafil, "DPS_LITERAL%cDPS_NAME, 0, 0, %d", ATT_SEP, t->body.cnst); + comment = "param "; + } + break; + + case T_NAME: + commentName = (char *)t->val; + if (t->wellKnownName) { + fprintf(datafil, "DPS_EXEC%cDPS_NAME, 0, DPSSYSNAME, %d", ATT_SEP, t->body.cnst); + } + else if (t->namedFormal == NULL) { + int ln; + if (noUserNames) { + ln = PSWStringLength((char *)t->val); + fprintf(datafil, "DPS_EXEC%cDPS_NAME, 0, %d, %d", ATT_SEP, + ln, t->body.cnst); + } else + fprintf(datafil, "DPS_EXEC%cDPS_NAME, 0, 0, 0", ATT_SEP); + } + else { + Item item = t->namedFormal; + if (IsCharType(item->type)) { + if (item->subscripted && t->namedFormal->subscript->constant) { + fprintf(datafil, "DPS_EXEC%cDPS_NAME, 0, %d, %d", ATT_SEP, + t->namedFormal->subscript->val, t->body.cnst); + comment = "param[const]: "; + } + else { + fprintf(datafil, "DPS_EXEC%cDPS_NAME, 0, 0, %d", ATT_SEP, t->body.cnst); + comment = "param "; + } + } + else { + if (item->subscripted) { + if (t->namedFormal->subscript->constant) { + if(IsNumStrType(item->type)) + fprintf(datafil, "DPS_LITERAL%cDPS_STRING, 0, %d, %d", + ATT_SEP, t->namedFormal->subscript->val + + NUMSTR_HEADER_SIZE, t->body.cnst); + else + fprintf(datafil, "DPS_LITERAL%cDPS_ARRAY, 0, %d, %d", + ATT_SEP, t->namedFormal->subscript->val, + t->body.cnst); + comment = "param[const]: "; + } else { + if(IsNumStrType(item->type)) + fprintf(datafil, "DPS_LITERAL%cDPS_STRING, 0, 0, %d", + ATT_SEP, t->body.cnst); + else + fprintf(datafil, "DPS_LITERAL%cDPS_ARRAY, 0, 0, %d", ATT_SEP, + t->body.cnst); + comment = "param[var]: "; + } + } + else { + char *dt = CTypeToDPSType(item->type); + fprintf(datafil, "DPS_LITERAL%c%s, 0, 0, 0", ATT_SEP, dt); + comment = "param: "; + } + } + } + break; + case T_SUBSCRIPTED: { + Item item = t->namedFormal; + char *dt = CTypeToDPSType(item->type); + + /* Assert(t->namedFormal) */ + fprintf(datafil, "DPS_LITERAL%c%s, 0, 0, 0", ATT_SEP, dt); + comment = "indexed param: "; + commentName = (char *)t->val; + } + break; + + default: + CantHappen(); + } /* switch */ + + if (comment == NULL) { + if (commentName == NULL) fprintf(datafil, "},\n"); + else fprintf(datafil, "}, /* %s */\n", commentName); + } + else { + if (commentName == NULL) fprintf(datafil, "}, /* %s */\n", comment); + else fprintf(datafil, "}, /* %s%s */\n", comment, commentName); + } + outlineno++; + } /* EmitFieldConstructor */ + +static void ConstructStatics(body, sz, nObjs) + Body body; Adr *sz; int nObjs; { + int objN = 0; + register TokenList strings = NULL, bodies = NULL; + register TokenList tl; + boolean isNamedInputArrays = false; + PSWDict wrapDict; + int strCount = 0; + + wrapDict = CreatePSWDict(MAXSTRINGS); /* dictionary of strings in the wrap */ + + bodies = ConsToken(body, (TokenList) NULL); /* the work list */ + + /* emit boilerplate for the binobjseq static */ + StartStatic(true); + FirstStatic(NumTokens(body), sz); + + while (bodies) { + register Token t; + TokenList c = bodies; + bodies = c->next; + + for (t = c->token; t; t = t->next) { + /* foreach token in this body */ + + /* emit the next record field constructor */ + EmitFieldConstructor(t); + objN++; + + switch (t->type) { + case T_STRING: /* token is a string literal */ + if ((t->namedFormal == NULL) && PSWStringLength(t->val)) + strings = ConsToken(t, strings); + break; + + case T_HEXSTRING: /* token is a hexstring literal */ + if ((t->namedFormal == NULL) && PSWHexStringLength(t->val)) + strings = ConsToken(t, strings); + break; + + case T_NAME: + if (t->namedFormal == NULL) { + if (noUserNames) { + if (!t->wellKnownName) + strings = ConsToken(t, strings); + } + } else + if ((t->namedFormal->subscripted) + && (!IsCharType(t->namedFormal->type)) + && (!IsNumStrType(t->namedFormal->type)) + ) + isNamedInputArrays = true; + break; + + case T_LITNAME: + if (noUserNames) { + if (!t->namedFormal && !t->wellKnownName) + strings = ConsToken(t, strings); + break; + } + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + case T_SUBSCRIPTED: + break; + + case T_ARRAY: + case T_PROC: + bodies = ConsToken((Body)t->val, bodies); + break; + default: + CantHappen(); + } /* switch */ + } /* for */ + free(c); + } /* while */ + + if (strings && isNamedInputArrays) { + EndStatic(true); + StartStatic(false); + } + + for (tl = strings; tl; tl = tl->next) { + Token t = tl->token; + if (PSWDictLookup(wrapDict, (char *)t->val) == -1) { + if (strCount <= MAXSTRINGS) { + PSWDictEnter(wrapDict, (char *)t->val, 0); + strCount++; + } + printf(" {"); + if (t->type == T_STRING || t->type == T_NAME || t->type == T_LITNAME) + PSWOutputStringChars((char *)t->val); + else + PSWOutputHexStringChars((char *)t->val); + printf("},\n"); outlineno++; + objN++; + } + } + + FreeTokenList(strings); strings = NULL; + + EndStatic(! twoStatics); /* end the last static record */ + + Assert(objN == nObjs); + + DestroyPSWDict(wrapDict); + } /* ConstructStatics */ + + +/* Procedures for managing the result table */ + +static void EmitResultTagTableDecls(outArgs) Args outArgs; { + register Arg arg; + register Item item; + int count = 0; + + if(reentrant) { + for (arg = outArgs; arg; arg = arg->next) + for (item = arg->items; item; item = item->next) + count++; + printf(" DPSResultsRec _dpsR[%d];\n", count); outlineno++; + count = 0; + if(doANSI) + printf(" static const DPSResultsRec _dpsRstat[] = {\n"); + else + printf(" static DPSResultsRec _dpsRstat[] = {\n"); + outlineno++; + } else { + printf(" static DPSResultsRec _dpsR[] = {\n"); outlineno++; + } + for (arg = outArgs; arg; arg = arg->next) { + for (item = arg->items; item; item = item->next) { + if (item->subscripted) { + printf(" { %s },\n",CTypeToResultType(item->type)); + } + else { /* not subscripted */ + printf(" { %s, -1 },\n",CTypeToResultType(item->type)); + } + outlineno++; + } + } + printf(" };\n"); outlineno++; + for (arg = outArgs; arg; arg = arg->next) { + for (item = arg->items; item; item = item->next) { + if(reentrant) { + printf(" _dpsR[%d] = _dpsRstat[%d];\n", count, count); + outlineno++; + } + if (item->subscripted) { + Subscript s = item->subscript; + if (!(s->constant)) { + printf(" _dpsR[%d].count = %s;\n",count, s->name); + } else { + printf(" _dpsR[%d].count = %d;\n",count, s->val); + } + outlineno++; + } else { /* not subscripted */ + if (IsCharType(item->type)) { + printf(" _dpsR[%d].count = -1;\n",count); + outlineno++; + } + } + printf(" _dpsR[%d].value = (char *)%s;\n",count++,item->name); + outlineno++; + } + } + printf("\n"); outlineno++; +} + +static void EmitResultTagTableAssignments(outArgs) Args outArgs; { + printf(" DPSSetResultTable(%s, _dpsR, %d);\n",ctxName,NumArgs(outArgs)); + outlineno++; + } + +/* Procedure for acquiring name tags */ + +static void EmitNameTagAcquisition() { + register TokenList n; + int i; + char *last_str; + + last_str = (char *) psw_malloc((unsigned) (maxstring+1)); + + printf(" {\n"); + if(!doANSI) { + printf(" static int _dpsT = 1;\n\n"); + printf(" if (_dpsT) {\n"); + outlineno += 4; + } else { + printf("if (_dpsCodes[0] < 0) {\n"); + outlineno += 2; + } + if(doANSI) + printf(" static const char * const _dps_names[] = {\n"); + else + printf(" static char *_dps_names[] = {\n"); + outlineno ++; + + for (n = nameTokens; n!= NULL; n = n->next) { + if (strcmp(last_str,(char *)n->token->val)) { + strcpy(last_str,(char *)n->token->val); + printf("\t\"%s\"", (char *)n->token->val); + } else { + printf("\t(char *) 0 "); + } + if (n->next) {printf(",\n"); outlineno++;} + } + printf("};\n"); outlineno++; + printf(" int *_dps_nameVals[%d];\n",nNames);outlineno++; + if (!doANSI) { + if (!writable) { + printf(" register DPSBinObjRec *_dpsP = (DPSBinObjRec *) &_dpsF.obj0;\n"); + outlineno++; + } else { + if (reentrant) { + printf(" _dpsP = (DPSBinObjRec *) &_dpsStat.obj0;\n"); + outlineno++; + } + } + } + i = 0; + if (doANSI) { + for(i=0; i<nNames; i++) { + printf(" _dps_nameVals[%d] = &_dpsCodes[%d];\n",i,i); + outlineno ++; + } + } else { + for (n = nameTokens; n!= NULL; n = n->next) { + printf(" _dps_nameVals[%d] = (int *)&_dpsP[%d].val.nameVal;\n", + i++, n->token->tokenIndex); + outlineno++; + } + } + printf("\n DPSMapNames(%s, %d, (char **) _dps_names, _dps_nameVals);\n", + ctxName, nNames); + outlineno += 2; + if (reentrant && writable && !doANSI) { + printf(" _dpsP = (DPSBinObjRec *) &_dpsF.obj0;\n"); + outlineno++; + } + if (!doANSI) { + printf(" _dpsT = 0;\n"); + outlineno ++; + } + printf(" }\n }\n\n"); + outlineno += 3; + } /* EmitNameTagAcquisition */ + + +/* Miscellaneous procedures */ + +static void EmitLocals(sz) +unsigned sz; +{ + if(reentrant && writable) { + printf(" _dpsQ _dpsF; /* local copy */\n"); + outlineno++; + } + if (ctxName == NULL) { + printf(" register DPSContext _dpsCurCtxt = DPSPrivCurrentContext();\n"); + ctxName = "_dpsCurCtxt"; + outlineno++; + } + if(pad) { + printf(" char pad[3];\n"); + outlineno++; + } + if (writable) { + printf(" register DPSBinObjRec *_dpsP = (DPSBinObjRec *)&_dpsF.obj0;\n"); + if(doANSI && nNames) { + printf(" static int _dpsCodes[%d] = {-1};\n",nNames); + outlineno++; + } + outlineno++; + if (namedInputArrays || namedInputStrings) { + printf(" register int _dps_offset = %d;\n", + twoStatics ? sz : sz + stringBytes); + outlineno++; + } + } +} + +static boolean AllLiterals(body) Body body; { + Token t; + + for (t = body; t; t = t->next) { + switch (t->type) { + + case T_NAME: + if (t->namedFormal == NULL) return false; + break; + + case T_ARRAY: + if (!AllLiterals((Body)t->val)) return false; + break; + + case T_PROC: + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + case T_LITNAME: + case T_HEXSTRING: + case T_STRING: + case T_SUBSCRIPTED: + break; + + default: + CantHappen(); + } /* switch */ + } /* for */ + return true; + } /* AllLiterals */ + +static void FlattenSomeArrays(body, inSquiggles) + Body body; boolean inSquiggles; { + Token t; + for (t = body; t; t = t->next) { + switch (t->type) { + + case T_ARRAY: + if (!AllLiterals((Body)t->val)) { + Token t1, b, tlsq, trsq; + char *s; + t1 = t->next; + b = (Body)t->val; + SafeStrCpy(s, "["); + tlsq = PSWToken(T_NAME, s); + SafeStrCpy(s, "]"); + trsq = PSWToken(T_NAME, s); + tlsq->sourceLine = t->sourceLine; + trsq->sourceLine = t->sourceLine; + *t = *tlsq; + t->next = b; + trsq->next = t1; + if (b == NULL) t->next = trsq; + else { + Token last; + for (last = b; last->next; last = last->next) ; + last->next = trsq; + } + } + else FlattenSomeArrays((Body)t->val, inSquiggles); + break; + + case T_PROC: + FlattenSomeArrays((Body)t->val, true); + /* flatten all arrays below here */ + break; + + case T_NAME: + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + case T_LITNAME: + case T_HEXSTRING: + case T_STRING: + case T_SUBSCRIPTED: + case T_NUMSTR: + case T_FLOATNUMSTR: + case T_LONGNUMSTR: + case T_SHORTNUMSTR: + break; + + default: + CantHappen(); + } /* switch */ + } /* for */ + } /* FlattenSomeArrays */ + + +static void FixupOffsets() +{ + register TokenList tl; Token t; + register Item item; + int stringOffset = 0; + PSWDict wrapDict; + int strCount = 0; + + wrapDict = CreatePSWDict(MAXSTRINGS); /* dictionary of wrap strings */ + + for (tl = namedInputArrays; tl; tl = tl->next) { + t = tl->token; item = t->namedFormal; + printf(" _dpsP[%d].val.arrayVal = _dps_offset;\n",t->tokenIndex); + printf(" _dps_offset += "); + if (item->subscript->constant) + printf("%d * sizeof(DPSBinObjGeneric);\n",item->subscript->val); + else + printf("%s * sizeof(DPSBinObjGeneric);\n",item->subscript->name); + outlineno += 2; + } /* named input arrays */ + + for (tl = namedInputStrings; tl; tl = tl->next) { + t = tl->token; item = t->namedFormal; + printf(" _dpsP[%d].val.stringVal = _dps_offset;\n",t->tokenIndex); + printf(" _dps_offset += "); + if (item->subscripted) { + if (item->subscript->constant) { + if(IsNumStrType(t->namedFormal->type)) { + if(pad & IsPadNumStrType(t->namedFormal->type)) + printf("((%d * sizeof(%s)) + %d) & ~%d;\n", + item->subscript->val,TypeToText(t->namedFormal->type), + NUMSTR_HEADER_SIZE+WORD_ALIGN, WORD_ALIGN); + else + printf("(%d * sizeof(%s)) + %d;\n", + item->subscript->val,TypeToText(t->namedFormal->type), + NUMSTR_HEADER_SIZE); + } else + if(pad) { + int val = item->subscript->val; + val += WORD_ALIGN; + val &= ~WORD_ALIGN; + printf("%d;\n", val); + } else + printf("%d;\n",item->subscript->val); + } else { + if(IsNumStrType(t->namedFormal->type)) { + if(pad & IsPadNumStrType(t->namedFormal->type)) + printf("((%s * sizeof(%s)) + %d) & ~%d;\n", + item->subscript->name,TypeToText(t->namedFormal->type), + NUMSTR_HEADER_SIZE+WORD_ALIGN, WORD_ALIGN); + else + printf("(%s * sizeof(%s)) + %d;\n", + item->subscript->name,TypeToText(t->namedFormal->type), + NUMSTR_HEADER_SIZE); + } else + if(pad) + printf("(%s + %d) & ~%d;\n", + item->subscript->name, WORD_ALIGN, WORD_ALIGN); + else + printf("%s;\n",item->subscript->name); + } + } else + if(pad) + printf("(_dpsP[%d].length + %d) & ~%d;\n", + t->tokenIndex, WORD_ALIGN, WORD_ALIGN); + else + printf("_dpsP[%d].length;\n",t->tokenIndex); + outlineno += 2; + } /* named input strings */ + + if (namedInputArrays) { + PSWDictValue strOffset; + for (tl = literalStrings; tl; tl = tl->next) { + t = tl->token; + strOffset = PSWDictLookup(wrapDict, (char *)t->val); + if (strOffset == -1) { + if (strCount <= MAXSTRINGS) { + PSWDictEnter(wrapDict, (char *)t->val, stringOffset); + strCount++; + } + if (stringOffset == 0) + printf(" _dpsP[%d].val.stringVal = _dps_offset;\n", + t->tokenIndex); + else + printf(" _dpsP[%d].val.stringVal = _dps_offset + %d;\n", + t->tokenIndex,stringOffset); + outlineno++; + stringOffset += + (t->type == T_STRING || t->type == T_NAME || t->type == T_LITNAME) + ? PSWStringLength((char *)t->val) + : PSWHexStringLength((char *)t->val); + } else { + if (strOffset == 0) + printf(" _dpsP[%d].val.stringVal = _dps_offset;\n", + t->tokenIndex); + else + printf(" _dpsP[%d].val.stringVal = _dps_offset + %d;\n", + t->tokenIndex,strOffset); + outlineno++; + } + } /* literalStrings */ + if (stringOffset) { + printf(" _dps_offset += %d;\n",stringOffset); + outlineno++; + } + } + DestroyPSWDict(wrapDict); +} /* FixupOffsets */ + + +static int EmitValueAssignments(body,item) +Body body; Item item; +{ + register Token t; + int gotit = 0; + + for (t = body; t; t = t->next) { + switch (t->type) { + case T_STRING: + case T_HEXSTRING: + case T_LITNAME: + if (t->namedFormal && t->namedFormal == item) { + printf("\n _dpsP[%d].length =",t->tokenIndex); + outlineno++; + gotit++; + } + break; + case T_NAME: + if (t->namedFormal && t->namedFormal == item) { + if ((item->subscripted && !item->subscript->constant) || + (item->starred && IsCharType(item->type)) || + IsNumStrType(item->type)) { + printf("\n _dpsP[%d].length =",t->tokenIndex); + outlineno++; + gotit++; + } + switch (item->type) { + case T_BOOLEAN: + if (!item->subscripted) { + printf("\n _dpsP[%d].val.booleanVal =", + t->tokenIndex); + gotit++; outlineno++; + } + break; + case T_INT: + case T_LONGINT: + case T_SHORTINT: + case T_UINT: + case T_ULONGINT: + case T_USHORTINT: + case T_USEROBJECT: + if (!item->subscripted) { + printf("\n _dpsP[%d].val.integerVal =", + t->tokenIndex); + gotit++; outlineno++; + } + break; + case T_FLOAT: + case T_DOUBLE: + if (!item->subscripted) { + printf("\n _dpsP[%d].val.realVal =", + t->tokenIndex); + gotit++; outlineno++; + } + break; + case T_CHAR: + case T_UCHAR: /* the executable name is an arg */ + case T_NUMSTR: + case T_FLOATNUMSTR: + case T_LONGNUMSTR: + case T_SHORTNUMSTR: + break; + default: CantHappen(); + } + } + break; + + case T_SUBSCRIPTED: + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + break; + + case T_ARRAY: + case T_PROC: + /* recurse */ + gotit += EmitValueAssignments((Body) (t->val),item); + break; + default: + CantHappen(); + } /* switch */ + } /* token */ + return (gotit); + } /* EmitValueAssignments */ + + +static void EmitElementValueAssignments(body,item) +Body body; Item item; +{ + register Token t; + + for (t = body; t; t = t->next) { + if (t->type != T_SUBSCRIPTED) continue; + if (t->namedFormal == item) { + switch (item->type) { + case T_BOOLEAN: + printf("\n _dpsP[%d].val.booleanVal = (int)(0 != %s[%s]);", + t->tokenIndex, item->name, t->body.var); + outlineno++; + break; + case T_INT: + case T_LONGINT: + case T_SHORTINT: + case T_UINT: + case T_ULONGINT: + case T_USHORTINT: + printf("\n _dpsP[%d].val.integerVal = %s[%s];", + t->tokenIndex, item->name, t->body.var); + outlineno++; + break; + case T_FLOAT: + case T_DOUBLE: + printf("\n _dpsP[%d].val.realVal = %s[%s];", + t->tokenIndex, item->name, t->body.var); + outlineno++; + break; + case T_CHAR: + case T_UCHAR: + CantHappen(); + break; + default: CantHappen(); + } + } + } /* token */ +} /* EmitElementValueAssignments */ + + +static void ScanParamsAndEmitValues(body,args) +Body body; Args args; +{ + register Arg arg; /* a list of parameters */ + register Item item; /* a parameter */ + int gotit; /* flag that we found some token with this length */ + + /* for each arg */ + for (arg = args; arg; arg = arg->next) { + /* for each arg item */ + for (item = arg->items; item; item = item->next) { + if (item->type == T_CONTEXT) continue; + gotit = EmitValueAssignments(body,item); + if (gotit != 0) { + if (item->subscripted) { + if (item->subscript->constant) { + if(IsNumStrType(item->type)) + printf(" (%d * sizeof(%s)) + %d;",item->subscript->val, + TypeToText(item->type), NUMSTR_HEADER_SIZE); + else + printf(" %d;",item->subscript->val); + } else { + if(IsNumStrType(item->type)) + printf(" (%s * sizeof(%s)) + %d;",item->subscript->name, + TypeToText(item->type), NUMSTR_HEADER_SIZE); + else + printf(" %s;",item->subscript->name); + } + } else switch(item->type) { + case T_CHAR: + case T_UCHAR: + printf(" strlen(%s);",item->name); + break; + case T_INT: + case T_LONGINT: + case T_SHORTINT: + case T_UINT: + case T_ULONGINT: + case T_USHORTINT: + case T_FLOAT: + case T_DOUBLE: + case T_USEROBJECT: + printf(" %s;",item->name); + break; + case T_BOOLEAN: + printf(" (int) (0 != %s);",item->name); + break; + default: CantHappen(); + } /* switch */ + } /* gotit */ + if (item->subscripted) { + EmitElementValueAssignments(body,item); + } + } /* item */ + } /* arg */ + printf("\n"); outlineno++; +} + +static void EmitMappedNames() +{ +register TokenList n; +int i=0; + for (n = nameTokens; n!= NULL; n = n->next) { + printf(" _dpsP[%d].val.nameVal = _dpsCodes[%d];\n", + n->token->tokenIndex, i++); + outlineno++; + } +} + +static void WriteObjSeq(sz) +unsigned sz; +{ + register TokenList tl; + + printf(" DPSBinObjSeqWrite(%s,(char *) &_dpsF,%d);\n", + ctxName, (twoStatics ? sz : sz + stringBytes) + dpsHeaderSize); + outlineno++; + + for (tl = namedInputArrays; tl; tl = tl->next) { + Token t = tl->token; + printf(" DPSWriteTypedObjectArray(%s, %s, (char *)%s, ", + ctxName, + CTypeToResultType(t->namedFormal->type), + t->namedFormal->name); + if (t->namedFormal->subscript->constant) + printf("%d);\n", t->namedFormal->subscript->val); + else + printf("%s);\n", t->namedFormal->subscript->name); + outlineno++; + } + + for (tl = namedInputStrings; tl; tl = tl->next) { + Token t = tl->token; + if(IsNumStrType(t->namedFormal->type)) { + printf(" DPSWriteNumString(%s, %s, (char *) %s, ", ctxName, + CTypeToResultType(t->namedFormal->type), t->namedFormal->name); + if (t->namedFormal->subscript->constant) + printf("%d, ", t->namedFormal->subscript->val); + else + printf("%s, ", t->namedFormal->subscript->name); + if (t->namedFormal->scaled) { + if (t->namedFormal->scale->constant) + printf("%d);\n", t->namedFormal->scale->val); + else + printf("%s);\n", t->namedFormal->scale->name); + } else printf("0);\n"); + outlineno ++; + } else { + printf(" DPSWriteStringChars(%s, (char *)%s, ", + ctxName, t->namedFormal->name); + if (!t->namedFormal->subscripted) { + printf("_dpsP[%d].length);\n", t->tokenIndex); + if(pad) { + printf(" DPSWriteStringChars(%s, (char *)pad, ~(_dpsP[%d].length + %d) & %d);\n", + ctxName,t->tokenIndex,WORD_ALIGN,WORD_ALIGN); + outlineno ++; + } + } else + if (t->namedFormal->subscript->constant) { + int val = t->namedFormal->subscript->val; + printf("%d);\n", val); + if(pad){ + val = ~(val + WORD_ALIGN) & WORD_ALIGN; + if(val) { + printf(" DPSWriteStringChars(%s, (char *)pad, %d);\n", + ctxName,val); + outlineno ++; + } + } + } else { + printf("%s);\n", t->namedFormal->subscript->name); + if(pad) { + printf(" DPSWriteStringChars(%s, (char *)pad, ~(%s + %d) & %d);\n", + ctxName,t->namedFormal->subscript->name, + WORD_ALIGN,WORD_ALIGN); + outlineno ++; + } + } + outlineno ++; + } + } + + if (twoStatics) { + printf(" DPSWriteStringChars(%s,(char *) &_dpsF1,%d);\n", + ctxName,stringBytes); + outlineno++; + } + } /* WriteObjSeq */ + + +/*************************************************************/ +/* Public procedures, called by the semantic action routines */ + +void EmitPrototype(hdr) Header hdr; { + /* emit procedure prototype to the output .h file, if any */ + + fprintf(header, "\n"); + fprintf(header, "extern void %s(", hdr->name); + if (doANSI) EmitANSIPrototypes(header, hdr); + else if (hdr->inArgs || hdr->outArgs) { + fprintf(header, " /* "); + EmitArgPrototypes(header, hdr); + fprintf(header, "*/ "); + } + fprintf(header, ");\n"); + } + +void EmitBodyHeader(hdr) Header hdr; { + /* emit procedure header */ + register Arg arg; + register Item item; + + nameTokens = NULL; + nNames = 0; + ctxName = NULL; + + if (hdr->isStatic) printf("static "); + printf("void %s(", hdr->name); + + if (doANSI) { + EmitANSIPrototypes(stdout,hdr); + printf(")\n"); + outlineno++; + } + else { /* not ANSI */ + for (arg = hdr->inArgs; arg; arg = arg->next) { + for (item = arg->items; item; item = item->next) { + if (arg->type == T_CONTEXT) ctxName = item->name; + printf(item->name); + if (item->next) printf(", "); + } + if (arg->next || hdr->outArgs) printf(", "); + } /* inArgs */ + for (arg = hdr->outArgs; arg; arg = arg->next) { + for (item = arg->items; item; item = item->next) { + printf(item->name); + if (item->next) printf(", "); + } + if (arg->next) printf(", "); + } /* outArgs */ + printf(")\n"); outlineno++; + if (hdr->inArgs || hdr->outArgs) { + EmitArgPrototypes(stdout, hdr); + printf("\n"); + outlineno++; + } + } +} /* EmitBodyHeader */ + +void EmitBody(body, hdr) Tokens body; Header hdr; { + Args arg, outArgs = hdr->outArgs; + Item item; + long int nObjs; + unsigned structSize; + /* total number of objects plus string bodies in objrecs. + Not including array arg expansions */ + Adr sizeAdr; + + if(NumTokens(body) == 0) + return; /* empty wrap */ + + if (outArgs) body = AppendResultFlush(body, NumArgs(outArgs)); + + FlattenSomeArrays(body, false); + + if (large = ((NumTokens(body) > 0xff)) || CheckSize(body)) + dpsHeaderSize = DPS_LONG_HEADER_SIZE; + else + dpsHeaderSize = DPS_HEADER_SIZE; + + /* check for char * input args */ + for (arg = hdr->inArgs; arg && !large; arg = arg->next) { + for (item = arg->items; item; item = item->next) { + if ((arg->type == T_CHAR) && item->starred) { + /* if arg is char * then need to use large format since + size of arg is unknown */ + large = true; + dpsHeaderSize = DPS_LONG_HEADER_SIZE; + } + } + } + + BuildTypesAndAssignAddresses(body, &sizeAdr, &nObjs, &structSize); + /* also constructs namedInputArrays, namedInputStrings and literalStrings */ + + ConstructStatics(body, &sizeAdr, nObjs); + + EmitLocals(structSize); + + if (outArgs) EmitResultTagTableDecls(outArgs); + + if (nameTokens) { + EmitNameTagAcquisition(); + } + + if(reentrant && writable) { + printf(" _dpsF = _dpsStat; /* assign automatic variable */\n"); + outlineno++; + } + if(writable) { + ScanParamsAndEmitValues(body,hdr->inArgs); + } + + if(doANSI && nameTokens) { + EmitMappedNames(); + FreeTokenList(nameTokens); + nameTokens = NULL; + } + + /* Fixup offsets and the total size */ + + if (writable && (namedInputArrays || namedInputStrings)) { + FixupOffsets(); + printf("\n _dpsF.nBytes = _dps_offset+%d;\n", dpsHeaderSize); + outlineno += 2; + } + + if (outArgs) EmitResultTagTableAssignments(outArgs); + + WriteObjSeq(structSize); + + FreeTokenList(namedInputArrays); namedInputArrays = NULL; + FreeTokenList(namedInputStrings); namedInputStrings = NULL; + FreeTokenList(literalStrings); literalStrings = NULL; + + if (outArgs) + printf(" DPSAwaitReturnValues(%s);\n", ctxName); + else + printf(" DPSSYNCHOOK(%s)\n", ctxName); + outlineno++; + +#ifdef NeXT + if (pad) { + printf(" if (0) *pad = 0; /* quiets compiler warnings */\n"); /* gets rid of "unused variable" warnings */ + outlineno++; + } +#endif + } /* EmitBody */ + +static void AllocFailure() +{ + extern int yylineno; + extern int bigFile; + ErrIntro(yylineno); + fprintf(stderr, "pswrap is out of storage; "); + if (bigFile) + fprintf(stderr, "try splitting the input file\n"); + else + fprintf(stderr, "try -b switch\n"); + exit(1); +} + +char *psw_malloc(s) int s; { + char *temp; + extern char *malloc(); + if ((temp = malloc((unsigned) s)) == NULL) + AllocFailure(); + return(temp); +} + +char *psw_calloc(n,s) int n,s; { + char *temp; + extern char *calloc(); + if ((temp = calloc((unsigned) n, (unsigned) s)) == NULL) + AllocFailure(); + return(temp); +} + +FreeBody(body) Body body; { + register Token t, nexttoken; + + for (t = body; t; t = nexttoken) { + nexttoken = t->next; + if (t->adr.var) free(t->adr.var); + switch (t->type) { + case T_STRING: + case T_NAME: + case T_LITNAME: + case T_HEXSTRING: + free (t->val); + break; + case T_FLOAT: + case T_INT: + case T_BOOLEAN: + break; + case T_SUBSCRIPTED: + free (t->val); free(t->body.var); + break; + case T_ARRAY: + case T_PROC: + FreeBody((Body) (t->val)); + break; + default: + CantHappen(); + } + free (t); + } +} diff --git a/xc/config/pswrap/psw.h b/xc/config/pswrap/psw.h new file mode 100644 index 000000000..b1f42de34 --- /dev/null +++ b/xc/config/pswrap/psw.h @@ -0,0 +1,84 @@ +/* + * psw.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef PSW_H +#define PSW_H + +extern char *currentPSWName; /* valid between DEFINEPS and ENDPS */ + +/* C types */ + +#define T_BOOLEAN 101 +#define T_FLOAT 102 +#define T_DOUBLE 103 +#define T_CHAR 104 +#define T_UCHAR 105 +#define T_INT 106 +#define T_UINT 107 +#define T_LONGINT 108 +#define T_SHORTINT 109 +#define T_ULONGINT 110 +#define T_USHORTINT 111 +#define T_USEROBJECT 112 +#define T_NUMSTR 113 +#define T_FLOATNUMSTR 114 +#define T_LONGNUMSTR 115 +#define T_SHORTNUMSTR 116 + + +/* PostScript types */ + +#define T_STRING 91 +#define T_HEXSTRING 92 +#define T_NAME 93 +#define T_LITNAME 94 +#define T_ARRAY 95 +#define T_PROC 96 +#define T_CONTEXT 97 +#define T_SUBSCRIPTED 98 + +/* Other PostScript types: + + T_FLOAT is used for real + T_INT is used for integer + T_BOOLEAN is used for boolean + T_USEROBJECT is used for userobjects + +*/ + +#endif /* PSW_H */ diff --git a/xc/config/pswrap/pswdict.c b/xc/config/pswrap/pswdict.c new file mode 100644 index 000000000..c7ccd00fe --- /dev/null +++ b/xc/config/pswrap/pswdict.c @@ -0,0 +1,176 @@ +/* + * pswdict.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +/***********/ +/* Imports */ +/***********/ + +#include "pswtypes.h" +#include "pswdict.h" + +#ifdef XENVIRONMENT +#include <X11/Xos.h> +#else +#include <string.h> +#endif + +extern char *psw_calloc(); +extern char *psw_malloc(); + +/********************/ +/* Types */ +/********************/ + +typedef struct _t_EntryRec { + struct _t_EntryRec *next; + char *name; + PSWDictValue value; + } EntryRec, *Entry; + + /* The concrete definition for a dictionary */ + typedef struct _t_PSWDictRec { + int nEntries; + Entry *entries; + } PSWDictRec; + +PSWDict atoms; + +/**************************/ +/* Procedure Declarations */ +/**************************/ + +/* Creates and returns a new dictionary. nEntries is a hint. */ +PSWDict CreatePSWDict(nEntries) int nEntries; { + PSWDict d = (PSWDict)psw_calloc(sizeof(PSWDictRec), 1); + d->nEntries = nEntries; + d->entries = (Entry *)psw_calloc(sizeof(EntryRec), d->nEntries); + return d; + } + +/* Destroys a dictionary */ +void DestroyPSWDict(dict) PSWDict dict; { + free(dict->entries); + free(dict); + } + +static int Hash(name, nEntries) char *name; int nEntries; { + register int val = 0; + while (*name) val += *name++; + if (val < 0) val = -val; + return (val % nEntries); + } + +static Entry Probe(d, x, name) PSWDict d; int x; char *name; { + register Entry e; + for (e = (d->entries)[x]; e; e = e->next) { + if (strcmp(name, e->name) == 0) break; + } + return e; + } + +static Entry PrevProbe(prev, d, x, name) + Entry *prev; PSWDict d; int x; char *name; + { + register Entry e; + *prev = NULL; + for (e = (d->entries)[x]; e; e = e->next) { + if (strcmp(name, e->name) == 0) break; + *prev = e; + } + return e; + } + +/* -1 => not found */ +PSWDictValue PSWDictLookup(dict, name) PSWDict dict; char *name; { + Entry e; + e = Probe(dict, Hash(name, dict->nEntries), name); + if (e == NULL) return -1; + return e->value; + } + +/* 0 => normal return (not found) + -1 => found. If found, value is replaced. */ +PSWDictValue PSWDictEnter(dict, name, value) + PSWDict dict; char *name; PSWDictValue value; + { + Entry e; + int x = Hash(name, dict->nEntries); + e = Probe(dict, x, name); + if (e) { + e->value = value; + return -1; + } + e = (Entry)psw_calloc(sizeof(EntryRec), 1); + e->next = (dict->entries)[x]; (dict->entries)[x] = e; + e->value = value; + e->name = MakeAtom(name); + return 0; + } + +/* -1 => not found. If found, value is returned. */ +PSWDictValue PSWDictRemove(dict, name) PSWDict dict; char *name; { + Entry e, prev; + PSWDictValue value; + int x = Hash(name, dict->nEntries); + + e = PrevProbe(&prev, dict, x, name); + if (e == NULL) return -1; + value = e->value; + if (prev == NULL) (dict->entries)[x] = e->next; else prev->next = e->next; + free(e); + return value; + } + +PSWAtom MakeAtom(name) char *name; { + Entry e; + int x = Hash(name, 511); + char *newname; + + if (atoms == NULL) atoms = CreatePSWDict(511); + e = Probe(atoms, x, name); + if (e == NULL) { + e = (Entry)psw_calloc(sizeof(EntryRec), 1); + e->next = (atoms->entries)[x]; (atoms->entries)[x] = e; + e->value = 0; + newname = psw_malloc(strlen(name)+1); + strcpy(newname, name); + e->name = newname; + } + return e->name; + } + diff --git a/xc/config/pswrap/pswdict.h b/xc/config/pswrap/pswdict.h new file mode 100644 index 000000000..ae7df4f89 --- /dev/null +++ b/xc/config/pswrap/pswdict.h @@ -0,0 +1,74 @@ +/* + * pswdict.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef PSWDICT_H +#define PSWDICT_H + +typedef struct _t_PSWDictRec *PSWDict; +/* Opaque designator for a dictionary */ + +typedef long int PSWDictValue; /* non-negative */ +typedef char *PSWAtom; + +/* PROCEDURES */ + +/* NOTES + The name parameters defined below are NULL-terminated C strings. + None of the name parameters are handed off, i.e. the caller is + responsible for managing their storage. */ + +extern PSWDict CreatePSWDict(/* int nEntries */); +/* nEntries is a hint. Creates and returns a new dictionary */ + +extern void DestroyPSWDict(/* PSWDict dict */); +/* Destroys a dictionary */ + +extern PSWDictValue PSWDictLookup(/* PSWDict dict; char *name */); +/* -1 => not found. */ + +extern PSWDictValue PSWDictEnter + (/* PSWDict dict; char *name; PSWDictValue value; */); +/* 0 => normal return (not found) + -1 => found. If found, the old value gets replaced with the new one. */ + +extern PSWDictValue PSWDictRemove(/* PSWDict dict; char *name */); +/* -1 => not found. If found, value is returned. */ + +extern PSWAtom MakeAtom(/* char *name */); + +#endif /* PSWDICT_H */ diff --git a/xc/config/pswrap/pswfile.c b/xc/config/pswrap/pswfile.c new file mode 100644 index 000000000..c419e11d7 --- /dev/null +++ b/xc/config/pswrap/pswfile.c @@ -0,0 +1,121 @@ +/* + * pswfile.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#include <stdio.h> +#include "pswversion.h" + +extern int outlineno; /* line number in output file */ + +extern FILE *header; +extern char headid[]; +extern char *ifile; +extern char *hfile; +extern char *ofile; +#ifdef __MACH__ +extern char *shlibInclude; +#endif /* __MACH__ */ + + +#ifdef _NO_PROTO +#include <varargs.h> + +/* for debugging */ +myprintf (va_alist) + va_dcl +{ + printf(va_alist); +} + +#else /* _NO_PROTO */ + +#include <stdarg.h> + +/* for debugging */ +myprintf (char *fmt, ...) +{ + va_list args; + +#if defined(__STDC__) || defined(AIXV3) || defined(ultrix) + va_start(args, fmt); +#else + va_start(args); +#endif + + vprintf(fmt, args); + va_end(args); +} + +#endif /* _NO_PROTO */ + +static int EmitVersion(f, infname, outfname) + FILE *f; + char *infname, *outfname; +{ + extern char *prog; + fprintf(f,"/* %s generated from %s\n",outfname,infname); + fprintf(f," by %s %s %s\n */\n\n",PSW_OS,prog,PSW_VERSION); + return 4; /* number of output lines */ +} + +InitHFile(){ + (void) EmitVersion(header, ifile, hfile); + fprintf(header,"#ifndef %s\n#define %s\n",headid,headid); +} + +FinishHFile() { + fprintf(header,"\n#endif /* %s */\n",headid); + fclose(header); +} + +InitOFile() { + outlineno += EmitVersion(stdout, ifile, ofile); +#ifdef __MACH__ + if( shlibInclude ) { + printf("#ifdef SHLIB\n"); + printf("#include \"%s\"\n", shlibInclude ); + printf("#endif\n"); + outlineno += 3; + } +#endif /* __MACH__ */ + printf("#include %s\n", FRIENDSFILE); + printf("#include <string.h>\n\n"); + outlineno += 3; /* UPDATE this if you add more prolog */ + printf("#line 1 \"%s\"\n",ifile); + outlineno++; +} + diff --git a/xc/config/pswrap/pswparser.y b/xc/config/pswrap/pswparser.y new file mode 100644 index 000000000..adfe0362f --- /dev/null +++ b/xc/config/pswrap/pswparser.y @@ -0,0 +1,271 @@ +/* + * pswparser.y + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +%{ + +#include "pswpriv.h" +#include "pswsemantics.h" + +%} + +/* yylval type (from lexer and on stack) */ + +%union { + char *object; + int intobj; + Token token; + Item item; + Header header; + int flag; + Arg arg; + Subscript subscript; +} + + +%token <object> DEFINEPS ENDPS STATIC +%token <object> PSCONTEXT +%token <object> BOOLEAN FLOAT DOUBLE UNSIGNED SHORT LONG INT CHAR USEROBJECT +%token <object> NUMSTRING +%token <object> CNAME +%token <intobj> CINTEGER + +%token <object> PSNAME PSLITNAME PSREAL PSBOOLEAN PSSTRING PSHEXSTRING +%token <intobj> PSINTEGER +%token <object> PSSUBNAME PSINDEX + +%token <object> '(' ')' '|' ';' ',' '*' '[' ']' '{' '}' ':' + +%type <token> Token Tokens Body +%type <item> Items Item +%type <header> Header +%type <flag> Def Type +%type <arg> InArgs Args ContextArg SubArgs Arg +%type <subscript> Subscript + +%start Module + +%% + +Module: + /* empty */ + | Module Definition + ; + +Definition: + Header Body ENDPS + { FinalizePSWrapDef($1, $2); yyerrok; } + | error ENDPS + { yyerrok; } + ; + +Body: + /* nothing */ + { $$ = 0; } + | Tokens + /* { $$ = $1; }*/ + ; + +Tokens: + Token + { $$ = AppendPSWToken($1, 0L); } + | Tokens Token + { $$ = AppendPSWToken($2, $1); yyerrok; } + /* | error + { $$ = 0; } */ + ; + +Header: + Def ')' + { $$ = PSWHeader($1, 0, 0); yyerrok; } + | Def InArgs ')' + { $$ = PSWHeader($1, $2, 0); yyerrok; } + | Def InArgs '|' Args ')' + { $$ = PSWHeader($1, $2, $4); yyerrok; } + | Def '|' Args ')' + { $$ = PSWHeader($1, 0, $3); yyerrok; } + ; + +Def: + DEFINEPS CNAME '(' + { PSWName($2); $$ = 0; yyerrok; } + | DEFINEPS STATIC CNAME '(' + { PSWName($3); $$ = 1; yyerrok; } + | DEFINEPS error '(' + { PSWName("error"); $$ = 0; yyerrok; } + ; + +Semi: + /* nothing */ + | ';' { yyerrok; } + ; + +InArgs: + ContextArg Semi + /* { $$ = $1; } */ + | Args + /* { $$ = $1; } */ + | ContextArg ';' Args + { $$ = ConsPSWArgs($1, $3); } + ; + +ContextArg: + PSCONTEXT CNAME + { $$ = PSWArg(T_CONTEXT, PSWItem($2)); } + ; + +Args: + SubArgs Semi + /* { $$ = $1; }*/ + ; + +SubArgs: + Arg + /* { $$ = $1; }*/ + | SubArgs ';' Arg + { yyerrok; $$ = AppendPSWArgs($3, $1); } + | SubArgs error + | SubArgs error Arg + { yyerrok; $$ = AppendPSWArgs($3, $1); } + | SubArgs ';' error + ; + +Arg: Type Items + { $$ = PSWArg($1, $2); yyerrok; } + ; + +Items: + Item + /* { $$ = $1; } */ + | Items ',' Item + { yyerrok; $$ = AppendPSWItems($3, $1); } + | error { $$ = 0; } + | Items error + | Items error Item + { yyerrok; $$ = AppendPSWItems($3, $1); } + | Items ',' error + ; + +Item: + '*' CNAME + { $$ = PSWStarItem($2); } + | CNAME '[' Subscript ']' + { $$ = PSWSubscriptItem($1, $3); } + | CNAME '[' Subscript ']' ':' CNAME + { $$ = PSWScaleItem($1, $3, $6, NULL); } + | CNAME '[' Subscript ']' ':' CINTEGER + { $$ = PSWScaleItem($1, $3, NULL, $6); } + | CNAME + { $$ = PSWItem($1); } + ; + +Subscript: + CNAME + { $$ = PSWNameSubscript($1); } + | CINTEGER + { $$ = PSWIntegerSubscript($1); } + ; + +Type: + BOOLEAN + { $$ = T_BOOLEAN; } + | FLOAT + { $$ = T_FLOAT; } + | DOUBLE + { $$ = T_DOUBLE; } + | CHAR + { $$ = T_CHAR; } + | UNSIGNED CHAR + { $$ = T_UCHAR; } + | INT + { $$ = T_INT; } + | LONG INT + { $$ = T_LONGINT; } + | LONG + { $$ = T_LONGINT; } + | SHORT INT + { $$ = T_SHORTINT; } + | SHORT + { $$ = T_SHORTINT; } + | UNSIGNED + { $$ = T_UINT; } + | UNSIGNED LONG + { $$ = T_ULONGINT; } + | UNSIGNED INT + { $$ = T_UINT; } + | UNSIGNED LONG INT + { $$ = T_ULONGINT; } + | UNSIGNED SHORT + { $$ = T_USHORTINT; } + | UNSIGNED SHORT INT + { $$ = T_USHORTINT; } + | USEROBJECT + { $$ = T_USEROBJECT; } + | NUMSTRING + { $$ = T_NUMSTR; } + | INT NUMSTRING + { $$ = T_NUMSTR; } + | FLOAT NUMSTRING + { $$ = T_FLOATNUMSTR; } + | LONG NUMSTRING + { $$ = T_LONGNUMSTR; } + | SHORT NUMSTRING + { $$ = T_SHORTNUMSTR; } + ; + +Token: + PSINTEGER + { $$ = PSWToken(T_INT, $1); } + | PSREAL + { $$ = PSWToken(T_FLOAT, $1); } + | PSBOOLEAN + { $$ = PSWToken(T_BOOLEAN, $1); } + | PSSTRING + { $$ = PSWToken(T_STRING, $1); } + | PSHEXSTRING + { $$ = PSWToken(T_HEXSTRING, $1); } + | PSNAME + { $$ = PSWToken(T_NAME, $1); } + | PSLITNAME + { $$ = PSWToken(T_LITNAME, $1); } + | PSSUBNAME PSINDEX + { $$ = PSWToken2(T_SUBSCRIPTED, $1, $2); } + | '[' Body ']' + { $$ = PSWToken(T_ARRAY, $2); } + | '{' Body '}' + { $$ = PSWToken(T_PROC, $2); } + ; diff --git a/xc/config/pswrap/pswpriv.h b/xc/config/pswrap/pswpriv.h new file mode 100644 index 000000000..bd049e5db --- /dev/null +++ b/xc/config/pswrap/pswpriv.h @@ -0,0 +1,129 @@ +/* + * pswpriv.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef PSWPRIV_H +#define PSWPRIV_H + +#include "pswtypes.h" +#include "psw.h" + +/********************/ +/* Types */ +/********************/ + +typedef struct _t_ItemRec *Item; +/* Forward type designator */ + +typedef struct { + boolean constant; + int val; /* valid if constant */ + char *name; /* valid if not constant */ + } SubscriptRec, *Subscript, ScaleRec, *Scale; + +typedef int Type; + +typedef struct _t_ItemRec { /* see above */ + struct _t_ItemRec *next; + char *name; + boolean starred, subscripted, scaled; + Subscript subscript; /* valid if subscripted */ + Scale scale; + + /* the fields below are filled in by PSWHeader */ + boolean isoutput; /* true if this is an output parameter */ + long int tag; /* valid if output is true; the index of + this output parameter. starting from 0. */ + Type type; /* copied from parent Arg */ + int sourceLine; + } ItemRec; + +typedef Item Items; + +typedef struct _t_ArgRec { + struct _t_ArgRec *next; + Type type; + Items items; + } ArgRec, *Arg; + +typedef Arg Args; + +typedef struct { + boolean isStatic; + char *name; + Args inArgs, outArgs; + } HeaderRec, *Header; + +typedef struct { + long cnst; + char *var; + } Adr, *PAdr; + +typedef struct _t_TokenRec { + struct _t_TokenRec *next; + Type type; + Adr adr; /* of this token in the binary object sequence. */ + char *val; /* loopholed */ + int tokenIndex; + boolean wellKnownName; /* valid if type is T_NAME or T_LITNAME */ + int sourceLine; + Item namedFormal; + /* non-NIL if this token is a reference to a formal. + (T_STRING, T_HEXSTRING, T_NAME, and T_LITNAME) */ + Adr body; + /* Meaning depends on the token type, as follows: + simple => unused + array or proc => adr of body in binobjseq + string or hexstring => adr of body in binobjseq + name or litname => adr of namestring or array in binobjseq (named arg) + or cnst = the nametag (well-known name) + or cnst = 0 (name index filled in at runtime) + subscripted => index for element + */ +} TokenRec, *Token; + +typedef Token Tokens; + +typedef Tokens Body; + +typedef struct _t_TokenListRec { + struct _t_TokenListRec *next; + Token token; + } TokenListRec, *TokenList; + + +#endif /* PSWPRIV_H */ diff --git a/xc/config/pswrap/pswrap.man b/xc/config/pswrap/pswrap.man new file mode 100644 index 000000000..59b9b33ae --- /dev/null +++ b/xc/config/pswrap/pswrap.man @@ -0,0 +1,141 @@ +.\" $Id: pswrap.man,v 1.1.1.1 2000/02/22 15:38:03 kem Exp $ +.na +.nh +.TH PSWRAP 1 "4 Apr 1994" "Adobe Systems" +.SH NAME +pswrap \- creates C procedures from segments of PostScript language code + +.SH SYNOPSIS +.B pswrap +[ +.B \-apr +] [ +.B \-o +.I outputCfile +] [ +.B \-h +.I outputHfile +] [ +.B \-s +.I maxstring +] +.I inputfile + +.SH DESCRIPTION +.LP +.B pswrap +reads input from +.I inputfile +and creates C-callable procedures, known as wraps, that send PostScript +language code to the PostScript interpreter. +.I inputfile +contains segments of PostScript language code wrapped with a C-like +procedure syntax. +.LP +Wraps are the most efficient way for an application to communicate with the +PostScript interpreter. For complete documentation of +.B pswrap +and the language it accepts, see "pswrap Reference Manual" +in \fIProgramming the Display PostScript System with X.\fR +.LP + +.SH OPTIONS +.LP +.TP +.I inputfile +A file that contains one or more wrap definitions. +.B pswrap +transforms the definitions in +.I inputfile +into C procedures. If no input file is specified, the standard +input (which can be redirected from a file or pipe) is used. The input file +can include text other than wrap definitions. +.B pswrap +converts wrap definitions to C procedures and passes the other text +through unchanged. Therefore, it is possible to intersperse C-language +source code with wrap definitions in the input file. +.RS +.LP +.I Note: +Although C code is allowed in a pswrap input file, it is not allowed +within a wrap body. In particular, no CPP macros (for example, #define) are +allowed inside a wrap. +.RE +.TP +.B \-a +Generates ANSI C procedure prototypes for procedure definitions in +.I outputCfile +and, optionally, +.I outputHfile. +The +.B \-a +option allows compilers that recognize the +ANSI C standard to do more complete type checking of parameters. The +.B \-a +option also causes +.B pswrap +to generate const declarations. +.RS +.LP +.I Note: +ANSI C procedure prototype syntax is not recognized by most non-ANSI C +compilers, including many compilers based on the Portable C Compiler. Use the +.B \-a +option only in conjunction with a compiler that conforms to the ANSI C Standard. +.RE +.TP +.BI \-h " outputHFile" +Generates a header file that contains extern declarations for non-static +wraps. This file can be used in #include statements in modules that use +wraps. If the +.B \-a +option is specified, the declarations in the header file +are ANSI C procedure prototypes. If the +.B \-h +option is omitted, a header file is not produced. +.TP +.BI \-o " outputCFile" +Specifies the file to which the generated wraps and passed-through text are +written. If omitted, the standard output is used. If the +.B \-a +option is also specified, the procedure definitions generated by +.B pswrap +are in ANSI C procedure prototype syntax. +.TP +.B \-p +Specifies that strings passed by wraps are padded so that each data object +begins on a long-word (4-byte) boundary. This option allows wraps to run on +architectures that restrict data alignment to 4-byte boundaries and +improves performance on some other architectures. +.TP +.B \-r +Generates reentrant code for wraps shared by more than one process (as in +shared libraries). Reentrant code can be called recursively or by more than +one thread. The +.B \-r +option causes +.B pswrap +to generate extra code, so use it only when necessary. +.TP +.BI \-s " maxstring" +Sets the maximum allowable length of a PostScript string object or +hexadecimal string object in the wrap body input. A syntax error is reported if a +string is not terminated with ) or > within +.I maxstring +characters. +.I maxstring +cannot be set lower than 80; the default is 200. + +.SH SEE ALSO +\fIProgramming the Display PostScript System with X\fR +(Addison-Wesley Publishing Company, Inc., 1993). + +.SH AUTHOR +Adobe Systems Incorporated + +.SH NOTES +PostScript and Display PostScript are trademarks +of Adobe Systems Incorporated which may be registered +in certain jurisdictions. +.PP +Copyright (c) 1988-1994 Adobe Systems Incorporated. All rights reserved. diff --git a/xc/config/pswrap/pswsemantics.c b/xc/config/pswrap/pswsemantics.c new file mode 100644 index 000000000..5854d83dd --- /dev/null +++ b/xc/config/pswrap/pswsemantics.c @@ -0,0 +1,574 @@ +/* + * pswsemantics.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +/***********/ +/* Imports */ +/***********/ + +#include <stdio.h> + +#ifdef XENVIRONMENT +#include <X11/Xos.h> +#else +#include <string.h> +#endif + +#include "pswdict.h" +#include "pswpriv.h" + +extern char *hfile; +extern char *ofile; +extern char *ifile; +extern FILE *header; +extern int yylineno; /* current line number in pswrap source file */ +extern int outlineno; + +extern void EmitPrototype(); +extern void EmitBodyHeader(); +extern void EmitBody(); + +extern char *psw_malloc(); +extern char *psw_calloc(); + +/***********************/ +/* Module-wide globals */ +/***********************/ + +char *currentPSWName = NULL; +int reportedPSWName = 0; + +static PSWDict currentDict = NULL; + + +/*************************************************/ +/* Procedures called by the parser's annotations */ +/*************************************************/ + +static boolean IsCharType(t) Type t; { + return (t == T_CHAR || t == T_UCHAR); + } + +static boolean IsNumStrType(t) Type t; { + return (t == T_NUMSTR + || t == T_FLOATNUMSTR + || t == T_LONGNUMSTR + || t == T_SHORTNUMSTR); +} + +void PSWName(s) char *s; { + currentPSWName = psw_malloc(strlen(s)+1); + strcpy(currentPSWName, s); + reportedPSWName = 0; + } + + /* Generate the code for this wrap now */ +void FinalizePSWrapDef(hdr, body) + Header hdr; Body body; +{ + extern int bigFile; + + if (header && ! hdr->isStatic) EmitPrototype(hdr); + + printf("#line %d \"%s\"\n", ++outlineno, ofile); + EmitBodyHeader(hdr); + + printf("{\n"); outlineno++; + EmitBody(body, hdr); + printf("}\n"); outlineno++; + printf("#line %d \"%s\"\n", yylineno, ifile); outlineno++; + + /* release storage for this wrap */ + /* Omit if you have lots of memory and want pswrap lean and mean */ + if (bigFile) { + register Arg arg, nextarg; register Item item, nextitem; + for(arg = hdr->inArgs; arg; arg = nextarg) { + nextarg = arg->next; + for(item = arg->items; item; item = nextitem) { + nextitem = item->next; + if (item->subscripted) { + if (!item->subscript->constant) free(item->subscript->name); + free(item->subscript); + if(item->scaled) { + if (!item->scale->constant) free(item->scale->name); + free(item->scale); + } + } + free(item->name); free(item); + } + free(arg); + } + for(arg = hdr->outArgs; arg; arg = nextarg) { + nextarg = arg->next; + for(item = arg->items; item; item = nextitem) { + nextitem = item->next; + if (item->subscripted) { + if (!item->subscript->constant) free(item->subscript->name); + free(item->subscript); + } + free(item->name); free(item); + } + free(arg); + } + free(hdr->name); free(hdr); + FreeBody(body); + } + + DestroyPSWDict(currentDict); + currentDict = NULL; + currentPSWName = NULL; + reportedPSWName = 0; + } + + /* Complete construction of the Header tree and make some semantic checks */ +Header PSWHeader(isStatic, inArgs, outArgs) + boolean isStatic; Args inArgs, outArgs; { + char *name = currentPSWName; + register Arg arg, prevArg; + register Item item, prevItem; + int nextTag = 0; + + Header hdr = (Header)psw_calloc(sizeof(HeaderRec), 1); + hdr->isStatic = isStatic; + hdr->name = name; + + currentDict = CreatePSWDict(511); + + prevArg = NULL; + for (arg = inArgs; arg; arg = arg->next) { /* foreach input arg */ + prevItem = NULL; + for (item = arg->items; item; item = item->next) { + if (IsCharType(arg->type) + && !(item->starred || item->subscripted)) { + ErrIntro(item->sourceLine); + fprintf(stderr, + "char input parameter %s must be starred or subscripted\n", + item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free(item); XXX? */ + continue; + } + if(item->scaled && !IsNumStrType(arg->type)) { + ErrIntro(item->sourceLine); + fprintf(stderr,"only numstring parameters may be scaled\n"); + } + if (IsNumStrType(arg->type) + && (item->starred || !item->subscripted)) { + ErrIntro(item->sourceLine); + fprintf(stderr, + "numstring parameter %s may only be subscripted\n", + item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free(item); XXX? */ + continue; + } + if (arg->type != T_CONTEXT) { + if (PSWDictLookup(currentDict, item->name) != -1) { + ErrIntro(item->sourceLine); + fprintf(stderr,"parameter %s reused\n", item->name); + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free this ? */ + continue; + } + PSWDictEnter(currentDict, item->name, (PSWDictValue) item); + item->isoutput = false; + item->type = arg->type; + prevItem = item; + } + } + if (arg->items == NULL) { + if (prevArg) { prevArg->next = arg->next;} + else if (arg == inArgs) {inArgs = arg->next;} + continue; + } + prevArg = arg; + } + + prevArg = NULL; + for (arg = outArgs; arg; arg = arg->next) { /* foreach output arg */ + prevItem = NULL; + for (item = arg->items; item; item = item->next) { + if (arg->type == T_USEROBJECT) { + ErrIntro(item->sourceLine); + fprintf(stderr,"output parameter can not be of type userobject\n", + item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free(item); XXX */ + continue; + } + if (arg->type == T_NUMSTR || arg->type == T_FLOATNUMSTR + || arg->type == T_LONGNUMSTR || arg->type == T_SHORTNUMSTR) { + ErrIntro(item->sourceLine); + fprintf(stderr,"output parameter %s can not be of type numstring\n", + item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free(item); XXX */ + continue; + } + if (!(item->starred || item->subscripted)) { + ErrIntro(item->sourceLine); + fprintf(stderr,"output parameter %s must be starred or subscripted\n", + item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free(item); XXX */ + continue; + } + if (PSWDictLookup(currentDict, item->name) != -1) { + ErrIntro(item->sourceLine); + fprintf(stderr,"parameter %s reused\n", item->name); + /* remove item from list */ + if (prevItem) {prevItem->next = item->next;} + else if (item == arg->items) {arg->items = item->next;}; + /* free the storage? XXX */ + continue; + } + PSWDictEnter(currentDict, item->name, (PSWDictValue) item); + item->isoutput = true; + item->type = arg->type; + item->tag = nextTag++; + prevItem = item; + } /* inside for loop */ + if (arg->items == NULL) { + if (prevArg) { + prevArg->next = arg->next; + } else if (arg == outArgs) { + outArgs = arg->next; + } + continue; + } + prevArg = arg; + } /* outside for loop */ + + /* now go looking for subscripts that name an input arg */ + for (arg = inArgs; arg; arg = arg->next) { /* foreach input arg */ + for (item = arg->items; item; item = item->next) { + if (item->subscripted && !item->subscript->constant) { + PSWDictValue v = PSWDictLookup(currentDict, item->subscript->name); + if (v != -1) { + Item subItem = (Item)v; + if (subItem->isoutput) { + ErrIntro(subItem->sourceLine); + fprintf(stderr,"output parameter %s used as a subscript\n", + subItem->name); + continue; + } + if (subItem->type != T_INT) { + ErrIntro(subItem->sourceLine); + fprintf(stderr, + "input parameter %s used as a subscript is not an int\n", + subItem->name); + continue; + } + } + } + } + } + + for (arg = outArgs; arg; arg = arg->next) { /* foreach output arg */ + for (item = arg->items; item; item = item->next) { + if (item->subscripted && !item->subscript->constant) { + PSWDictValue v = PSWDictLookup(currentDict, item->subscript->name); + if (v != -1) { + Item subItem = (Item)v; + if (subItem->isoutput) { + ErrIntro(subItem->sourceLine); + fprintf(stderr,"output parameter %s used as a subscript\n", + subItem->name); + continue; + } + if (subItem->type != T_INT) { + ErrIntro(subItem->sourceLine); + fprintf(stderr, + "input parameter %s used as a subscript is not an int\n", + subItem->name); + continue; + } + } + } + } + } + + hdr->inArgs = inArgs; + hdr->outArgs = outArgs; + + return hdr; + } + +Token PSWToken(type, val) + Type type; + char *val; { + register Token token = (Token)psw_calloc(sizeof(TokenRec), 1); + extern int errorCount; + extern char *ifile; + + token->next = NULL; + token->type = type; + token->val = val; + token->sourceLine = yylineno; + + switch (type) { + case T_STRING: + case T_NAME: + case T_LITNAME: { + Item dictVal = (Item) PSWDictLookup(currentDict, (char *)val); + if ((PSWDictValue) dictVal != -1) { + if ((type != T_NAME) && (dictVal->isoutput)) { + ErrIntro(yylineno); + fprintf(stderr,"output parameter %s used as %s\n", + dictVal->name, + (type == T_STRING) ? "string": "literal name"); + } else + if ((type != T_NAME) && !IsCharType(dictVal->type)) { + ErrIntro(yylineno); + fprintf(stderr,"non-char input parameter %s used as %s\n", + dictVal->name, + (type == T_STRING) ? "string": "literal name"); + } else + token->namedFormal = dictVal; /* ok, so assign a value */ + } + break; + } + default: + break; + } + + return token; + } + +Token PSWToken2(type, val, ind) + Type type; + char *val; char *ind; { + register Token token = (Token)psw_calloc(sizeof(TokenRec), 1); + extern int errorCount; + extern char *ifile; + Item dictVal = (Item) PSWDictLookup(currentDict, val); + Item dvi; + + token->next = NULL; + token->type = type; + token->val = val; + token->sourceLine = yylineno; + + /* Assert(type == T_SUBSCRIPTED); */ + if (((PSWDictValue) dictVal == -1) || (dictVal->isoutput)) { + ErrIntro(yylineno); + fprintf(stderr,"%s not an input parameter\n", val); + } + else if (!dictVal->subscripted) { + ErrIntro(yylineno); + fprintf(stderr,"%s not an array\n", val); + } + else if (dictVal->type >= T_NUMSTR) { + ErrIntro(yylineno); + fprintf(stderr,"cannot subscript numstring %s\n", val); + } + else if (IsCharType(dictVal->type)) { + ErrIntro(yylineno); + fprintf(stderr,"%s not a scalar type\n", val); + } + else { + dvi = (Item) PSWDictLookup(currentDict, (char *)ind); + if (((PSWDictValue) dvi != -1) + && ((dvi->isoutput) || IsCharType(dvi->type))) { + ErrIntro(yylineno); + fprintf(stderr,"%s wrong type\n",(char *) ind); + } + else { + token->body.var = (char *) ind; + token->namedFormal = dictVal; /* ok, so assign a value */ + return token; + } + } + + /* ERRORS fall through */ + free(token); + return (PSWToken(T_NAME,val)); + } + +Arg PSWArg(type, items) + Type type; Items items; { + register Arg arg = (Arg)psw_calloc(sizeof(ArgRec), 1); + arg->next = NULL; + arg->type = type; + arg->items = items; + return arg; + } + +Item PSWItem(name) + char *name; { + register Item item = (Item)psw_calloc(sizeof(ItemRec), 1); + item->next = NULL; + item->name = name; + item->sourceLine = yylineno; + return item; + } + +Item PSWStarItem(name) + char *name; { + register Item item = (Item)psw_calloc(sizeof(ItemRec), 1); + item->next = NULL; + item->name = name; + item->starred = true; + item->sourceLine = yylineno; + return item; + } + +Item PSWSubscriptItem(name, subscript) + char *name; Subscript subscript; { + register Item item = (Item)psw_calloc(sizeof(ItemRec), 1); + item->next = NULL; + item->name = name; + item->subscript = subscript; + item->subscripted = true; + item->sourceLine = yylineno; + return item; + } + +Item PSWScaleItem(name, subscript, nameval, val) + char *name; + Subscript subscript; + char *nameval; + int val; +{ + Item item; + Scale scale = (Scale)psw_calloc(sizeof(ScaleRec), 1); + item = PSWSubscriptItem(name, subscript); + item->scaled = true; + if(nameval) + scale->name = nameval; + else { + scale->constant = true; + scale->val = val; + } + item->scale = scale; + return(item); +} + +Subscript PSWNameSubscript(name) + char *name; { + Subscript subscript = (Subscript)psw_calloc(sizeof(SubscriptRec), 1); + subscript->name = name; + return subscript; + } + +Subscript PSWIntegerSubscript(val) + int val; { + Subscript subscript = (Subscript)psw_calloc(sizeof(SubscriptRec), 1); + subscript->constant = true; + subscript->val = val; + return subscript; + } + +Args ConsPSWArgs(arg, args) + Arg arg; Args args; { + arg->next = args; + return arg; + } + +Tokens AppendPSWToken(token, tokens) + register Token token; Tokens tokens; { + register Token t; + static Token firstToken, lastToken; /* cache ptr to last */ + + if ((token->type == T_NAME) && (token->namedFormal)) { + if( token->namedFormal->isoutput) { + Token oldtoken; + char *pos = "printobject"; + char *ss = psw_malloc(strlen(pos) + 1); + strcpy(ss, pos); + free(token->val); + oldtoken = token; + token = PSWToken(T_INT, (char *) token->namedFormal->tag); + free((char *)oldtoken); + token->next = PSWToken(T_NAME, ss); + } else + if (token->namedFormal->type == T_USEROBJECT) { + char *pos = "execuserobject"; + char *ss = psw_malloc(strlen(pos) + 1); + strcpy(ss, pos); + token->next = PSWToken(T_NAME, ss); + } + } + + if (tokens == NULL) { + firstToken = lastToken = token; + return token; + } + + if (tokens != firstToken) + firstToken = lastToken = tokens; + for (t = lastToken; t->next; t = t->next); + lastToken = t->next = token; + + return tokens; + } + +Args AppendPSWArgs(arg, args) + Arg arg; Args args; { + register Arg a; + arg->next = NULL; + if (args == NULL) return arg; + + for (a = args; a->next; a = a->next); + + a->next = arg; + return args; + } + +Items AppendPSWItems(item, items) + Item item; Items items; { + register Item t; + item->next = NULL; + if (items == NULL) return item; + + for (t = items; t->next; t = t->next); + + t->next = item; + return items; + } + diff --git a/xc/config/pswrap/pswsemantics.h b/xc/config/pswrap/pswsemantics.h new file mode 100644 index 000000000..550be2242 --- /dev/null +++ b/xc/config/pswrap/pswsemantics.h @@ -0,0 +1,63 @@ +/* + * pswsemantics.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef PSWSEMANTICS_H +#define PSWSEMANTICS_H + +#include "pswpriv.h" + +/* PROCEDURES */ + +extern void PSWName(/* char *s */); +extern void FinalizePSWrapDef(/* hdr, body */); +extern Header PSWHeader(/* isStatic, inArgs, outArgs */); +extern Token PSWToken(/* type, val */); +extern Token PSWToken2(/* type, val, ind */); +extern Arg PSWArg(/* type, items */); +extern Item PSWItem(/* name */); +extern Item PSWStarItem(/* name */); +extern Item PSWSubscriptItem(/* name, subscript */); +extern Item PSWScaleItem(/* name, subscript */); +extern Subscript PSWNameSubscript(/* name */); +extern Subscript PSWIntegerSubscript(/* val */); +extern Args ConsPSWArgs(/* arg, args */); +extern Tokens AppendPSWToken(/* token, tokens */); +extern Args AppendPSWArgs(/* arg, args */); +extern Items AppendPSWItems(/* item, items */); + +#endif /* PSWSEMANTICS_H */ diff --git a/xc/config/pswrap/pswstring.c b/xc/config/pswrap/pswstring.c new file mode 100644 index 000000000..adacf45fe --- /dev/null +++ b/xc/config/pswrap/pswstring.c @@ -0,0 +1,135 @@ +/* + * pswstring.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#include <stdio.h> +#include <ctype.h> + +#define outfil stdout +#define MAX_PER_LINE 16 + +extern int outlineno; /* line number in output file */ + +int PSWStringLength(s) char *s; { + register char *c = s; + register int len = 0; + + while (*c != '\0') { /* skip \\ and \ooo */ + if (*c++ == '\\') { + if (*c++ != '\\') c += 2; + } + len++; + } + return (len); +} + +void PSWOutputStringChars(s) char *s; { + register char *c = s; + register char b; + register int perline = 0; + + while (*c != '\0') { + putc('\'',outfil); + switch (b = *c++) { + case '\\': + putc('\\',outfil); + fputc(b = *c++,outfil); + if (b != '\\') {putc(*c++,outfil);putc(*c++,outfil);} + break; + case '\'': + fprintf(outfil,"\\'"); + break; + case '\"': + fprintf(outfil,"\\\""); + break; + case '\b': + fprintf(outfil,"\\b"); + break; + case '\f': + fprintf(outfil,"\\f"); + break; +/* avoid funny interpretations of \n, \r by MPW */ + case '\012': + fprintf(outfil,"\\012"); perline++; + break; + case '\015': + fprintf(outfil,"\\015"); perline++; + break; + case '\t': + fprintf(outfil,"\\t"); + break; + default: + putc(b,outfil); perline--; + break; + } + putc('\'',outfil); + if (*c != '\0') { + if (++perline >= MAX_PER_LINE) { + fprintf(outfil,",\n "); + outlineno++; + } + else {putc(',',outfil);} + perline %= MAX_PER_LINE; + } + } +} + + +int PSWHexStringLength(s) char *s; { + return ((int) (strlen(s)+1)/2); +} + +void PSWOutputHexStringChars(s) + register char *s; +{ + register int perline = 0; + char tmp[3]; + + tmp[2] ='\0'; + while ((tmp[0] = *s++)!= '\0') { + tmp[1] = *s ? *s++ : '\0'; + fprintf(outfil,"0x%s",tmp); + if (*s != '\0') { + if (++perline >= MAX_PER_LINE) { + fprintf(outfil,",\n "); + outlineno++; + } + else {putc(',',outfil);} + perline %= MAX_PER_LINE; + } + } /* while */ +} diff --git a/xc/config/pswrap/pswtypes.h b/xc/config/pswrap/pswtypes.h new file mode 100644 index 000000000..aa4bd0671 --- /dev/null +++ b/xc/config/pswrap/pswtypes.h @@ -0,0 +1,50 @@ +/* + * pswtypes.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#ifndef PSWTYPES_H +#define PSWTYPES_H + +#ifndef NULL +#define NULL 0 +#endif + +#define false 0 +#define true 1 +typedef short boolean; + +#endif /* PSWTYPES_H */ diff --git a/xc/config/pswrap/pswversion.h b/xc/config/pswrap/pswversion.h new file mode 100644 index 000000000..b15f7bf4e --- /dev/null +++ b/xc/config/pswrap/pswversion.h @@ -0,0 +1,41 @@ +/* + * pswversion.h + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#define PSW_VERSION "V1.009 Wed Apr 19 17:50:24 PDT 1989" + +#define PSW_OS "unix" diff --git a/xc/config/pswrap/sysname_gen.c b/xc/config/pswrap/sysname_gen.c new file mode 100644 index 000000000..10624aafc --- /dev/null +++ b/xc/config/pswrap/sysname_gen.c @@ -0,0 +1,429 @@ +/* + * sysnames_gen.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + + wellKnownPSNames = CreatePSWDict(431); + + PSWDictEnter(wellKnownPSNames,"abs", 0); + PSWDictEnter(wellKnownPSNames,"add", 1); + PSWDictEnter(wellKnownPSNames,"aload", 2); + PSWDictEnter(wellKnownPSNames,"anchorsearch", 3); + PSWDictEnter(wellKnownPSNames,"and", 4); + PSWDictEnter(wellKnownPSNames,"arc", 5); + PSWDictEnter(wellKnownPSNames,"arcn", 6); + PSWDictEnter(wellKnownPSNames,"arct", 7); + PSWDictEnter(wellKnownPSNames,"arcto", 8); + PSWDictEnter(wellKnownPSNames,"array", 9); + PSWDictEnter(wellKnownPSNames,"ashow", 10); + PSWDictEnter(wellKnownPSNames,"astore", 11); + PSWDictEnter(wellKnownPSNames,"awidthshow", 12); + PSWDictEnter(wellKnownPSNames,"begin", 13); + PSWDictEnter(wellKnownPSNames,"bind", 14); + PSWDictEnter(wellKnownPSNames,"bitshift", 15); + PSWDictEnter(wellKnownPSNames,"ceiling", 16); + PSWDictEnter(wellKnownPSNames,"charpath", 17); + PSWDictEnter(wellKnownPSNames,"clear", 18); + PSWDictEnter(wellKnownPSNames,"cleartomark", 19); + PSWDictEnter(wellKnownPSNames,"clip", 20); + PSWDictEnter(wellKnownPSNames,"clippath", 21); + PSWDictEnter(wellKnownPSNames,"closepath", 22); + PSWDictEnter(wellKnownPSNames,"concat", 23); + PSWDictEnter(wellKnownPSNames,"concatmatrix", 24); + PSWDictEnter(wellKnownPSNames,"copy", 25); + PSWDictEnter(wellKnownPSNames,"count", 26); + PSWDictEnter(wellKnownPSNames,"counttomark", 27); + PSWDictEnter(wellKnownPSNames,"currentcmykcolor", 28); + PSWDictEnter(wellKnownPSNames,"currentdash", 29); + PSWDictEnter(wellKnownPSNames,"currentdict", 30); + PSWDictEnter(wellKnownPSNames,"currentfile", 31); + PSWDictEnter(wellKnownPSNames,"currentfont", 32); + PSWDictEnter(wellKnownPSNames,"currentgray", 33); + PSWDictEnter(wellKnownPSNames,"currentgstate", 34); + PSWDictEnter(wellKnownPSNames,"currenthsbcolor", 35); + PSWDictEnter(wellKnownPSNames,"currentlinecap", 36); + PSWDictEnter(wellKnownPSNames,"currentlinejoin", 37); + PSWDictEnter(wellKnownPSNames,"currentlinewidth", 38); + PSWDictEnter(wellKnownPSNames,"currentmatrix", 39); + PSWDictEnter(wellKnownPSNames,"currentpoint", 40); + PSWDictEnter(wellKnownPSNames,"currentrgbcolor", 41); + PSWDictEnter(wellKnownPSNames,"currentshared", 42); + PSWDictEnter(wellKnownPSNames,"curveto", 43); + PSWDictEnter(wellKnownPSNames,"cvi", 44); + PSWDictEnter(wellKnownPSNames,"cvlit", 45); + PSWDictEnter(wellKnownPSNames,"cvn", 46); + PSWDictEnter(wellKnownPSNames,"cvr", 47); + PSWDictEnter(wellKnownPSNames,"cvrs", 48); + PSWDictEnter(wellKnownPSNames,"cvs", 49); + PSWDictEnter(wellKnownPSNames,"cvx", 50); + PSWDictEnter(wellKnownPSNames,"def", 51); + PSWDictEnter(wellKnownPSNames,"defineusername", 52); + PSWDictEnter(wellKnownPSNames,"dict", 53); + PSWDictEnter(wellKnownPSNames,"div", 54); + PSWDictEnter(wellKnownPSNames,"dtransform", 55); + PSWDictEnter(wellKnownPSNames,"dup", 56); + PSWDictEnter(wellKnownPSNames,"end", 57); + PSWDictEnter(wellKnownPSNames,"eoclip", 58); + PSWDictEnter(wellKnownPSNames,"eofill", 59); + PSWDictEnter(wellKnownPSNames,"eoviewclip", 60); + PSWDictEnter(wellKnownPSNames,"eq", 61); + PSWDictEnter(wellKnownPSNames,"exch", 62); + PSWDictEnter(wellKnownPSNames,"exec", 63); + PSWDictEnter(wellKnownPSNames,"exit", 64); + PSWDictEnter(wellKnownPSNames,"file", 65); + PSWDictEnter(wellKnownPSNames,"fill", 66); + PSWDictEnter(wellKnownPSNames,"findfont", 67); + PSWDictEnter(wellKnownPSNames,"flattenpath", 68); + PSWDictEnter(wellKnownPSNames,"floor", 69); + PSWDictEnter(wellKnownPSNames,"flush", 70); + PSWDictEnter(wellKnownPSNames,"flushfile", 71); + PSWDictEnter(wellKnownPSNames,"for", 72); + PSWDictEnter(wellKnownPSNames,"forall", 73); + PSWDictEnter(wellKnownPSNames,"ge", 74); + PSWDictEnter(wellKnownPSNames,"get", 75); + PSWDictEnter(wellKnownPSNames,"getinterval", 76); + PSWDictEnter(wellKnownPSNames,"grestore", 77); + PSWDictEnter(wellKnownPSNames,"gsave", 78); + PSWDictEnter(wellKnownPSNames,"gstate", 79); + PSWDictEnter(wellKnownPSNames,"gt", 80); + PSWDictEnter(wellKnownPSNames,"identmatrix", 81); + PSWDictEnter(wellKnownPSNames,"idiv", 82); + PSWDictEnter(wellKnownPSNames,"idtransform", 83); + PSWDictEnter(wellKnownPSNames,"if", 84); + PSWDictEnter(wellKnownPSNames,"ifelse", 85); + PSWDictEnter(wellKnownPSNames,"image", 86); + PSWDictEnter(wellKnownPSNames,"imagemask", 87); + PSWDictEnter(wellKnownPSNames,"index", 88); + PSWDictEnter(wellKnownPSNames,"ineofill", 89); + PSWDictEnter(wellKnownPSNames,"infill", 90); + PSWDictEnter(wellKnownPSNames,"initviewclip", 91); + PSWDictEnter(wellKnownPSNames,"inueofill", 92); + PSWDictEnter(wellKnownPSNames,"inufill", 93); + PSWDictEnter(wellKnownPSNames,"invertmatrix", 94); + PSWDictEnter(wellKnownPSNames,"itransform", 95); + PSWDictEnter(wellKnownPSNames,"known", 96); + PSWDictEnter(wellKnownPSNames,"le", 97); + PSWDictEnter(wellKnownPSNames,"length", 98); + PSWDictEnter(wellKnownPSNames,"lineto", 99); + PSWDictEnter(wellKnownPSNames,"load", 100); + PSWDictEnter(wellKnownPSNames,"loop", 101); + PSWDictEnter(wellKnownPSNames,"lt", 102); + PSWDictEnter(wellKnownPSNames,"makefont", 103); + PSWDictEnter(wellKnownPSNames,"matrix", 104); + PSWDictEnter(wellKnownPSNames,"maxlength", 105); + PSWDictEnter(wellKnownPSNames,"mod", 106); + PSWDictEnter(wellKnownPSNames,"moveto", 107); + PSWDictEnter(wellKnownPSNames,"mul", 108); + PSWDictEnter(wellKnownPSNames,"ne", 109); + PSWDictEnter(wellKnownPSNames,"neg", 110); + PSWDictEnter(wellKnownPSNames,"newpath", 111); + PSWDictEnter(wellKnownPSNames,"not", 112); + PSWDictEnter(wellKnownPSNames,"null", 113); + PSWDictEnter(wellKnownPSNames,"or", 114); + PSWDictEnter(wellKnownPSNames,"pathbbox", 115); + PSWDictEnter(wellKnownPSNames,"pathforall", 116); + PSWDictEnter(wellKnownPSNames,"pop", 117); + PSWDictEnter(wellKnownPSNames,"print", 118); + PSWDictEnter(wellKnownPSNames,"printobject", 119); + PSWDictEnter(wellKnownPSNames,"put", 120); + PSWDictEnter(wellKnownPSNames,"putinterval", 121); + PSWDictEnter(wellKnownPSNames,"rcurveto", 122); + PSWDictEnter(wellKnownPSNames,"read", 123); + PSWDictEnter(wellKnownPSNames,"readhexstring", 124); + PSWDictEnter(wellKnownPSNames,"readline", 125); + PSWDictEnter(wellKnownPSNames,"readstring", 126); + PSWDictEnter(wellKnownPSNames,"rectclip", 127); + PSWDictEnter(wellKnownPSNames,"rectfill", 128); + PSWDictEnter(wellKnownPSNames,"rectstroke", 129); + PSWDictEnter(wellKnownPSNames,"rectviewclip", 130); + PSWDictEnter(wellKnownPSNames,"repeat", 131); + PSWDictEnter(wellKnownPSNames,"restore", 132); + PSWDictEnter(wellKnownPSNames,"rlineto", 133); + PSWDictEnter(wellKnownPSNames,"rmoveto", 134); + PSWDictEnter(wellKnownPSNames,"roll", 135); + PSWDictEnter(wellKnownPSNames,"rotate", 136); + PSWDictEnter(wellKnownPSNames,"round", 137); + PSWDictEnter(wellKnownPSNames,"save", 138); + PSWDictEnter(wellKnownPSNames,"scale", 139); + PSWDictEnter(wellKnownPSNames,"scalefont", 140); + PSWDictEnter(wellKnownPSNames,"search", 141); + PSWDictEnter(wellKnownPSNames,"selectfont", 142); + PSWDictEnter(wellKnownPSNames,"setbbox", 143); + PSWDictEnter(wellKnownPSNames,"setcachedevice", 144); + PSWDictEnter(wellKnownPSNames,"setcachedevice2", 145); + PSWDictEnter(wellKnownPSNames,"setcharwidth", 146); + PSWDictEnter(wellKnownPSNames,"setcmykcolor", 147); + PSWDictEnter(wellKnownPSNames,"setdash", 148); + PSWDictEnter(wellKnownPSNames,"setfont", 149); + PSWDictEnter(wellKnownPSNames,"setgray", 150); + PSWDictEnter(wellKnownPSNames,"setgstate", 151); + PSWDictEnter(wellKnownPSNames,"sethsbcolor", 152); + PSWDictEnter(wellKnownPSNames,"setlinecap", 153); + PSWDictEnter(wellKnownPSNames,"setlinejoin", 154); + PSWDictEnter(wellKnownPSNames,"setlinewidth", 155); + PSWDictEnter(wellKnownPSNames,"setmatrix", 156); + PSWDictEnter(wellKnownPSNames,"setrgbcolor", 157); + PSWDictEnter(wellKnownPSNames,"setshared", 158); + PSWDictEnter(wellKnownPSNames,"shareddict", 159); + PSWDictEnter(wellKnownPSNames,"show", 160); + PSWDictEnter(wellKnownPSNames,"showpage", 161); + PSWDictEnter(wellKnownPSNames,"stop", 162); + PSWDictEnter(wellKnownPSNames,"stopped", 163); + PSWDictEnter(wellKnownPSNames,"store", 164); + PSWDictEnter(wellKnownPSNames,"string", 165); + PSWDictEnter(wellKnownPSNames,"stringwidth", 166); + PSWDictEnter(wellKnownPSNames,"stroke", 167); + PSWDictEnter(wellKnownPSNames,"strokepath", 168); + PSWDictEnter(wellKnownPSNames,"sub", 169); + PSWDictEnter(wellKnownPSNames,"systemdict", 170); + PSWDictEnter(wellKnownPSNames,"token", 171); + PSWDictEnter(wellKnownPSNames,"transform", 172); + PSWDictEnter(wellKnownPSNames,"translate", 173); + PSWDictEnter(wellKnownPSNames,"truncate", 174); + PSWDictEnter(wellKnownPSNames,"type", 175); + PSWDictEnter(wellKnownPSNames,"uappend", 176); + PSWDictEnter(wellKnownPSNames,"ucache", 177); + PSWDictEnter(wellKnownPSNames,"ueofill", 178); + PSWDictEnter(wellKnownPSNames,"ufill", 179); + PSWDictEnter(wellKnownPSNames,"undef", 180); + PSWDictEnter(wellKnownPSNames,"upath", 181); + PSWDictEnter(wellKnownPSNames,"userdict", 182); + PSWDictEnter(wellKnownPSNames,"ustroke", 183); + PSWDictEnter(wellKnownPSNames,"viewclip", 184); + PSWDictEnter(wellKnownPSNames,"viewclippath", 185); + PSWDictEnter(wellKnownPSNames,"where", 186); + PSWDictEnter(wellKnownPSNames,"widthshow", 187); + PSWDictEnter(wellKnownPSNames,"write", 188); + PSWDictEnter(wellKnownPSNames,"writehexstring", 189); + PSWDictEnter(wellKnownPSNames,"writeobject", 190); + PSWDictEnter(wellKnownPSNames,"writestring", 191); + PSWDictEnter(wellKnownPSNames,"wtranslation", 192); + PSWDictEnter(wellKnownPSNames,"xor", 193); + PSWDictEnter(wellKnownPSNames,"xshow", 194); + PSWDictEnter(wellKnownPSNames,"xyshow", 195); + PSWDictEnter(wellKnownPSNames,"yshow", 196); + PSWDictEnter(wellKnownPSNames,"FontDirectory", 197); + PSWDictEnter(wellKnownPSNames,"SharedFontDirectory", 198); + PSWDictEnter(wellKnownPSNames,"Courier", 199); + PSWDictEnter(wellKnownPSNames,"Courier-Bold", 200); + PSWDictEnter(wellKnownPSNames,"Courier-BoldOblique", 201); + PSWDictEnter(wellKnownPSNames,"Courier-Oblique", 202); + PSWDictEnter(wellKnownPSNames,"Helvetica", 203); + PSWDictEnter(wellKnownPSNames,"Helvetica-Bold", 204); + PSWDictEnter(wellKnownPSNames,"Helvetica-BoldOblique", 205); + PSWDictEnter(wellKnownPSNames,"Helvetica-Oblique", 206); + PSWDictEnter(wellKnownPSNames,"Symbol", 207); + PSWDictEnter(wellKnownPSNames,"Times-Bold", 208); + PSWDictEnter(wellKnownPSNames,"Times-BoldItalic", 209); + PSWDictEnter(wellKnownPSNames,"Times-Italic", 210); + PSWDictEnter(wellKnownPSNames,"Times-Roman", 211); + PSWDictEnter(wellKnownPSNames,"execuserobject", 212); + PSWDictEnter(wellKnownPSNames,"=", 256); + PSWDictEnter(wellKnownPSNames,"==", 257); + PSWDictEnter(wellKnownPSNames,"ISOLatin1Encoding", 258); + PSWDictEnter(wellKnownPSNames,"StandardEncoding", 259); + PSWDictEnter(wellKnownPSNames,"[", 260); + PSWDictEnter(wellKnownPSNames,"]", 261); + PSWDictEnter(wellKnownPSNames,"atan", 262); + PSWDictEnter(wellKnownPSNames,"banddevice", 263); + PSWDictEnter(wellKnownPSNames,"bytesavailable", 264); + PSWDictEnter(wellKnownPSNames,"cachestatus", 265); + PSWDictEnter(wellKnownPSNames,"closefile", 266); + PSWDictEnter(wellKnownPSNames,"colorimage", 267); + PSWDictEnter(wellKnownPSNames,"condition", 268); + PSWDictEnter(wellKnownPSNames,"copypage", 269); + PSWDictEnter(wellKnownPSNames,"cos", 270); + PSWDictEnter(wellKnownPSNames,"countdictstack", 271); + PSWDictEnter(wellKnownPSNames,"countexecstack", 272); + PSWDictEnter(wellKnownPSNames,"cshow", 273); + PSWDictEnter(wellKnownPSNames,"currentblackgeneration", 274); + PSWDictEnter(wellKnownPSNames,"currentcacheparams", 275); + PSWDictEnter(wellKnownPSNames,"currentcolorscreen", 276); + PSWDictEnter(wellKnownPSNames,"currentcolortransfer", 277); + PSWDictEnter(wellKnownPSNames,"currentcontext", 278); + PSWDictEnter(wellKnownPSNames,"currentflat", 279); + PSWDictEnter(wellKnownPSNames,"currenthalftone", 280); + PSWDictEnter(wellKnownPSNames,"currenthalftonephase", 281); + PSWDictEnter(wellKnownPSNames,"currentmiterlimit", 282); + PSWDictEnter(wellKnownPSNames,"currentobjectformat", 283); + PSWDictEnter(wellKnownPSNames,"currentpacking", 284); + PSWDictEnter(wellKnownPSNames,"currentscreen", 285); + PSWDictEnter(wellKnownPSNames,"currentstrokeadjust", 286); + PSWDictEnter(wellKnownPSNames,"currenttransfer", 287); + PSWDictEnter(wellKnownPSNames,"currentundercolorremoval", 288); + PSWDictEnter(wellKnownPSNames,"defaultmatrix", 289); + PSWDictEnter(wellKnownPSNames,"definefont", 290); + PSWDictEnter(wellKnownPSNames,"deletefile", 291); + PSWDictEnter(wellKnownPSNames,"detach", 292); + PSWDictEnter(wellKnownPSNames,"deviceinfo", 293); + PSWDictEnter(wellKnownPSNames,"dictstack", 294); + PSWDictEnter(wellKnownPSNames,"echo", 295); + PSWDictEnter(wellKnownPSNames,"erasepage", 296); + PSWDictEnter(wellKnownPSNames,"errordict", 297); + PSWDictEnter(wellKnownPSNames,"execstack", 298); + PSWDictEnter(wellKnownPSNames,"executeonly", 299); + PSWDictEnter(wellKnownPSNames,"exp", 300); + PSWDictEnter(wellKnownPSNames,"false", 301); + PSWDictEnter(wellKnownPSNames,"filenameforall", 302); + PSWDictEnter(wellKnownPSNames,"fileposition", 303); + PSWDictEnter(wellKnownPSNames,"fork", 304); + PSWDictEnter(wellKnownPSNames,"framedevice", 305); + PSWDictEnter(wellKnownPSNames,"grestoreall", 306); + PSWDictEnter(wellKnownPSNames,"handleerror", 307); + PSWDictEnter(wellKnownPSNames,"initclip", 308); + PSWDictEnter(wellKnownPSNames,"initgraphics", 309); + PSWDictEnter(wellKnownPSNames,"initmatrix", 310); + PSWDictEnter(wellKnownPSNames,"instroke", 311); + PSWDictEnter(wellKnownPSNames,"inustroke", 312); + PSWDictEnter(wellKnownPSNames,"join", 313); + PSWDictEnter(wellKnownPSNames,"kshow", 314); + PSWDictEnter(wellKnownPSNames,"ln", 315); + PSWDictEnter(wellKnownPSNames,"lock", 316); + PSWDictEnter(wellKnownPSNames,"log", 317); + PSWDictEnter(wellKnownPSNames,"mark", 318); + PSWDictEnter(wellKnownPSNames,"monitor", 319); + PSWDictEnter(wellKnownPSNames,"noaccess", 320); + PSWDictEnter(wellKnownPSNames,"notify", 321); + PSWDictEnter(wellKnownPSNames,"nulldevice", 322); + PSWDictEnter(wellKnownPSNames,"packedarray", 323); + PSWDictEnter(wellKnownPSNames,"quit", 324); + PSWDictEnter(wellKnownPSNames,"rand", 325); + PSWDictEnter(wellKnownPSNames,"rcheck", 326); + PSWDictEnter(wellKnownPSNames,"readonly", 327); + PSWDictEnter(wellKnownPSNames,"realtime", 328); + PSWDictEnter(wellKnownPSNames,"renamefile", 329); + PSWDictEnter(wellKnownPSNames,"renderbands", 330); + PSWDictEnter(wellKnownPSNames,"resetfile", 331); + PSWDictEnter(wellKnownPSNames,"reversepath", 332); + PSWDictEnter(wellKnownPSNames,"rootfont", 333); + PSWDictEnter(wellKnownPSNames,"rrand", 334); + PSWDictEnter(wellKnownPSNames,"run", 335); + PSWDictEnter(wellKnownPSNames,"scheck", 336); + PSWDictEnter(wellKnownPSNames,"setblackgeneration", 337); + PSWDictEnter(wellKnownPSNames,"setcachelimit", 338); + PSWDictEnter(wellKnownPSNames,"setcacheparams", 339); + PSWDictEnter(wellKnownPSNames,"setcolorscreen", 340); + PSWDictEnter(wellKnownPSNames,"setcolortransfer", 341); + PSWDictEnter(wellKnownPSNames,"setfileposition", 342); + PSWDictEnter(wellKnownPSNames,"setflat", 343); + PSWDictEnter(wellKnownPSNames,"sethalftone", 344); + PSWDictEnter(wellKnownPSNames,"sethalftonephase", 345); + PSWDictEnter(wellKnownPSNames,"setmiterlimit", 346); + PSWDictEnter(wellKnownPSNames,"setobjectformat", 347); + PSWDictEnter(wellKnownPSNames,"setpacking", 348); + PSWDictEnter(wellKnownPSNames,"setscreen", 349); + PSWDictEnter(wellKnownPSNames,"setstrokeadjust", 350); + PSWDictEnter(wellKnownPSNames,"settransfer", 351); + PSWDictEnter(wellKnownPSNames,"setucacheparams", 352); + PSWDictEnter(wellKnownPSNames,"setundercolorremoval", 353); + PSWDictEnter(wellKnownPSNames,"sin", 354); + PSWDictEnter(wellKnownPSNames,"sqrt", 355); + PSWDictEnter(wellKnownPSNames,"srand", 356); + PSWDictEnter(wellKnownPSNames,"stack", 357); + PSWDictEnter(wellKnownPSNames,"status", 358); + PSWDictEnter(wellKnownPSNames,"statusdict", 359); + PSWDictEnter(wellKnownPSNames,"true", 360); + PSWDictEnter(wellKnownPSNames,"ucachestatus", 361); + PSWDictEnter(wellKnownPSNames,"undefinefont", 362); + PSWDictEnter(wellKnownPSNames,"usertime", 363); + PSWDictEnter(wellKnownPSNames,"ustrokepath", 364); + PSWDictEnter(wellKnownPSNames,"version", 365); + PSWDictEnter(wellKnownPSNames,"vmreclaim", 366); + PSWDictEnter(wellKnownPSNames,"vmstatus", 367); + PSWDictEnter(wellKnownPSNames,"wait", 368); + PSWDictEnter(wellKnownPSNames,"wcheck", 369); + PSWDictEnter(wellKnownPSNames,"xcheck", 370); + PSWDictEnter(wellKnownPSNames,"yield", 371); + PSWDictEnter(wellKnownPSNames,"defineuserobject", 372); + PSWDictEnter(wellKnownPSNames,"undefineuserobject", 373); + PSWDictEnter(wellKnownPSNames,"UserObjects", 374); + PSWDictEnter(wellKnownPSNames,"cleardictstack", 375); + PSWDictEnter(wellKnownPSNames,"A", 376); + PSWDictEnter(wellKnownPSNames,"B", 377); + PSWDictEnter(wellKnownPSNames,"C", 378); + PSWDictEnter(wellKnownPSNames,"D", 379); + PSWDictEnter(wellKnownPSNames,"E", 380); + PSWDictEnter(wellKnownPSNames,"F", 381); + PSWDictEnter(wellKnownPSNames,"G", 382); + PSWDictEnter(wellKnownPSNames,"H", 383); + PSWDictEnter(wellKnownPSNames,"I", 384); + PSWDictEnter(wellKnownPSNames,"J", 385); + PSWDictEnter(wellKnownPSNames,"K", 386); + PSWDictEnter(wellKnownPSNames,"L", 387); + PSWDictEnter(wellKnownPSNames,"M", 388); + PSWDictEnter(wellKnownPSNames,"N", 389); + PSWDictEnter(wellKnownPSNames,"O", 390); + PSWDictEnter(wellKnownPSNames,"P", 391); + PSWDictEnter(wellKnownPSNames,"Q", 392); + PSWDictEnter(wellKnownPSNames,"R", 393); + PSWDictEnter(wellKnownPSNames,"S", 394); + PSWDictEnter(wellKnownPSNames,"T", 395); + PSWDictEnter(wellKnownPSNames,"U", 396); + PSWDictEnter(wellKnownPSNames,"V", 397); + PSWDictEnter(wellKnownPSNames,"W", 398); + PSWDictEnter(wellKnownPSNames,"X", 399); + PSWDictEnter(wellKnownPSNames,"Y", 400); + PSWDictEnter(wellKnownPSNames,"Z", 401); + PSWDictEnter(wellKnownPSNames,"a", 402); + PSWDictEnter(wellKnownPSNames,"b", 403); + PSWDictEnter(wellKnownPSNames,"c", 404); + PSWDictEnter(wellKnownPSNames,"d", 405); + PSWDictEnter(wellKnownPSNames,"e", 406); + PSWDictEnter(wellKnownPSNames,"f", 407); + PSWDictEnter(wellKnownPSNames,"g", 408); + PSWDictEnter(wellKnownPSNames,"h", 409); + PSWDictEnter(wellKnownPSNames,"i", 410); + PSWDictEnter(wellKnownPSNames,"j", 411); + PSWDictEnter(wellKnownPSNames,"k", 412); + PSWDictEnter(wellKnownPSNames,"l", 413); + PSWDictEnter(wellKnownPSNames,"m", 414); + PSWDictEnter(wellKnownPSNames,"n", 415); + PSWDictEnter(wellKnownPSNames,"o", 416); + PSWDictEnter(wellKnownPSNames,"p", 417); + PSWDictEnter(wellKnownPSNames,"q", 418); + PSWDictEnter(wellKnownPSNames,"r", 419); + PSWDictEnter(wellKnownPSNames,"s", 420); + PSWDictEnter(wellKnownPSNames,"t", 421); + PSWDictEnter(wellKnownPSNames,"u", 422); + PSWDictEnter(wellKnownPSNames,"v", 423); + PSWDictEnter(wellKnownPSNames,"w", 424); + PSWDictEnter(wellKnownPSNames,"x", 425); + PSWDictEnter(wellKnownPSNames,"y", 426); + PSWDictEnter(wellKnownPSNames,"z", 427); + PSWDictEnter(wellKnownPSNames,"setvmthreshold", 428); + PSWDictEnter(wellKnownPSNames,"<<", 429); + PSWDictEnter(wellKnownPSNames,">>", 430); + diff --git a/xc/config/pswrap/systemnames.c b/xc/config/pswrap/systemnames.c new file mode 100644 index 000000000..4f91a3584 --- /dev/null +++ b/xc/config/pswrap/systemnames.c @@ -0,0 +1,46 @@ +/* + * systemnames.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#include "pswdict.h" + +PSWDict wellKnownPSNames; + +void InitWellKnownPSNames() +{ +#include "sysname_gen.c" +} diff --git a/xc/config/pswrap/yyerror.c b/xc/config/pswrap/yyerror.c new file mode 100644 index 000000000..ca6a7da04 --- /dev/null +++ b/xc/config/pswrap/yyerror.c @@ -0,0 +1,84 @@ +/* + * yyerror.c + * + * (c) Copyright 1988-1994 Adobe Systems Incorporated. + * All rights reserved. + * + * Permission to use, copy, modify, distribute, and sublicense this software + * and its documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notices appear in all copies and that + * both those copyright notices and this permission notice appear in + * supporting documentation and that the name of Adobe Systems Incorporated + * not be used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. No trademark license + * to use the Adobe trademarks is hereby granted. If the Adobe trademark + * "Display PostScript"(tm) is used to describe this software, its + * functionality or for any other purpose, such use shall be limited to a + * statement that this software works in conjunction with the Display + * PostScript system. Proper trademark attribution to reflect Adobe's + * ownership of the trademark shall be given whenever any such reference to + * the Display PostScript system is made. + * + * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR + * ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. + * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON- INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL ADOBE BE LIABLE + * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ADOBE WILL NOT + * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE. + * + * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems + * Incorporated which may be registered in certain jurisdictions + * + * Author: Adobe Systems Incorporated + */ + +#include <stdio.h> +#include <ctype.h> + +/* ErrIntro prints a standard intro for error messages; + * change it if your system uses something else. We have many options: + * + * to match Macintosh: #define FMT "File \"%s\"; Line %d # " + * to match BSD cc: #define FMT "\"%s\", line %d: " + * to match gcc: #define FMT "%s:%d: " + * to match Mips cc: #define FMT "pswrap: Error: %s, line %d: " + */ + + +#define INTRO "# In function %s -\n" + +#ifdef macintosh +#define FMT "File \"%s\"; Line %d # " +#else /* macintosh */ +#define FMT "\"%s\", line %d: " +#endif /* macintosh */ + +ErrIntro(line) int line; { + extern char *ifile; + extern int reportedPSWName; + extern char *currentPSWName; + extern int errorCount; + + if (! reportedPSWName && currentPSWName) { + reportedPSWName = 1; + fprintf(stderr,INTRO,currentPSWName); + } + fprintf(stderr,FMT,ifile,line); + errorCount++; +} + + +yyerror(errmsg) +char *errmsg; +{ + extern char yytext[]; + extern int yylineno; + + ErrIntro(yylineno); + fprintf(stderr,"%s near text \"%s\"\n",errmsg,yytext); +} + |