diff options
Diffstat (limited to 'nx-X11/config/pswrap/pswsemantics.c')
| -rw-r--r-- | nx-X11/config/pswrap/pswsemantics.c | 551 |
1 files changed, 551 insertions, 0 deletions
diff --git a/nx-X11/config/pswrap/pswsemantics.c b/nx-X11/config/pswrap/pswsemantics.c new file mode 100644 index 000000000..caaff800e --- /dev/null +++ b/nx-X11/config/pswrap/pswsemantics.c @@ -0,0 +1,551 @@ +/* + * 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 <stdlib.h> +#include <stdio.h> + +#ifdef XENVIRONMENT +#include <X11/Xos.h> +#else +#include <string.h> +#endif + +#include "pswdict.h" +#include "pswpriv.h" +#include "pswsemantics.h" + +/***********************/ +/* Module-wide globals */ +/***********************/ + +char *currentPSWName = NULL; +int reportedPSWName = 0; + +static PSWDict currentDict = NULL; + + +/*************************************************/ +/* Procedures called by the parser's annotations */ +/*************************************************/ + +static boolean IsCharType(Type t) +{ + return (t == T_CHAR || t == T_UCHAR); +} + +static boolean IsNumStrType(Type t) +{ + return (t == T_NUMSTR + || t == T_FLOATNUMSTR + || t == T_LONGNUMSTR + || t == T_SHORTNUMSTR); +} + +void PSWName(char *s) +{ + currentPSWName = psw_malloc(strlen(s)+1); + strcpy(currentPSWName, s); + reportedPSWName = 0; +} + + /* Generate the code for this wrap now */ +void FinalizePSWrapDef(Header hdr, Body body) +{ + 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(boolean isStatic, Args inArgs, Args 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 %s 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 type, char *val) +{ + register Token token = (Token)psw_calloc(sizeof(TokenRec), 1); + + 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 type, char *val, char *ind) +{ + register Token token = (Token)psw_calloc(sizeof(TokenRec), 1); + 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 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(char *name) +{ + register Item item = (Item)psw_calloc(sizeof(ItemRec), 1); + item->next = NULL; + item->name = name; + item->sourceLine = yylineno; + return item; +} + +Item PSWStarItem(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(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(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(char *name) +{ + Subscript subscript = (Subscript)psw_calloc(sizeof(SubscriptRec), 1); + subscript->name = name; + return subscript; +} + +Subscript PSWIntegerSubscript(int val) +{ + Subscript subscript = (Subscript)psw_calloc(sizeof(SubscriptRec), 1); + subscript->constant = true; + subscript->val = val; + return subscript; +} + +Args ConsPSWArgs(Arg arg, Args args) +{ + arg->next = args; + return arg; +} + +Tokens AppendPSWToken(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 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 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; +} |