Itcl - the [incr Tcl] extension

    Tcl_HashEntry *reshPtr, *hPtr;

    /* could be resolved directly */
    if ((reshPtr = Tcl_FindHashEntry(&iclsPtr->resolveVars, lookupName)) != NULL) {
	return reshPtr;
    } else {



    /* try to build virtual table for this var */
    const char *varName, *simpleName;
    Tcl_DString buffer, buffer2, *bufferC;
    ItclHierIter hier;
    ItclClass* iclsPtr2;
    ItclVarLookup *vlookup;
    ItclVariable *ivPtr;
    Tcl_Namespace* nsPtr;
    Tcl_Obj *vnObjPtr;
    int newEntry, processAncestors;

    /* simple speedup: avoid lookup for ::itcl::internal's - not resolvable in a class */
    if (strncmp(lookupName, ITCL_NAMESPACE, sizeof(ITCL_NAMESPACE)-1) == 0) {
	return NULL;
    }
    
    /* (de)qualify to simple name */
    varName = simpleName = lookupName;
    while(*varName) {
        if (*varName++ == ':') {
            if (*varName++ == ':') { simpleName = varName; }

        };

    }
    vnObjPtr = Tcl_NewStringObj(simpleName, -1);
    
    processAncestors = simpleName != lookupName;

    //!!! printf("====get======== %p : %s -- v: %s (%s), pa: %d ===== \n", iclsPtr, Tcl_GetString(iclsPtr->fullNamePtr), lookupName, simpleName, processAncestors);
    
    Tcl_DStringInit(&buffer);
    Tcl_DStringInit(&buffer2);

    /*
     *  Scan through all classes in the hierarchy, from most to
     *  least specific.  Add a lookup entry for each variable

            varName = simpleName;
            bufferC = &buffer;
            nsPtr = iclsPtr2->nsPtr;

            while (1) {
		hPtr = Tcl_CreateHashEntry(&iclsPtr->resolveVars,
		    varName, &newEntry);
                //!!! printf("    **** %s %p : %s : %s -> %p\n", newEntry ? "find   " : "created", iclsPtr2, Tcl_GetString(iclsPtr2->fullNamePtr), varName, hPtr);




		/* check for same name in current class */
		if (!newEntry) {
		    vlookup = (ItclVarLookup*)Tcl_GetHashValue(hPtr);
		    //!!! printf("    **** exist %p : %p != %p / %s != %s && %d\n", vlookup, vlookup->ivPtr, ivPtr, Tcl_GetString(vlookup->ivPtr->fullNamePtr), Tcl_GetString(ivPtr->fullNamePtr), iclsPtr2 == iclsPtr);
		    if (vlookup->ivPtr != ivPtr && iclsPtr2 == iclsPtr) {
		    	/* if used multiple times - unbind, else - overwrite */
			if (vlookup->usage > 1) {
			    /* correct leastQualName */
			    vlookup->leastQualName = NULL;
			    processAncestors = 1; /* correction in progress */
			    /* should create new lookup */
			    --vlookup->usage;
			    vlookup = NULL;
			} else {
			    /* correct values (overwrite) */
			    vlookup->usage = 0;
			    goto setResVar;
			}
			newEntry = 1;
		    } else {
#if 1
		    	/* var exists and no correction necessary - next var */
			if (!processAncestors) {
			    break;
			}
#endif
			/* check leastQualName correction needed */
			if (!vlookup->leastQualName) {
			    vlookup->leastQualName = 
				Tcl_GetHashKey(&iclsPtr->resolveVars, hPtr);
			}
			/* reset vlookup for full-qualified names - new lookup */
			if (vlookup->ivPtr != ivPtr) {
			    vlookup = NULL;
			}
		    }
		}
		//!!! printf("    **** newEntry %d, vlookup: %p\n", newEntry, vlookup);
		if (newEntry) {
		    if (!vlookup) {
			/* create new (or overwrite) */
			vlookup = (ItclVarLookup *)ckalloc(sizeof(ItclVarLookup));
			vlookup->usage = 0;

		    setResVar:

			}
		    }

		    Tcl_SetHashValue(hPtr, (ClientData)vlookup);
		    vlookup->usage++;
		}

                /* if we have found it */
                if (simpleName == lookupName || strcmp(varName, lookupName) == 0) {
		    if (!reshPtr) {
			reshPtr = hPtr;
		    }
		    break;
                }
                if (nsPtr == NULL) {
                    break;
                }
                Tcl_DStringSetLength(bufferC, 0);
                Tcl_DStringAppend(bufferC, nsPtr->name, -1);
                Tcl_DStringAppend(bufferC, "::", -1);
                Tcl_DStringAppend(bufferC, varName, -1);
                varName = Tcl_DStringValue(bufferC);
                bufferC = (bufferC == &buffer) ? &buffer2 : &buffer;

                nsPtr = nsPtr->parentPtr;
            }

        }



	/* Stop create vars for ancestors (if not needed) */
	if (!processAncestors && reshPtr) {
#if 1


	    /* simple name - don't need to check ancestors */


	    break;
#endif
	}

        iclsPtr2 = Itcl_AdvanceHierIter(&hier);
    }
    Itcl_DeleteHierIter(&hier);

#if 0 /* DUMP var table */
    //!!!
    printf("===DUMP===== %p : %s ===== \n", iclsPtr, Tcl_GetString(iclsPtr->fullNamePtr));

    Itcl_InitHierIter(&hier, iclsPtr);
    iclsPtr2 = Itcl_AdvanceHierIter(&hier);
    while (iclsPtr2 != NULL) {
    	Tcl_HashSearch place;

        //!!!

    Itcl_DeleteHierIter(&hier);
#endif

	Tcl_DStringFree(&buffer);
	Tcl_DStringFree(&buffer2);
	Tcl_DecrRefCount(vnObjPtr);

	if (reshPtr == NULL) {
	    reshPtr = Tcl_FindHashEntry(&iclsPtr->resolveVars, lookupName);
	}
	//!!! printf("====ret======== %p : %s ===== \n", reshPtr, reshPtr && ((ItclVarLookup*)Tcl_GetHashValue(reshPtr))->leastQualName ? ((ItclVarLookup*)Tcl_GetHashValue(reshPtr))->leastQualName : "<NULL>");
	return reshPtr;
    }
#endif
}

/*
 * ------------------------------------------------------------------------