aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/config/pswrap/pswsemantics.c
diff options
context:
space:
mode:
authorReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
committerReinhard Tartler <siretart@tauware.de>2011-10-10 17:43:39 +0200
commitf4092abdf94af6a99aff944d6264bc1284e8bdd4 (patch)
tree2ac1c9cc16ceb93edb2c4382c088dac5aeafdf0f /nx-X11/config/pswrap/pswsemantics.c
parenta840692edc9c6d19cd7c057f68e39c7d95eb767d (diff)
downloadnx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.gz
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.tar.bz2
nx-libs-f4092abdf94af6a99aff944d6264bc1284e8bdd4.zip
Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1
Summary: Imported nx-X11-3.1.0-1.tar.gz Keywords: Imported nx-X11-3.1.0-1.tar.gz into Git repository
Diffstat (limited to 'nx-X11/config/pswrap/pswsemantics.c')
-rw-r--r--nx-X11/config/pswrap/pswsemantics.c551
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;
+}