![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Quarks.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk|
Return to Quarks.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk |
1.1 root 1: #ifndef lint
2: static char rcsid[] = "$Header: Quarks.c,v 1.3 87/09/11 21:24:19 haynes Rel $";
3: #endif lint
4:
5: /*
6: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
7: *
8: * All Rights Reserved
9: *
10: * Permission to use, copy, modify, and distribute this software and its
11: * documentation for any purpose and without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and that
13: * both that copyright notice and this permission notice appear in
14: * supporting documentation, and that the name of Digital Equipment
15: * Corporation not be used in advertising or publicity pertaining to
16: * distribution of the software without specific, written prior permission.
17: *
18: *
19: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25: * SOFTWARE.
26: */
27: /* File: Quarks.c - last edit by */
28:
29: #include <sys/param.h>
30: #include "Xlib.h"
31: #include "Xlibos.h"
32: #include "Xresource.h"
33: #include "Quarks.h"
34: #include <strings.h>
35:
36: extern void bcopy();
37:
38:
39: typedef int Signature;
40:
41: XrmQuark nextQuark = 1; /* next available quark number */
42:
43: XrmAtom *quarkToAtomTable = NULL;
44: int maxQuarks = 0; /* max names in current quarkToAtomTable */
45: #define QUARKQUANTUM 300 /* how much to extend quarkToAtomTable by */
46:
47: typedef struct _NodeRec *Node;
48: typedef struct _NodeRec {
49: Node next;
50: Signature sig;
51: XrmQuark quark;
52: XrmAtom name;
53: } NodeRec;
54:
55: #define HASHTABLESIZE 1000
56: static Node nodeTable[HASHTABLESIZE];
57:
58:
59:
60: /* predefined quarks */
61:
62: /* Representation types */
63:
64: XrmQuark XrmQBoolean;
65: XrmQuark XrmQColor;
66: XrmQuark XrmQCursor;
67: XrmQuark XrmQDims;
68: XrmQuark XrmQDisplay;
69: XrmQuark XrmQFile;
70: XrmQuark XrmQFont;
71: XrmQuark XrmQFontStruct;
72: XrmQuark XrmQGeometry;
73: XrmQuark XrmQInt;
74: XrmQuark XrmQPixel;
75: XrmQuark XrmQPixmap;
76: XrmQuark XrmQPointer;
77: XrmQuark XrmQString;
78: XrmQuark XrmQWindow;
79:
80: /* "Enumeration" constants */
81:
82: XrmQuark XrmQEfalse;
83: XrmQuark XrmQEno;
84: XrmQuark XrmQEoff;
85: XrmQuark XrmQEon;
86: XrmQuark XrmQEtrue;
87: XrmQuark XrmQEyes;
88:
89:
90: XrmQuark XrmAtomToQuark(name)
91: register XrmAtom name;
92: {
93: register Signature sig = 0;
94: register Signature scale = 27;
95: register XrmAtom tname;
96: register Node np;
97: register XrmAtom npn;
98: Node *hashp;
99: unsigned strLength;
100:
101: if (name == NULL)
102: return (NULLQUARK);
103:
104: /* Compute atom signature (sparse 31-bit hash value) */
105: for (tname = name; *tname != '\0'; tname++)
106: sig = sig*scale + (unsigned int) *tname;
107: strLength = tname - name + 1;
108: if (sig < 0)
109: sig = -sig;
110:
111: /* Look for atom in hash table */
112: hashp = &nodeTable[sig % HASHTABLESIZE];
113: for (np = *hashp; np != NULL; np = np->next) {
114: if (np->sig == sig) {
115: for (npn=np->name, tname = name;
116: ((scale = *tname) != 0) && (scale == *npn); ++tname, ++npn) {};
117: if (scale == *npn) {
118: return np->quark;
119: }
120: }
121: }
122:
123: /* Not found, add atom to hash table */
124: np = (Node) Xmalloc (sizeof (NodeRec));
125: np->next = *hashp;
126: *hashp = np;
127: np->sig = sig;
128: bcopy(name, (np->name = Xmalloc(strLength)), (int) strLength);
129: np->quark = nextQuark;
130:
131: if (nextQuark >= maxQuarks) {
132: maxQuarks += QUARKQUANTUM;
133: if (quarkToAtomTable != NULL)
134: quarkToAtomTable = (XrmAtom *) Xrealloc((char *) quarkToAtomTable,
135: (unsigned) maxQuarks * sizeof(XrmAtom));
136: else
137: quarkToAtomTable = (XrmAtom *) Xcalloc(
138: (unsigned) maxQuarks, sizeof(XrmAtom));
139: }
140: quarkToAtomTable[nextQuark] = np->name;
141: ++nextQuark;
142: return np->quark;
143: }
144:
145: extern XrmQuark XrmUniqueQuark()
146: {
147: XrmQuark quark;
148:
149: quark = nextQuark;
150: if (nextQuark >= maxQuarks) {
151: maxQuarks += QUARKQUANTUM;
152: if (quarkToAtomTable != NULL)
153: quarkToAtomTable = (XrmAtom *) Xrealloc((char *) quarkToAtomTable,
154: (unsigned) maxQuarks * sizeof(XrmAtom));
155: else
156: quarkToAtomTable = (XrmAtom *) Xcalloc(
157: (unsigned) maxQuarks, sizeof(XrmAtom));
158: }
159: quarkToAtomTable[nextQuark] = NULLATOM;
160: ++nextQuark;
161: return (quark);
162: }
163:
164:
165: XrmAtom XrmQuarkToAtom(quark)
166: XrmQuark quark;
167: {
168: if (quark <= 0 || quark >= nextQuark)
169: return NULLATOM;
170: return quarkToAtomTable[quark];
171: }
172:
173:
174: void XrmStringToQuarkList(name, quarks)
175: register char *name;
176: register XrmQuarkList quarks;
177: {
178: register int i;
179: static char oneName[1000];
180:
181: if (name != NULL) {
182: for (i = 0 ; (name[0] != '\0') ; name++) {
183: if (*name == '.') {
184: if (i == 0) {
185: /* Skip over leading . */
186: } else {
187: oneName[i] = 0;
188: *quarks = XrmAtomToQuark(oneName);
189: quarks++;
190: i = 0;
191: }
192: } else {
193: oneName[i] = *name;
194: i++;
195: }
196: }
197: if (i != 0) {
198: oneName[i] = 0;
199: *quarks = XrmAtomToQuark(oneName);
200: quarks++;
201: }
202: }
203: *quarks = NULLQUARK;
204: }
205:
206:
207: XrmQuarkList XrmNewQuarkList()
208: {
209: register XrmQuarkList result;
210:
211: result = (XrmQuarkList) Xmalloc(sizeof(XrmQuark));
212: *result = NULLQUARK;
213: return result;
214: }
215:
216:
217: /* ||| Could be replaced by define in Xresource.h, but Xfree being a macro
218: complicates things. */
219:
220: XrmQuarkList XrmFreeQuarkList(list)
221: XrmQuarkList list;
222: {
223: Xfree((char *) list);
224: return (XrmQuarkList) NULL;
225: }
226:
227:
228:
229: /* Return the number of elements in an atomlist. */
230:
231: int XrmQuarkListLength(list)
232: register XrmQuarkList list;
233: {
234: register int result;
235:
236: for (result = 0; *list != NULLQUARK ; result++, list++) ;
237: return result;
238: }
239:
240:
241: XrmQuarkList XrmCopyQuarkList(list)
242: register XrmQuarkList list;
243: {
244: register int length;
245: register XrmQuarkList result, dest;
246:
247: length = XrmQuarkListLength(list)+1;
248: result = (XrmQuarkList) Xcalloc((unsigned) length, sizeof(XrmQuark));
249: for (dest = result; --length >= 0 ; dest++, list++)
250: *dest = *list;
251: return result;
252: }
253:
254:
255: void QuarkInitialize()
256: {
257: /* Representation types */
258:
259: XrmQBoolean = XrmAtomToQuark(XrmRBoolean);
260: XrmQColor = XrmAtomToQuark(XrmRColor);
261: XrmQCursor = XrmAtomToQuark(XrmRCursor);
262: XrmQDims = XrmAtomToQuark(XrmRDims);
263: XrmQDisplay = XrmAtomToQuark(XrmRDisplay);
264: XrmQFile = XrmAtomToQuark(XrmRFile);
265: XrmQFont = XrmAtomToQuark(XrmRFont);
266: XrmQFontStruct = XrmAtomToQuark(XrmRFontStruct);
267: XrmQGeometry = XrmAtomToQuark(XrmRGeometry);
268: XrmQInt = XrmAtomToQuark(XrmRInt);
269: XrmQPixel = XrmAtomToQuark(XrmRPixel);
270: XrmQPixmap = XrmAtomToQuark(XrmRPixmap);
271: XrmQPointer = XrmAtomToQuark(XrmRPointer);
272: XrmQString = XrmAtomToQuark(XrmRString);
273: XrmQWindow = XrmAtomToQuark(XrmRWindow);
274:
275: /* Boolean enumeration constants */
276:
277: XrmQEfalse = XrmAtomToQuark(XrmEfalse);
278: XrmQEno = XrmAtomToQuark(XrmEno);
279: XrmQEoff = XrmAtomToQuark(XrmEoff);
280: XrmQEon = XrmAtomToQuark(XrmEon);
281: XrmQEtrue = XrmAtomToQuark(XrmEtrue);
282: XrmQEyes = XrmAtomToQuark(XrmEyes);
283: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.