![[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 / oldXrm|
Return to Quarks.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXrm |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)Atom.c 1.21 3/19/87";
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:
28:
29: /* File: Quarks.c - last edit by */
30:
31: #include <sys/param.h>
32: #include "Xlib.h"
33: #include "Xlibos.h"
34: #include "Xresource.h"
35: #include "Quarks.h"
36: #include <strings.h>
37:
38: extern void bcopy();
39:
40:
41: typedef int Signature;
42:
43: static XrmQuark nextQuark = 1; /* next available quark number */
44: static XrmAtom *quarkToAtomTable = NULL;
45: static int maxQuarks = 0; /* max names in current quarkToAtomTable */
46: #define QUARKQUANTUM 300 /* how much to extend quarkToAtomTable by */
47:
48: typedef struct _NodeRec *Node;
49: typedef struct _NodeRec {
50: Node next;
51: Signature sig;
52: XrmQuark quark;
53: XrmAtom name;
54: } NodeRec;
55:
56: #define HASHTABLESIZE 1000
57: static Node nodeTable[HASHTABLESIZE];
58:
59:
60:
61: /* predefined quarks */
62:
63: /* Representation types */
64:
65: XrmQuark XrmQBoolean;
66: XrmQuark XrmQColor;
67: XrmQuark XrmQCursor;
68: XrmQuark XrmQDims;
69: XrmQuark XrmQDisplay;
70: XrmQuark XrmQFile;
71: XrmQuark XrmQFont;
72: XrmQuark XrmQFontStruct;
73: XrmQuark XrmQGeometry;
74: XrmQuark XrmQInt;
75: XrmQuark XrmQPixel;
76: XrmQuark XrmQPixmap;
77: XrmQuark XrmQPointer;
78: XrmQuark XrmQString;
79: XrmQuark XrmQWindow;
80:
81: /* "Enumeration" constants */
82:
83: XrmQuark XrmQEfalse;
84: XrmQuark XrmQEno;
85: XrmQuark XrmQEoff;
86: XrmQuark XrmQEon;
87: XrmQuark XrmQEtrue;
88: XrmQuark XrmQEyes;
89:
90:
91: static XrmAllocMoreQuartToAtomTable()
92: {
93: unsigned size;
94:
95: maxQuarks += QUARKQUANTUM;
96: size = (unsigned) maxQuarks * sizeof(XrmAtom);
97: if (quarkToAtomTable == (XrmAtom *)NULL)
98: quarkToAtomTable = (XrmAtom *) Xmalloc(size);
99: else
100: quarkToAtomTable =
101: (XrmAtom *) Xrealloc((char *) quarkToAtomTable, size);
102: }
103:
104: XrmQuark XrmAtomToQuark(name)
105: register XrmAtom name;
106: {
107: register Signature sig = 0;
108: register Signature scale = 27;
109: register XrmAtom tname;
110: register Node np;
111: register XrmAtom npn;
112: Node *hashp;
113: unsigned strLength;
114:
115: if (name == NULL)
116: return (NULLQUARK);
117:
118: /* Compute atom signature (sparse 31-bit hash value) */
119: for (tname = name; *tname != '\0'; tname++)
120: sig = sig*scale + (unsigned int) *tname;
121: strLength = tname - name + 1;
122: if (sig < 0)
123: sig = -sig;
124:
125: /* Look for atom in hash table */
126: hashp = &nodeTable[sig % HASHTABLESIZE];
127: for (np = *hashp; np != NULL; np = np->next) {
128: if (np->sig == sig) {
129: for (npn=np->name, tname = name;
130: ((scale = *tname) != 0) && (scale == *npn); ++tname, ++npn) {};
131: if (scale == *npn) {
132: return np->quark;
133: }
134: }
135: }
136:
137: /* Not found, add atom to hash table */
138: np = (Node) Xmalloc (sizeof (NodeRec));
139: np->next = *hashp;
140: *hashp = np;
141: np->sig = sig;
142: bcopy(name, (np->name = Xmalloc(strLength)), (int) strLength);
143: np->quark = nextQuark;
144:
145: if (nextQuark >= maxQuarks)
146: XrmAllocMoreQuartToAtomTable();
147:
148: quarkToAtomTable[nextQuark] = np->name;
149: ++nextQuark;
150: return np->quark;
151: }
152:
153: extern XrmQuark XrmUniqueQuark()
154: {
155: XrmQuark quark;
156:
157: quark = nextQuark;
158: if (nextQuark >= maxQuarks)
159: XrmAllocMoreQuartToAtomTable();
160: quarkToAtomTable[nextQuark] = NULLATOM;
161: ++nextQuark;
162: return (quark);
163: }
164:
165:
166: XrmAtom XrmQuarkToAtom(quark)
167: XrmQuark quark;
168: {
169: if (quark <= 0 || quark >= nextQuark)
170: return NULLATOM;
171: return quarkToAtomTable[quark];
172: }
173:
174:
175: void XrmStringToQuarkList(name, quarks)
176: register char *name;
177: register XrmQuarkList quarks;
178: {
179: register int i;
180: static char oneName[1000];
181:
182: if (name != NULL) {
183: for (i = 0 ; (name[0] != '\0') ; name++) {
184: if (*name == '.') {
185: if (i == 0) {
186: /* Skip over leading . */
187: } else {
188: oneName[i] = 0;
189: *quarks = XrmAtomToQuark(oneName);
190: quarks++;
191: i = 0;
192: }
193: } else {
194: oneName[i] = *name;
195: i++;
196: }
197: }
198: if (i != 0) {
199: oneName[i] = 0;
200: *quarks = XrmAtomToQuark(oneName);
201: quarks++;
202: }
203: }
204: *quarks = NULLQUARK;
205: }
206:
207:
208: XrmQuarkList XrmNewQuarkList()
209: {
210: register XrmQuarkList result;
211:
212: result = (XrmQuarkList) Xmalloc(sizeof(XrmQuark));
213: *result = NULLQUARK;
214: return result;
215: }
216:
217:
218: /* ||| Could be replaced by define in Xresource.h, but Xfree being a macro
219: complicates things. */
220:
221: XrmQuarkList XrmFreeQuarkList(list)
222: XrmQuarkList list;
223: {
224: Xfree((char *) list);
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.