Return to atom.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / dix

Annotation of researchv9/X11/src/X.V11R1/server/dix/atom.c, revision 1.1

1.1     ! root        1: /***********************************************************
        !             2: Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
        !             3: and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
        !             4: 
        !             5:                         All Rights Reserved
        !             6: 
        !             7: Permission to use, copy, modify, and distribute this software and its 
        !             8: documentation for any purpose and without fee is hereby granted, 
        !             9: provided that the above copyright notice appear in all copies and that
        !            10: both that copyright notice and this permission notice appear in 
        !            11: supporting documentation, and that the names of Digital or MIT not be
        !            12: used in advertising or publicity pertaining to distribution of the
        !            13: software without specific, written prior permission.  
        !            14: 
        !            15: DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
        !            16: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
        !            17: DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
        !            18: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
        !            19: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
        !            20: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
        !            21: SOFTWARE.
        !            22: 
        !            23: ******************************************************************/
        !            24: 
        !            25: /* $Header: atom.c,v 1.21 87/09/11 07:18:24 toddb Exp $ */
        !            26: 
        !            27: #include "X.h"
        !            28: #include "Xatom.h"
        !            29: #include "misc.h"
        !            30: 
        !            31: #define InitialTableSize 100
        !            32: 
        !            33: char *Xalloc();
        !            34: 
        !            35: typedef struct _Node {
        !            36:     struct _Node   *left,   *right;
        !            37:     Atom a;
        !            38:     unsigned int fingerPrint;
        !            39:     char   *string;
        !            40: } NodeRec, *NodePtr;
        !            41: 
        !            42: static Atom lastAtom = None;
        !            43: static NodePtr atomRoot = (NodePtr)NULL;
        !            44: static int tableLength;
        !            45: static NodePtr *nodeTable;
        !            46: 
        !            47: Atom 
        !            48: MakeAtom(string, len, makeit)
        !            49:     char *string;
        !            50:     int len;
        !            51:     Bool makeit;
        !            52: {
        !            53:     register    NodePtr * np;
        !            54:     int     comp, i;
        !            55:     register unsigned int   fp = 0;
        !            56: 
        !            57:     np = &atomRoot;
        !            58:     for (i = 0; i < (len+1)/2; i++)
        !            59:     {
        !            60:        fp = fp * 27 + string[i];
        !            61:        fp = fp * 27 + string[len - 1 - i];
        !            62:     }
        !            63:     while (*np != (NodePtr) NULL)
        !            64:     {
        !            65:        if (fp < (*np)->fingerPrint)
        !            66:            np = &((*np)->left);
        !            67:        else if (fp > (*np)->fingerPrint)
        !            68:            np = &((*np)->right);
        !            69:        else
        !            70:        {                              /* now start testing the strings */
        !            71:            comp = strncmp(string, (*np)->string, len);
        !            72:            if ((comp < 0) || ((comp == 0) && (len < strlen((*np)->string))))
        !            73:                np = &((*np)->left);
        !            74:            else if (comp > 0)
        !            75:                np = &((*np)->right);
        !            76:            else
        !            77:                return(*np)->a;
        !            78:            }
        !            79:     }
        !            80:     if (makeit)
        !            81:     {
        !            82:        *np = (NodePtr) Xalloc(sizeof(NodeRec));
        !            83:        (*np)->left = (*np)->right = (NodePtr) NULL;
        !            84:        (*np)->fingerPrint = fp;
        !            85:        (*np)->a = (++lastAtom);
        !            86:        strncpy((*np)->string = Xalloc(len + 1), string, len);
        !            87:        (*np)->string[len] = 0;
        !            88:        if (lastAtom >= tableLength)
        !            89:        {
        !            90:            tableLength *= 2;
        !            91:            nodeTable = (NodePtr *) Xrealloc(
        !            92:                    nodeTable, tableLength * sizeof(NodePtr));
        !            93:        }
        !            94:        nodeTable[lastAtom] = *np;
        !            95:        return(*np)->a;
        !            96:     }
        !            97:     else
        !            98:        return None;
        !            99: }
        !           100: 
        !           101: ValidAtom(atom)
        !           102:     Atom atom;
        !           103: {
        !           104:     return (atom != None) && (atom <= lastAtom);
        !           105: }
        !           106: 
        !           107: char *
        !           108: NameForAtom(atom)
        !           109:     Atom atom;
        !           110: {
        !           111:     NodePtr node;
        !           112:     if (atom > lastAtom) return 0;
        !           113:     if ((node = nodeTable[atom]) == (NodePtr)NULL) return 0;
        !           114:     return node->string;
        !           115: }
        !           116: 
        !           117: AtomError()
        !           118: {
        !           119:     FatalError("initializing atoms");
        !           120: }
        !           121: 
        !           122: InitAtoms()
        !           123: {
        !           124:     FreeAllAtoms();
        !           125:     tableLength = InitialTableSize;
        !           126:     nodeTable = (NodePtr *)Xalloc(InitialTableSize*sizeof(NodePtr));
        !           127:     nodeTable[None] = (NodePtr)NULL;
        !           128:     MakePredeclaredAtoms();
        !           129:     if (lastAtom != XA_LAST_PREDEFINED)
        !           130:        AtomError ();
        !           131: }
        !           132: 
        !           133: FreeAllAtoms()
        !           134: {
        !           135:     if(atomRoot == (NodePtr)NULL)
        !           136:        return;
        !           137:     FreeAtom(atomRoot);
        !           138:     atomRoot = (NodePtr)NULL;
        !           139:     Xfree(nodeTable);
        !           140:     nodeTable = (NodePtr *)NULL;
        !           141:     lastAtom = None;
        !           142: }
        !           143: 
        !           144: FreeAtom(patom)
        !           145:     NodePtr patom;
        !           146: {
        !           147:     if(patom->left)
        !           148:        FreeAtom(patom->left);
        !           149:     if(patom->right)
        !           150:        FreeAtom(patom->right);
        !           151:     Xfree(patom->string);
        !           152:     Xfree(patom);
        !           153: }
        !           154:     

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.