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