/*ARGSUSED*/
static int
EmbWinLayoutProc(
TkText *textPtr, /* Text widget being layed out. */
TkTextIndex *indexPtr, /* Identifies first character in chunk. */
TkTextSegment *ewPtr, /* Segment corresponding to indexPtr. */
int offset, /* Offset within segPtr corresponding to
* indexPtr (always 0). */
int maxX, /* Chunk must not occupy pixels at this
* position or higher. */
int maxChars, /* Chunk must not include more than this many
* characters. */
int noCharsYet, /* Non-zero means no characters have been
* assigned to this line yet. */
TkWrapMode wrapMode, /* Wrap mode to use for line:
* TEXT_WRAPMODE_CHAR, TEXT_WRAPMODE_NONE, or
* TEXT_WRAPMODE_WORD. */
register TkTextDispChunk *chunkPtr)
/* Structure to fill in with information about
* this chunk. The x field has already been
* set by the caller. */
{
int width, height;
TkTextEmbWindowClient *client;
if (offset != 0) {
Tcl_Panic("Non-zero offset in EmbWinLayoutProc");
}
client = EmbWinGetClient(textPtr, ewPtr);
if (client == NULL) {
ewPtr->body.ew.tkwin = NULL;
} else {
ewPtr->body.ew.tkwin = client->tkwin;
}
if ((ewPtr->body.ew.tkwin == NULL) && (ewPtr->body.ew.create != NULL)) {
int code, isNew;
Tk_Window ancestor;
Tcl_HashEntry *hPtr;
const char *before, *string;
Tcl_DString name, buf, *dsPtr = NULL;
before = ewPtr->body.ew.create;
/*
* Find everything up to the next % character and append it to the
* result string.
*/
string = before;
while (*string != 0) {
if ((*string == '%') && (string[1] == '%' || string[1] == 'W')) {
if (dsPtr == NULL) {
Tcl_DStringInit(&buf);
dsPtr = &buf;
}
if (string != before) {
Tcl_DStringAppend(dsPtr, before, (int) (string-before));
before = string;
}
if (string[1] == '%') {
Tcl_DStringAppend(dsPtr, "%", 1);
} else {
/*
* Substitute string as proper Tcl list element.
*/
int spaceNeeded, cvtFlags, length;
const char *str = Tk_PathName(textPtr->tkwin);
spaceNeeded = Tcl_ScanElement(str, &cvtFlags);
length = Tcl_DStringLength(dsPtr);
Tcl_DStringSetLength(dsPtr, length + spaceNeeded);
spaceNeeded = Tcl_ConvertElement(str,
Tcl_DStringValue(dsPtr) + length,
cvtFlags | TCL_DONT_USE_BRACES);
Tcl_DStringSetLength(dsPtr, length + spaceNeeded);
}
before += 2;
string++;
}
string++;
}
/*
* The window doesn't currently exist. Create it by evaluating the
* creation script. The script must return the window's path name:
* look up that name to get back to the window token. Then register
* ourselves as the geometry manager for the window.
*/
if (dsPtr != NULL) {
Tcl_DStringAppend(dsPtr, before, (int) (string-before));
code = Tcl_GlobalEval(textPtr->interp, Tcl_DStringValue(dsPtr));
Tcl_DStringFree(dsPtr);
} else {
code = Tcl_GlobalEval(textPtr->interp, ewPtr->body.ew.create);
}
if (code != TCL_OK) {
createError:
Tcl_BackgroundException(textPtr->interp, code);
goto gotWindow;
}
Tcl_DStringInit(&name);
Tcl_DStringAppend(&name, Tcl_GetStringResult(textPtr->interp), -1);
Tcl_ResetResult(textPtr->interp);
ewPtr->body.ew.tkwin = Tk_NameToWindow(textPtr->interp,
Tcl_DStringValue(&name), textPtr->tkwin);
Tcl_DStringFree(&name);
if (ewPtr->body.ew.tkwin == NULL) {
goto createError;
}
for (ancestor = textPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == Tk_Parent(ewPtr->body.ew.tkwin)) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
badMaster:
Tcl_AppendResult(textPtr->interp, "can't embed ",
Tk_PathName(ewPtr->body.ew.tkwin), " relative to ",
Tk_PathName(textPtr->tkwin), NULL);
Tcl_BackgroundError(textPtr->interp);
ewPtr->body.ew.tkwin = NULL;
goto gotWindow;
}
}
if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
|| (textPtr->tkwin == ewPtr->body.ew.tkwin)) {
goto badMaster;
}
if (client == NULL) {
/*
* We just used a '-create' script to make a new window, which we
* now need to add to our client list.
*/
client = (TkTextEmbWindowClient *)
ckalloc(sizeof(TkTextEmbWindowClient));
client->next = ewPtr->body.ew.clients;
client->textPtr = textPtr;
client->tkwin = NULL;
client->chunkCount = 0;
client->displayed = 0;
client->parent = ewPtr;
ewPtr->body.ew.clients = client;
}
client->tkwin = ewPtr->body.ew.tkwin;
Tk_ManageGeometry(client->tkwin, &textGeomType,
(ClientData) client);
Tk_CreateEventHandler(client->tkwin, StructureNotifyMask,
EmbWinStructureProc, (ClientData) client);
/*
* Special trick! Must enter into the hash table *after* calling
* Tk_ManageGeometry: if the window was already managed elsewhere in
* this text, the Tk_ManageGeometry call will cause the entry to be
* removed, which could potentially lose the new entry.
*/
hPtr = Tcl_CreateHashEntry(&textPtr->sharedTextPtr->windowTable,
Tk_PathName(client->tkwin), &isNew);
Tcl_SetHashValue(hPtr, ewPtr);
}
/*
* See if there's room for this window on this line.
*/
gotWindow:
if (ewPtr->body.ew.tkwin == NULL) {
width = 0;
height = 0;
} else {
width = Tk_ReqWidth(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padX;
height = Tk_ReqHeight(ewPtr->body.ew.tkwin) + 2*ewPtr->body.ew.padY;
}
if ((width > (maxX - chunkPtr->x))
&& !noCharsYet && (textPtr->wrapMode != TEXT_WRAPMODE_NONE)) {
return 0;
}
/*
* Fill in the chunk structure.
*/
chunkPtr->displayProc = TkTextEmbWinDisplayProc;
chunkPtr->undisplayProc = EmbWinUndisplayProc;
chunkPtr->measureProc = NULL;
chunkPtr->bboxProc = EmbWinBboxProc;
chunkPtr->numBytes = 1;
if (ewPtr->body.ew.align == ALIGN_BASELINE) {
chunkPtr->minAscent = height - ewPtr->body.ew.padY;
chunkPtr->minDescent = ewPtr->body.ew.padY;
chunkPtr->minHeight = 0;
} else {
chunkPtr->minAscent = 0;
chunkPtr->minDescent = 0;
chunkPtr->minHeight = height;
}
chunkPtr->width = width;
chunkPtr->breakIndex = -1;
chunkPtr->breakIndex = 1;
chunkPtr->clientData = (ClientData) ewPtr;
if (client != NULL) {
client->chunkCount += 1;
}
return 1;
}
static int
Initialize (
Tcl_Interp *interp)
{
Tcl_Namespace *nsPtr;
Tcl_Namespace *itclNs;
Tcl_HashEntry *hPtr;
Tcl_Obj *objPtr;
ItclObjectInfo *infoPtr;
const char * ret;
char *res_option;
int opt;
int isNew;
if (Tcl_InitStubs(interp, "8.6", 0) == NULL) {
return TCL_ERROR;
}
ret = TclOOInitializeStubs(interp, "1.0");
if (ret == NULL) {
return TCL_ERROR;
}
nsPtr = Tcl_CreateNamespace(interp, ITCL_NAMESPACE, NULL, NULL);
if (nsPtr == NULL) {
Tcl_Panic("Itcl: cannot create namespace: \"%s\" \n", ITCL_NAMESPACE);
}
nsPtr = Tcl_CreateNamespace(interp, ITCL_NAMESPACE"::methodset",
NULL, NULL);
if (nsPtr == NULL) {
Tcl_Panic("Itcl: cannot create namespace: \"%s::methodset\" \n",
ITCL_NAMESPACE);
}
nsPtr = Tcl_CreateNamespace(interp, ITCL_NAMESPACE"::internal::dicts",
NULL, NULL);
if (nsPtr == NULL) {
Tcl_Panic("Itcl: cannot create namespace: \"%s::internal::dicts\" \n",
ITCL_NAMESPACE);
}
Tcl_CreateObjCommand(interp, ITCL_NAMESPACE"::finish", ItclFinishCmd,
NULL, NULL);
/* for debugging only !!! */
#ifdef OBJ_REF_COUNT_DEBUG
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::dumprefcountinfo",
ItclDumpRefCountInfo, NULL, NULL);
#endif
#ifdef ITCL_PRESERVE_DEBUG
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::dumppreserveinfo",
ItclDumpPreserveInfo, NULL, NULL);
#endif
/* END for debugging only !!! */
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::methodset::callCCommand",
ItclCallCCommand, NULL, NULL);
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::methodset::objectUnknownCommand",
ItclObjectUnknownCommand, NULL, NULL);
/*
* Create the top-level data structure for tracking objects.
* Store this as "associated data" for easy access, but link
* it to the itcl namespace for ownership.
*/
infoPtr = (ItclObjectInfo*)ckalloc(sizeof(ItclObjectInfo));
memset(infoPtr, 0, sizeof(ItclObjectInfo));
infoPtr->interp = interp;
infoPtr->class_meta_type = (Tcl_ObjectMetadataType *)ckalloc(
sizeof(Tcl_ObjectMetadataType));
infoPtr->class_meta_type->version = TCL_OO_METADATA_VERSION_CURRENT;
infoPtr->class_meta_type->name = "ItclClass";
infoPtr->class_meta_type->deleteProc = ItclDeleteClassMetadata;
infoPtr->class_meta_type->cloneProc = NULL;
infoPtr->object_meta_type = (Tcl_ObjectMetadataType *)ckalloc(
sizeof(Tcl_ObjectMetadataType));
infoPtr->object_meta_type->version = TCL_OO_METADATA_VERSION_CURRENT;
infoPtr->object_meta_type->name = "ItclObject";
infoPtr->object_meta_type->deleteProc = ItclDeleteObjectMetadata;
infoPtr->object_meta_type->cloneProc = NULL;
Tcl_InitHashTable(&infoPtr->objects, TCL_ONE_WORD_KEYS);
Tcl_InitHashTable(&infoPtr->objectCmds, TCL_ONE_WORD_KEYS);
Tcl_InitObjHashTable(&infoPtr->objectNames);
Tcl_InitHashTable(&infoPtr->classes, TCL_ONE_WORD_KEYS);
Tcl_InitObjHashTable(&infoPtr->nameClasses);
Tcl_InitHashTable(&infoPtr->namespaceClasses, TCL_ONE_WORD_KEYS);
Tcl_InitHashTable(&infoPtr->procMethods, TCL_ONE_WORD_KEYS);
Tcl_InitObjHashTable(&infoPtr->instances);
Tcl_InitHashTable(&infoPtr->objectInstances, TCL_ONE_WORD_KEYS);
Tcl_InitObjHashTable(&infoPtr->classTypes);
infoPtr->ensembleInfo = (EnsembleInfo *)ckalloc(sizeof(EnsembleInfo));
memset(infoPtr->ensembleInfo, 0, sizeof(EnsembleInfo));
Tcl_InitHashTable(&infoPtr->ensembleInfo->ensembles, TCL_ONE_WORD_KEYS);
Tcl_InitHashTable(&infoPtr->ensembleInfo->subEnsembles, TCL_ONE_WORD_KEYS);
infoPtr->ensembleInfo->numEnsembles = 0;
infoPtr->protection = ITCL_DEFAULT_PROTECT;
infoPtr->currClassFlags = 0;
infoPtr->buildingWidget = 0;
infoPtr->typeDestructorArgumentPtr = Tcl_NewStringObj("", -1);
Tcl_IncrRefCount(infoPtr->typeDestructorArgumentPtr);
infoPtr->lastIoPtr = NULL;
Tcl_SetVar(interp, ITCL_NAMESPACE"::internal::dicts::classes", "", 0);
Tcl_SetVar(interp, ITCL_NAMESPACE"::internal::dicts::objects", "", 0);
Tcl_SetVar(interp, ITCL_NAMESPACE"::internal::dicts::classOptions", "", 0);
Tcl_SetVar(interp,
ITCL_NAMESPACE"::internal::dicts::classDelegatedOptions", "", 0);
Tcl_SetVar(interp,
ITCL_NAMESPACE"::internal::dicts::classComponents", "", 0);
Tcl_SetVar(interp,
ITCL_NAMESPACE"::internal::dicts::classVariables", "", 0);
Tcl_SetVar(interp,
ITCL_NAMESPACE"::internal::dicts::classFunctions", "", 0);
Tcl_SetVar(interp,
ITCL_NAMESPACE"::internal::dicts::classDelegatedFunctions", "", 0);
hPtr = Tcl_CreateHashEntry(&infoPtr->classTypes,
(char *)Tcl_NewStringObj("class", -1), &isNew);
Tcl_SetHashValue(hPtr, ITCL_CLASS);
hPtr = Tcl_CreateHashEntry(&infoPtr->classTypes,
(char *)Tcl_NewStringObj("type", -1), &isNew);
Tcl_SetHashValue(hPtr, ITCL_TYPE);
hPtr = Tcl_CreateHashEntry(&infoPtr->classTypes,
(char *)Tcl_NewStringObj("widget", -1), &isNew);
Tcl_SetHashValue(hPtr, ITCL_WIDGET);
hPtr = Tcl_CreateHashEntry(&infoPtr->classTypes,
(char *)Tcl_NewStringObj("widgetadaptor", -1), &isNew);
Tcl_SetHashValue(hPtr, ITCL_WIDGETADAPTOR);
hPtr = Tcl_CreateHashEntry(&infoPtr->classTypes,
(char *)Tcl_NewStringObj("extendedclass", -1), &isNew);
Tcl_SetHashValue(hPtr, ITCL_ECLASS);
res_option = getenv("ITCL_USE_OLD_RESOLVERS");
if (res_option == NULL) {
opt = 1;
} else {
opt = atoi(res_option);
}
infoPtr->useOldResolvers = opt;
Itcl_InitStack(&infoPtr->clsStack);
Itcl_InitStack(&infoPtr->contextStack);
Itcl_InitStack(&infoPtr->constructorStack);
Tcl_SetAssocData(interp, ITCL_INTERP_DATA,
(Tcl_InterpDeleteProc*)FreeItclObjectInfo, (ClientData)infoPtr);
Itcl_PreserveData((ClientData)infoPtr);
#ifdef NEW_PROTO_RESOLVER
ItclVarsAndCommandResolveInit(interp);
#endif
/* first create the Itcl base class as root of itcl classes */
if (Tcl_EvalEx(interp, clazzClassScript, -1, 0) != TCL_OK) {
Tcl_Panic("cannot create Itcl root class ::itcl::clazz");
}
objPtr = Tcl_NewStringObj("::itcl::clazz", -1);
infoPtr->clazzObjectPtr = Tcl_GetObjectFromObj(interp, objPtr);
/* work around for SF bug #254 needed because of problem in TclOO 1.0.2 !! */
if (Tcl_PkgPresent(interp, "TclOO", "1.0.2", 1) != NULL) {
Itcl_IncrObjectRefCount(infoPtr->clazzObjectPtr);
}
Tcl_DecrRefCount(objPtr);
if (infoPtr->clazzObjectPtr == NULL) {
Tcl_AppendResult(interp,
"ITCL: cannot get Object for ::itcl::clazz for class \"",
"::itcl::clazz", "\"", NULL);
return TCL_ERROR;
}
infoPtr->clazzClassPtr = Tcl_GetObjectAsClass(infoPtr->clazzObjectPtr);
AddClassUnknowMethod(interp, infoPtr, infoPtr->clazzClassPtr);
/*
* Initialize the ensemble package first, since we need this
* for other parts of [incr Tcl].
*/
if (Itcl_EnsembleInit(interp) != TCL_OK) {
return TCL_ERROR;
}
Itcl_ParseInit(interp, infoPtr);
/*
* Create "itcl::builtin" namespace for commands that
* are automatically built into class definitions.
*/
if (Itcl_BiInit(interp, infoPtr) != TCL_OK) {
return TCL_ERROR;
}
/*
* Export all commands in the "itcl" namespace so that they
* can be imported with something like "namespace import itcl::*"
*/
itclNs = Tcl_FindNamespace(interp, "::itcl", (Tcl_Namespace*)NULL,
TCL_LEAVE_ERR_MSG);
/*
* This was changed from a glob export (itcl::*) to explicit
* command exports, so that the itcl::is command can *not* be
* exported. This is done for concern that the itcl::is command
* imported might be confusing ("is").
*/
if (!itclNs ||
(Tcl_Export(interp, itclNs, "body", /* reset */ 1) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "class", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "code", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "configbody", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "delete", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "delete_helper", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "ensemble", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "filter", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "find", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "forward", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "local", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "mixin", 0) != TCL_OK) ||
(Tcl_Export(interp, itclNs, "scope", 0) != TCL_OK)) {
return TCL_ERROR;
}
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::internal::commands::sethullwindowname",
ItclSetHullWindowName, infoPtr, NULL);
Tcl_CreateObjCommand(interp,
ITCL_NAMESPACE"::internal::commands::checksetitclhull",
ItclCheckSetItclHull, infoPtr, NULL);
/*
* Set up the variables containing version info.
*/
Tcl_SetVar(interp, "::itcl::version", ITCL_VERSION, TCL_NAMESPACE_ONLY);
Tcl_SetVar(interp, "::itcl::patchLevel", ITCL_PATCH_LEVEL,
TCL_NAMESPACE_ONLY);
#ifdef ITCL_DEBUG_C_INTERFACE
RegisterDebugCFunctions(interp);
#endif
/*
* Package is now loaded.
*/
Tcl_PkgProvideEx(interp, "Itcl", ITCL_PATCH_LEVEL, &itclStubs);
return Tcl_PkgProvideEx(interp, "itcl", ITCL_PATCH_LEVEL, &itclStubs);
}
static int
EmbWinConfigure(
TkText *textPtr, /* Information about text widget that contains
* embedded window. */
TkTextSegment *ewPtr, /* Embedded window to be configured. */
int objc, /* Number of strings in objv. */
Tcl_Obj *const objv[]) /* Array of objects describing configuration
* options. */
{
Tk_Window oldWindow;
TkTextEmbWindowClient *client;
/*
* Copy over client specific value before querying or setting.
*/
client = EmbWinGetClient(textPtr, ewPtr);
if (client != NULL) {
ewPtr->body.ew.tkwin = client->tkwin;
} else {
ewPtr->body.ew.tkwin = NULL;
}
oldWindow = ewPtr->body.ew.tkwin;
if (Tk_SetOptions(textPtr->interp, (char *) &ewPtr->body.ew,
ewPtr->body.ew.optionTable, objc, objv, textPtr->tkwin, NULL,
NULL) != TCL_OK) {
return TCL_ERROR;
}
if (oldWindow != ewPtr->body.ew.tkwin) {
if (oldWindow != NULL) {
Tcl_DeleteHashEntry(Tcl_FindHashEntry(
&textPtr->sharedTextPtr->windowTable,
Tk_PathName(oldWindow)));
Tk_DeleteEventHandler(oldWindow, StructureNotifyMask,
EmbWinStructureProc, (ClientData) client);
Tk_ManageGeometry(oldWindow, NULL, (ClientData) NULL);
if (textPtr->tkwin != Tk_Parent(oldWindow)) {
Tk_UnmaintainGeometry(oldWindow, textPtr->tkwin);
} else {
Tk_UnmapWindow(oldWindow);
}
}
if (client != NULL) {
client->tkwin = NULL;
}
if (ewPtr->body.ew.tkwin != NULL) {
Tk_Window ancestor, parent;
Tcl_HashEntry *hPtr;
int isNew;
/*
* Make sure that the text is either the parent of the embedded
* window or a descendant of that parent. Also, don't allow a
* top-level window to be managed inside a text.
*/
parent = Tk_Parent(ewPtr->body.ew.tkwin);
for (ancestor = textPtr->tkwin; ; ancestor = Tk_Parent(ancestor)) {
if (ancestor == parent) {
break;
}
if (Tk_TopWinHierarchy(ancestor)) {
badMaster:
Tcl_AppendResult(textPtr->interp, "can't embed ",
Tk_PathName(ewPtr->body.ew.tkwin), " in ",
Tk_PathName(textPtr->tkwin), NULL);
ewPtr->body.ew.tkwin = NULL;
if (client != NULL) {
client->tkwin = NULL;
}
return TCL_ERROR;
}
}
if (Tk_TopWinHierarchy(ewPtr->body.ew.tkwin)
|| (ewPtr->body.ew.tkwin == textPtr->tkwin)) {
goto badMaster;
}
if (client == NULL) {
/*
* Have to make the new client.
*/
client = (TkTextEmbWindowClient *)
ckalloc(sizeof(TkTextEmbWindowClient));
client->next = ewPtr->body.ew.clients;
client->textPtr = textPtr;
client->tkwin = NULL;
client->chunkCount = 0;
client->displayed = 0;
client->parent = ewPtr;
ewPtr->body.ew.clients = client;
}
client->tkwin = ewPtr->body.ew.tkwin;
/*
* Take over geometry management for the window, plus create an
* event handler to find out when it is deleted.
*/
Tk_ManageGeometry(ewPtr->body.ew.tkwin, &textGeomType,
(ClientData) client);
Tk_CreateEventHandler(ewPtr->body.ew.tkwin, StructureNotifyMask,
EmbWinStructureProc, (ClientData) client);
/*
* Special trick! Must enter into the hash table *after* calling
* Tk_ManageGeometry: if the window was already managed elsewhere
* in this text, the Tk_ManageGeometry call will cause the entry
* to be removed, which could potentially lose the new entry.
*/
hPtr = Tcl_CreateHashEntry(&textPtr->sharedTextPtr->windowTable,
Tk_PathName(ewPtr->body.ew.tkwin), &isNew);
Tcl_SetHashValue(hPtr, ewPtr);
}
}
return TCL_OK;
}
weighted_result *se_blobs (idx_list_entry *idx, char *searchstring)
{
char *word_ptr;
int i, exists;
int tot_docs;
int record_num;
int num_search_words = 0;
int max_hits = 0;
int num_found_terms = 0;
int search_stopword_count;
int termidlist[8000];
struct temp_results {
int weight;
int tot_freq;
} *storage ;
Tcl_HashTable *hash_tab, hash_tab_data;
Tcl_HashEntry *entry;
Tcl_HashSearch hash_search;
idx_result *index_result;
weighted_result *wt_res, *se_sortwtset();
char *breakletters;
char *keywordletters = " \t\n`~!@#$%^&*()_=|\\{[]};:'\",<>?/";
char *urlletters = " \t\n<>";
char *filenameletters = " \t\n<>";
char *lastptr;
if (searchstring == NULL) return (NULL);
search_stopword_count = 0;
if (idx->type & URL_KEY) breakletters = urlletters;
else if (idx->type & FILENAME_KEY) breakletters = filenameletters;
else breakletters = keywordletters;
/* Allocate the hash table for collecting weights for each document */
hash_tab = &hash_tab_data;
Tcl_InitHashTable(hash_tab,TCL_ONE_WORD_KEYS);
/* find first token */
word_ptr = strtok_r (searchstring, breakletters, &lastptr);
if (word_ptr == NULL) { /* no words in search string */
return (NULL);
}
else { /* process each word */
do {
num_search_words++;
index_result = se_getterm_idx(idx, word_ptr, 1 /* normalize*/,
&search_stopword_count);
if (index_result != NULL) {
if (num_found_terms < 7999)
termidlist[num_found_terms++] = index_result->termid;
for (i = 0; i < index_result->num_entries; i++) {
/* we will be anding these, so need to know the max size */
if (index_result->num_entries > max_hits)
max_hits = index_result->num_entries;
record_num = index_result->entries[i].record_no;
if (record_num > 0) { /* negative is a deleted entry */
entry = Tcl_FindHashEntry(hash_tab, (void *)record_num);
if (entry == NULL){ /* new record number */
storage = CALLOC(struct temp_results,1);
storage->weight = 1;
storage->tot_freq = index_result->entries[i].term_freq;
Tcl_SetHashValue(
Tcl_CreateHashEntry(
hash_tab,
(void *)record_num,
&exists),
(ClientData)storage);
}
else {
storage = (struct temp_results *) Tcl_GetHashValue(entry);
storage->weight++;
storage->tot_freq += index_result->entries[i].term_freq;
}
}
}
/* done with the index results from the getterm call */
if (index_result->term)
FREE(index_result->term);
FREE(index_result);
} /* if not null index_result... */
static Tk_ConfigSpec *
GetCachedSpecs(
Tcl_Interp *interp, /* Interpreter in which to store the cache. */
const Tk_ConfigSpec *staticSpecs)
/* Value to cache a copy of; it is also used
* as a key into the cache. */
{
Tk_ConfigSpec *cachedSpecs;
Tcl_HashTable *specCacheTablePtr;
Tcl_HashEntry *entryPtr;
int isNew;
/*
* Get (or allocate if it doesn't exist) the hash table that the writable
* copies of the widget specs are stored in. In effect, this is
* self-initializing code.
*/
specCacheTablePtr = (Tcl_HashTable *)
Tcl_GetAssocData(interp, "tkConfigSpec.threadTable", NULL);
if (specCacheTablePtr == NULL) {
specCacheTablePtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(specCacheTablePtr, TCL_ONE_WORD_KEYS);
Tcl_SetAssocData(interp, "tkConfigSpec.threadTable",
DeleteSpecCacheTable, (ClientData) specCacheTablePtr);
}
/*
* Look up or create the hash entry that the constant specs are mapped to,
* which will have the writable specs as its associated value.
*/
entryPtr = Tcl_CreateHashEntry(specCacheTablePtr, (char *) staticSpecs,
&isNew);
if (isNew) {
unsigned int entrySpace = sizeof(Tk_ConfigSpec);
const Tk_ConfigSpec *staticSpecPtr;
Tk_ConfigSpec *specPtr;
/*
* OK, no working copy in this interpreter so copy. Need to work out
* how much space to allocate first.
*/
for (staticSpecPtr=staticSpecs; staticSpecPtr->type!=TK_CONFIG_END;
staticSpecPtr++) {
entrySpace += sizeof(Tk_ConfigSpec);
}
/*
* Now allocate our working copy's space and copy over the contents
* from the master copy.
*/
cachedSpecs = (Tk_ConfigSpec *) ckalloc(entrySpace);
memcpy(cachedSpecs, staticSpecs, entrySpace);
Tcl_SetHashValue(entryPtr, (ClientData) cachedSpecs);
/*
* Finally, go through and replace database names, database classes
* and default values with Tk_Uids. This is the bit that has to be
* per-thread.
*/
for (specPtr=cachedSpecs; specPtr->type!=TK_CONFIG_END; specPtr++) {
if (specPtr->argvName != NULL) {
if (specPtr->dbName != NULL) {
specPtr->dbName = Tk_GetUid(specPtr->dbName);
}
if (specPtr->dbClass != NULL) {
specPtr->dbClass = Tk_GetUid(specPtr->dbClass);
}
if (specPtr->defValue != NULL) {
specPtr->defValue = Tk_GetUid(specPtr->defValue);
}
}
specPtr->specFlags &= ~TK_CONFIG_OPTION_SPECIFIED;
}
} else {
cachedSpecs = (Tk_ConfigSpec *) Tcl_GetHashValue(entryPtr);
}
return cachedSpecs;
}
static TkCursor *
TkcGetCursor(
Tcl_Interp *interp, /* Interpreter to use for error reporting. */
Tk_Window tkwin, /* Window in which cursor will be used. */
const char *string) /* Description of cursor. See manual entry for
* details on legal syntax. */
{
Tcl_HashEntry *nameHashPtr;
register TkCursor *cursorPtr;
TkCursor *existingCursorPtr = NULL;
int isNew;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (!dispPtr->cursorInit) {
CursorInit(dispPtr);
}
nameHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorNameTable,
string, &isNew);
if (!isNew) {
existingCursorPtr = Tcl_GetHashValue(nameHashPtr);
for (cursorPtr = existingCursorPtr; cursorPtr != NULL;
cursorPtr = cursorPtr->nextPtr) {
if (Tk_Display(tkwin) == cursorPtr->display) {
cursorPtr->resourceRefCount++;
return cursorPtr;
}
}
} else {
existingCursorPtr = NULL;
}
cursorPtr = TkGetCursorByName(interp, tkwin, string);
if (cursorPtr == NULL) {
if (isNew) {
Tcl_DeleteHashEntry(nameHashPtr);
}
return NULL;
}
/*
* Add information about this cursor to our database.
*/
cursorPtr->display = Tk_Display(tkwin);
cursorPtr->resourceRefCount = 1;
cursorPtr->objRefCount = 0;
cursorPtr->otherTable = &dispPtr->cursorNameTable;
cursorPtr->hashPtr = nameHashPtr;
cursorPtr->nextPtr = existingCursorPtr;
cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable,
(char *) cursorPtr->cursor, &isNew);
if (!isNew) {
Tcl_Panic("cursor already registered in Tk_GetCursor");
}
Tcl_SetHashValue(nameHashPtr, cursorPtr);
Tcl_SetHashValue(cursorPtr->idHashPtr, cursorPtr);
return cursorPtr;
}
TkTextTag *
TkTextCreateTag(
TkText *textPtr, /* Widget in which tag is being used. */
const char *tagName, /* Name of desired tag. */
int *newTag) /* If non-NULL, then return 1 if new, or 0 if
* already exists. */
{
register TkTextTag *tagPtr;
Tcl_HashEntry *hPtr = NULL;
int isNew;
const char *name;
if (!strcmp(tagName, "sel")) {
if (textPtr->selTagPtr != NULL) {
if (newTag != NULL) {
*newTag = 0;
}
return textPtr->selTagPtr;
}
if (newTag != NULL) {
*newTag = 1;
}
name = "sel";
} else {
hPtr = Tcl_CreateHashEntry(&textPtr->sharedTextPtr->tagTable,
tagName, &isNew);
if (newTag != NULL) {
*newTag = isNew;
}
if (!isNew) {
return Tcl_GetHashValue(hPtr);
}
name = Tcl_GetHashKey(&textPtr->sharedTextPtr->tagTable, hPtr);
}
/*
* No existing entry. Create a new one, initialize it, and add a pointer
* to it to the hash table entry.
*/
tagPtr = ckalloc(sizeof(TkTextTag));
tagPtr->name = name;
tagPtr->textPtr = NULL;
tagPtr->toggleCount = 0;
tagPtr->tagRootPtr = NULL;
tagPtr->priority = textPtr->sharedTextPtr->numTags;
tagPtr->border = NULL;
tagPtr->borderWidth = 0;
tagPtr->borderWidthPtr = NULL;
tagPtr->reliefString = NULL;
tagPtr->relief = TK_RELIEF_FLAT;
tagPtr->bgStipple = None;
tagPtr->fgColor = NULL;
tagPtr->tkfont = NULL;
tagPtr->fgStipple = None;
tagPtr->justifyString = NULL;
tagPtr->justify = TK_JUSTIFY_LEFT;
tagPtr->lMargin1String = NULL;
tagPtr->lMargin1 = 0;
tagPtr->lMargin2String = NULL;
tagPtr->lMargin2 = 0;
tagPtr->offsetString = NULL;
tagPtr->offset = 0;
tagPtr->overstrikeString = NULL;
tagPtr->overstrike = 0;
tagPtr->rMarginString = NULL;
tagPtr->rMargin = 0;
tagPtr->spacing1String = NULL;
tagPtr->spacing1 = 0;
tagPtr->spacing2String = NULL;
tagPtr->spacing2 = 0;
tagPtr->spacing3String = NULL;
tagPtr->spacing3 = 0;
tagPtr->tabStringPtr = NULL;
tagPtr->tabArrayPtr = NULL;
tagPtr->tabStyle = TK_TEXT_TABSTYLE_NONE;
tagPtr->underlineString = NULL;
tagPtr->underline = 0;
tagPtr->elideString = NULL;
tagPtr->elide = 0;
tagPtr->wrapMode = TEXT_WRAPMODE_NULL;
tagPtr->affectsDisplay = 0;
tagPtr->affectsDisplayGeometry = 0;
textPtr->sharedTextPtr->numTags++;
if (!strcmp(tagName, "sel")) {
tagPtr->textPtr = textPtr;
textPtr->refCount++;
} else {
CLANG_ASSERT(hPtr);
Tcl_SetHashValue(hPtr, tagPtr);
}
tagPtr->optionTable =
Tk_CreateOptionTable(textPtr->interp, tagOptionSpecs);
return tagPtr;
}
static TkBitmap *
GetBitmap(
Tcl_Interp *interp, /* Interpreter to use for error reporting,
* this may be NULL. */
Tk_Window tkwin, /* Window in which bitmap will be used. */
const char *string) /* Description of bitmap. See manual entry for
* details on legal syntax. */
{
Tcl_HashEntry *nameHashPtr, *predefHashPtr;
TkBitmap *bitmapPtr, *existingBitmapPtr;
TkPredefBitmap *predefPtr;
Pixmap bitmap;
int isNew, width, height, dummy2;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
if (!dispPtr->bitmapInit) {
BitmapInit(dispPtr);
}
nameHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapNameTable, string,
&isNew);
if (!isNew) {
existingBitmapPtr = Tcl_GetHashValue(nameHashPtr);
for (bitmapPtr = existingBitmapPtr; bitmapPtr != NULL;
bitmapPtr = bitmapPtr->nextPtr) {
if ((Tk_Display(tkwin) == bitmapPtr->display) &&
(Tk_ScreenNumber(tkwin) == bitmapPtr->screenNum)) {
bitmapPtr->resourceRefCount++;
return bitmapPtr;
}
}
} else {
existingBitmapPtr = NULL;
}
/*
* No suitable bitmap exists. Create a new bitmap from the information
* contained in the string. If the string starts with "@" then the rest of
* the string is a file name containing the bitmap. Otherwise the string
* must refer to a bitmap defined by a call to Tk_DefineBitmap.
*/
if (*string == '@') { /* INTL: ISO char */
Tcl_DString buffer;
int result;
if (Tcl_IsSafe(interp)) {
Tcl_AppendResult(interp, "can't specify bitmap with '@' in a",
" safe interpreter", NULL);
goto error;
}
/*
* Note that we need to cast away the const from the string because
* Tcl_TranslateFileName is non-const, even though it doesn't modify
* the string.
*/
string = Tcl_TranslateFileName(interp, (char *) string + 1, &buffer);
if (string == NULL) {
goto error;
}
result = TkReadBitmapFile(Tk_Display(tkwin),
RootWindowOfScreen(Tk_Screen(tkwin)), string,
(unsigned int *) &width, (unsigned int *) &height,
&bitmap, &dummy2, &dummy2);
if (result != BitmapSuccess) {
if (interp != NULL) {
Tcl_AppendResult(interp, "error reading bitmap file \"",
string, "\"", NULL);
}
Tcl_DStringFree(&buffer);
goto error;
}
Tcl_DStringFree(&buffer);
} else {
predefHashPtr = Tcl_FindHashEntry(&tsdPtr->predefBitmapTable, string);
if (predefHashPtr == NULL) {
/*
* The following platform specific call allows the user to define
* bitmaps that may only exist during run time. If it returns None
* nothing was found and we return the error.
*/
bitmap = TkpGetNativeAppBitmap(Tk_Display(tkwin), string,
&width, &height);
if (bitmap == None) {
if (interp != NULL) {
Tcl_AppendResult(interp, "bitmap \"", string,
"\" not defined", NULL);
}
goto error;
}
} else {
predefPtr = Tcl_GetHashValue(predefHashPtr);
width = predefPtr->width;
height = predefPtr->height;
if (predefPtr->native) {
bitmap = TkpCreateNativeBitmap(Tk_Display(tkwin),
predefPtr->source);
if (bitmap == None) {
Tcl_Panic("native bitmap creation failed");
}
} else {
bitmap = XCreateBitmapFromData(Tk_Display(tkwin),
RootWindowOfScreen(Tk_Screen(tkwin)),
predefPtr->source, (unsigned)width, (unsigned)height);
}
}
}
/*
* Add information about this bitmap to our database.
*/
bitmapPtr = (TkBitmap *) ckalloc(sizeof(TkBitmap));
bitmapPtr->bitmap = bitmap;
bitmapPtr->width = width;
bitmapPtr->height = height;
bitmapPtr->display = Tk_Display(tkwin);
bitmapPtr->screenNum = Tk_ScreenNumber(tkwin);
bitmapPtr->resourceRefCount = 1;
bitmapPtr->objRefCount = 0;
bitmapPtr->nameHashPtr = nameHashPtr;
bitmapPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->bitmapIdTable,
(char *) bitmap, &isNew);
if (!isNew) {
Tcl_Panic("bitmap already registered in Tk_GetBitmap");
}
bitmapPtr->nextPtr = existingBitmapPtr;
Tcl_SetHashValue(nameHashPtr, bitmapPtr);
Tcl_SetHashValue(bitmapPtr->idHashPtr, bitmapPtr);
return bitmapPtr;
error:
if (isNew) {
Tcl_DeleteHashEntry(nameHashPtr);
}
return NULL;
}
static AP_Result built_interp(AP_World *w, Tcl_Interp **interpretor, AP_Obj *interp_name)
{
Tcl_Interp *interp;
char name[128];
const char *namep;
Tcl_HashEntry *entry;
int is_new, pre_named;
AP_Type type;
int r;
type = AP_ObjType(w, *interp_name);
if (type != AP_VARIABLE && type != AP_ATOM) {
AP_SetStandardError(w, AP_TYPE_ERROR,
AP_NewSymbolFromStr(w, "atom_or_variable"), *interp_name);
goto error;
}
pre_named = (type == AP_ATOM);
#ifdef macintosh
// Tcl_MacSetEventProc(MyConvertEvent);
// SIOUXSetEventVector(MyHandleOneEvent);
#endif
interp = Tcl_CreateInterp();
if (!interp) {
AP_SetStandardError(w, AP_RESOURCE_ERROR, AP_NewSymbolFromStr(w, "tcl_memory"));
goto error;
}
/*
The following was causing a coredump on Mac OS X 10.5, and isn't necessary when
using the OS's Tcl/TK. Turned off for the moment.
TODO figure out why this is crashing on 10.5 - CEH 2009
*/
#if 0
{
Tcl_DString path;
const char *elements[3];
Tcl_DStringInit(&path);
elements[0] = library_dir;
#ifdef macintosh
elements[1] = "Tool Command Language";
#else
elements[1] = "lib";
#endif
elements[2] = "tcl" TCL_VERSION;
Tcl_JoinPath(3, (char **)elements, &path);
Tcl_SetVar(interp, (char *)"tcl_library", path.string, TCL_GLOBAL_ONLY);
Tcl_DStringSetLength(&path, 0);
Tcl_JoinPath(2, (char **)elements, &path);
Tcl_SetVar(interp, (char *)"tcl_pkgPath", path.string, TCL_GLOBAL_ONLY|TCL_LIST_ELEMENT);
Tcl_SetVar(interp, (char *)"autopath", (char *)"", TCL_GLOBAL_ONLY);
Tcl_DStringFree(&path);
}
#endif
r = Tcl_Init(interp);
if (r != TCL_OK) {
TclToPrologResult(w, NULL, interp, r);
goto error_delete;
}
#ifdef ITCL
r = Itcl_Init(interp);
if (r != TCL_OK) {
TclToPrologResult(w, NULL, interp, r);
goto error_delete;
}
Tcl_StaticPackage(interp, (char *)"Itcl", Itcl_Init, Itcl_SafeInit);
r = Tcl_Import(interp, Tcl_GetGlobalNamespace(interp),
(char *)"::itcl::*", /* allowOverwrite */ 1);
if (r != TCL_OK) {
TclToPrologResult(w, NULL, interp, r);
goto error_delete;
}
r = Tcl_Eval(interp,
(char *)"auto_mkindex_parser::slavehook { _%@namespace import -force ::itcl::* }");
if (r != TCL_OK) {
TclToPrologResult(w, NULL, interp, r);
goto error_delete;
}
#endif
if (pre_named) {
namep = AP_GetAtomStr(w, *interp_name);
} else {
interp_count++;
sprintf(name, "tcl_interp%d", interp_count);
/* handle error */
namep = name;
}
entry = Tcl_CreateHashEntry(&tcl_interp_name_table, namep, &is_new);
if (!entry) {
AP_SetStandardError(w, AP_RESOURCE_ERROR, AP_NewSymbolFromStr(w, "tcl_memory"));
goto error_delete;
}
if (!is_new) {
AP_SetStandardError(w, AP_PERMISSION_ERROR,
AP_NewSymbolFromStr(w, "create"),
AP_NewSymbolFromStr(w, "tcl_interpreter"), *interp_name);
goto error_delete;
}
Tcl_SetHashValue(entry, interp);
if (ALSProlog_Package_Init(interp, w) != TCL_OK) {
AP_SetError(w, AP_NewSymbolFromStr(w, "tcl_create_command_error"));
goto error_delete;
}
*interpretor = interp;
return (pre_named) ? AP_SUCCESS : AP_Unify(w, *interp_name, AP_NewUIAFromStr(w, namep));
error_delete:
Tcl_DeleteInterp(interp);
error:
return AP_EXCEPTION;
}
/* + style map $style ? -resource statemap ... ?
*
* Note that resource names are unconstrained; the Style
* doesn't know what resources individual elements may use.
*/
static int
StyleMapCmd(
ClientData clientData, /* Master StylePackageData pointer */
Tcl_Interp *interp, /* Current interpreter */
int objc, /* Number of arguments */
Tcl_Obj *const objv[]) /* Argument objects */
{
StylePackageData *pkgPtr = clientData;
Ttk_Theme theme = pkgPtr->currentTheme;
const char *styleName;
Style *stylePtr;
int i;
if (objc < 3) {
usage:
Tcl_WrongNumArgs(interp,2,objv,"style ?-option ?value...??");
return TCL_ERROR;
}
styleName = Tcl_GetString(objv[2]);
stylePtr = Ttk_GetStyle(theme, styleName);
/* NOTE: StateMaps are actually Tcl_Obj *s, so HashTableToDict works
* for settingsTable.
*/
if (objc == 3) { /* style map $styleName */
Tcl_SetObjResult(interp, HashTableToDict(&stylePtr->settingsTable));
return TCL_OK;
} else if (objc == 4) { /* style map $styleName -option */
const char *optionName = Tcl_GetString(objv[3]);
Tcl_HashEntry *entryPtr =
Tcl_FindHashEntry(&stylePtr->settingsTable, optionName);
if (entryPtr) {
Tcl_SetObjResult(interp, (Tcl_Obj*)Tcl_GetHashValue(entryPtr));
}
return TCL_OK;
} else if (objc % 2 != 1) {
goto usage;
}
for (i = 3; i < objc; i += 2) {
const char *optionName = Tcl_GetString(objv[i]);
Tcl_Obj *stateMap = objv[i+1];
Tcl_HashEntry *entryPtr;
int newEntry;
/* Make sure 'stateMap' is legal:
* (@@@ SHOULD: check for valid resource values as well,
* but we don't know what types they should be at this level.)
*/
if (!Ttk_GetStateMapFromObj(interp, stateMap))
return TCL_ERROR;
entryPtr = Tcl_CreateHashEntry(
&stylePtr->settingsTable,optionName,&newEntry);
Tcl_IncrRefCount(stateMap);
if (!newEntry) {
Tcl_DecrRefCount((Tcl_Obj*)Tcl_GetHashValue(entryPtr));
}
Tcl_SetHashValue(entryPtr, stateMap);
}
ThemeChanged(pkgPtr);
return TCL_OK;
}
int
TnmSetIPAddress(Tcl_Interp *interp, const char *host, struct sockaddr_in *addr)
{
static Tcl_HashTable *hostTable = NULL;
Tcl_HashEntry *hostEntry;
struct hostent *hp = NULL;
int code, type;
#define TNM_IP_HOST_NAME 1
#define TNM_IP_HOST_ADDRESS 2
Tcl_MutexLock(&utilMutex);
if (hostTable == NULL) {
hostTable = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(hostTable, TCL_STRING_KEYS);
}
addr->sin_family = AF_INET;
/*
* First check whether we got a host name, an IP address or
* something else completely different.
*/
type = TNM_IP_HOST_NAME;
code = TnmValidateIpHostName(NULL, host);
if (code != TCL_OK) {
code = TnmValidateIpAddress(NULL, host);
if (code != TCL_OK) {
if (interp) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "illegal IP address or name \"",
host, "\"", (char *) NULL);
}
Tcl_MutexUnlock(&utilMutex);
return TCL_ERROR;
}
type = TNM_IP_HOST_ADDRESS;
}
/*
* Convert the IP address into the internal format. Note that
* inet_addr can't handle the valid address 255.255.255.255.
*/
if (type == TNM_IP_HOST_ADDRESS) {
int hostaddr = inet_addr(host);
if (hostaddr == -1 && strcmp(host, "255.255.255.255") != 0) {
if (interp) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "invalid IP address \"",
host, "\"", (char *) NULL);
}
Tcl_MutexUnlock(&utilMutex);
return TCL_ERROR;
}
memcpy((char *) &addr->sin_addr, (char *) &hostaddr, 4);
Tcl_MutexUnlock(&utilMutex);
return TCL_OK;
}
/*
* Try to convert the name into an IP address. First check
* whether this name is already known in our address cache.
* If not, try to resolve the name and add an entry to the
* cache if successful. Otherwise return an error.
*/
if (type == TNM_IP_HOST_NAME) {
struct sockaddr_in *caddr;
int isnew;
hostEntry = Tcl_FindHashEntry(hostTable, host);
if (hostEntry) {
caddr = (struct sockaddr_in *) Tcl_GetHashValue(hostEntry);
addr->sin_addr.s_addr = caddr->sin_addr.s_addr;
Tcl_MutexUnlock(&utilMutex);
return TCL_OK;
}
hp = gethostbyname(host);
if (! hp) {
if (interp) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "unknown IP host name \"",
host, "\"", (char *) NULL);
}
Tcl_MutexUnlock(&utilMutex);
return TCL_ERROR;
}
memcpy((char *) &addr->sin_addr,
(char *) hp->h_addr, (size_t) hp->h_length);
caddr = (struct sockaddr_in *) ckalloc(sizeof(struct sockaddr_in));
*caddr = *addr;
hostEntry = Tcl_CreateHashEntry(hostTable, host, &isnew);
Tcl_SetHashValue(hostEntry, (ClientData) caddr);
Tcl_MutexUnlock(&utilMutex);
return TCL_OK;
}
/*
* We should not reach here.
*/
Tcl_MutexUnlock(&utilMutex);
return TCL_ERROR;
}
* Converts a `sqlite3_stmt` into a `reg_portgroup`. The first column of the stmt's
* row must be the id of a portgroup; the second either `SQLITE_NULL` or the
* address of the entry in memory.
*
* @param [in] userdata sqlite3 database
* @param [out] portgroup portgroup described by `stmt`
* @param [in] stmt `sqlite3_stmt` with appropriate columns
* @param [out] errPtr unused
* @return true if success; false if failure
*/
static int reg_stmt_to_portgroup(void* userdata, void** portgroup, void* stmt,
void* calldata UNUSED, reg_error* errPtr UNUSED) {
int is_new;
reg_registry* reg = (reg_registry*)userdata;
sqlite_int64 id = sqlite3_column_int64(stmt, 0);
Tcl_HashEntry* hash = Tcl_CreateHashEntry(®->open_portgroups,
(const char*)&id, &is_new);
if (is_new) {
reg_portgroup* p = malloc(sizeof(reg_portgroup));
if (!p) {
return 0;
}
p->reg = reg;
p->id = id;
p->proc = NULL;
*portgroup = p;
Tcl_SetHashValue(hash, p);
} else {
*portgroup = Tcl_GetHashValue(hash);
}
return 1;
}
static void
AdvanceJumps(
CompileEnv *envPtr)
{
unsigned char *currentInstPtr;
Tcl_HashTable jumps;
for (currentInstPtr = envPtr->codeStart ;
currentInstPtr < envPtr->codeNext-1 ;
currentInstPtr += AddrLength(currentInstPtr)) {
int offset, delta, isNew;
switch (*currentInstPtr) {
case INST_JUMP1:
case INST_JUMP_TRUE1:
case INST_JUMP_FALSE1:
offset = TclGetInt1AtPtr(currentInstPtr + 1);
Tcl_InitHashTable(&jumps, TCL_ONE_WORD_KEYS);
for (delta=0 ; offset+delta != 0 ;) {
if (offset + delta < -128 || offset + delta > 127) {
break;
}
Tcl_CreateHashEntry(&jumps, INT2PTR(offset), &isNew);
if (!isNew) {
offset = TclGetInt1AtPtr(currentInstPtr + 1);
break;
}
offset += delta;
switch (*(currentInstPtr + offset)) {
case INST_NOP:
delta = InstLength(INST_NOP);
continue;
case INST_JUMP1:
delta = TclGetInt1AtPtr(currentInstPtr + offset + 1);
continue;
case INST_JUMP4:
delta = TclGetInt4AtPtr(currentInstPtr + offset + 1);
continue;
}
break;
}
Tcl_DeleteHashTable(&jumps);
TclStoreInt1AtPtr(offset, currentInstPtr + 1);
continue;
case INST_JUMP4:
case INST_JUMP_TRUE4:
case INST_JUMP_FALSE4:
Tcl_InitHashTable(&jumps, TCL_ONE_WORD_KEYS);
Tcl_CreateHashEntry(&jumps, INT2PTR(0), &isNew);
for (offset = TclGetInt4AtPtr(currentInstPtr + 1); offset!=0 ;) {
Tcl_CreateHashEntry(&jumps, INT2PTR(offset), &isNew);
if (!isNew) {
offset = TclGetInt4AtPtr(currentInstPtr + 1);
break;
}
switch (*(currentInstPtr + offset)) {
case INST_NOP:
offset += InstLength(INST_NOP);
continue;
case INST_JUMP1:
offset += TclGetInt1AtPtr(currentInstPtr + offset + 1);
continue;
case INST_JUMP4:
offset += TclGetInt4AtPtr(currentInstPtr + offset + 1);
continue;
}
break;
}
Tcl_DeleteHashTable(&jumps);
TclStoreInt4AtPtr(offset, currentInstPtr + 1);
continue;
}
}
}
/**
* R T _ G E T T R E E _ R E G I O N _ E N D
*
* This routine will be called by db_walk_tree() once all the solids
* in this region have been visited.
*
* This routine must be prepared to run in parallel. As a result,
* note that the details of the solids pointed to by the soltab
* pointers in the tree may not be filled in when this routine is
* called (due to the way multiple instances of solids are handled).
* Therefore, everything which referred to the tree has been moved out
* into the serial section. (rt_tree_region_assign, rt_bound_tree)
*/
HIDDEN union tree *rt_gettree_region_end(register struct db_tree_state *tsp, struct db_full_path *pathp, union tree *curtree, genptr_t client_data)
{
struct region *rp;
struct directory *dp;
int shader_len=0;
struct rt_i *rtip;
int i;
Tcl_HashTable *tbl = (Tcl_HashTable *)client_data;
Tcl_HashEntry *entry;
matp_t inv_mat;
RT_CK_DBI(tsp->ts_dbip);
RT_CK_FULL_PATH(pathp);
RT_CK_TREE(curtree);
rtip = tsp->ts_rtip;
RT_CK_RTI(rtip);
RT_CK_RESOURCE(tsp->ts_resp);
if ( curtree->tr_op == OP_NOP ) {
/* Ignore empty regions */
return curtree;
}
BU_GETSTRUCT( rp, region );
rp->l.magic = RT_REGION_MAGIC;
rp->reg_regionid = tsp->ts_regionid;
rp->reg_is_fastgen = tsp->ts_is_fastgen;
rp->reg_aircode = tsp->ts_aircode;
rp->reg_gmater = tsp->ts_gmater;
rp->reg_los = tsp->ts_los;
if ( tsp->ts_attrs.count && tsp->ts_attrs.avp ) {
rp->attr_values = (struct bu_mro **)bu_calloc( tsp->ts_attrs.count+1,
sizeof( struct bu_mro *), "regp->attr_values" );
for ( i=0; i<tsp->ts_attrs.count; i++ ) {
rp->attr_values[i] = bu_malloc( sizeof( struct bu_mro ),
"rp->attr_values[i]" );
bu_mro_init_with_string( rp->attr_values[i], tsp->ts_attrs.avp[i].value );
}
} else {
rp->attr_values = (struct bu_mro **)NULL;
}
rp->reg_mater = tsp->ts_mater; /* struct copy */
if ( tsp->ts_mater.ma_shader )
shader_len = strlen( tsp->ts_mater.ma_shader );
if ( shader_len )
{
rp->reg_mater.ma_shader = bu_strdup( tsp->ts_mater.ma_shader );
}
else
rp->reg_mater.ma_shader = (char *)NULL;
rp->reg_name = db_path_to_string( pathp );
dp = (struct directory *)DB_FULL_PATH_CUR_DIR(pathp);
if (RT_G_DEBUG&DEBUG_TREEWALK) {
bu_log("rt_gettree_region_end() %s\n", rp->reg_name );
rt_pr_tree( curtree, 0 );
}
rp->reg_treetop = curtree;
rp->reg_all_unions = db_is_tree_all_unions( curtree );
/* Determine material properties */
rp->reg_mfuncs = (char *)0;
rp->reg_udata = (char *)0;
if ( rp->reg_mater.ma_color_valid == 0 )
rt_region_color_map(rp);
/* enter critical section */
bu_semaphore_acquire( RT_SEM_RESULTS );
rp->reg_instnum = dp->d_uses++;
/*
* Add the region to the linked list of regions.
* Positions in the region bit vector are established at this time.
*/
BU_LIST_INSERT( &(rtip->HeadRegion), &rp->l );
/* Assign bit vector pos. */
rp->reg_bit = rtip->nregions++;
/* leave critical section */
bu_semaphore_release( RT_SEM_RESULTS );
if ( tbl && bu_avs_get( &tsp->ts_attrs, "ORCA_Comp" ) ) {
int newentry;
long int reg_bit = rp->reg_bit;
inv_mat = (matp_t)bu_calloc( 16, sizeof( fastf_t ), "inv_mat" );
if ( tsp->ts_mat )
bn_mat_inv( inv_mat, tsp->ts_mat );
else
MAT_IDN( inv_mat );
/* enter critical section */
bu_semaphore_acquire( RT_SEM_RESULTS );
entry = Tcl_CreateHashEntry(tbl, (char *)reg_bit, &newentry);
Tcl_SetHashValue( entry, (ClientData)inv_mat );
/* leave critical section */
bu_semaphore_release( RT_SEM_RESULTS );
}
if ( RT_G_DEBUG & DEBUG_REGIONS ) {
bu_log("Add Region %s instnum %d\n",
rp->reg_name, rp->reg_instnum);
}
/* Indicate that we have swiped 'curtree' */
return(TREE_NULL);
}
* Converts a `sqlite3_stmt` into a `reg_entry`. The first column of the stmt's
* row must be the id of an entry; the second either `SQLITE_NULL` or the
* address of the entry in memory.
*
* @param [in] userdata sqlite3 database
* @param [out] entry entry described by `stmt`
* @param [in] stmt `sqlite3_stmt` with appropriate columns
* @param [out] errPtr unused
* @return true if success; false if failure
*/
static int reg_stmt_to_entry(void* userdata, void** entry, void* stmt,
void* calldata UNUSED, reg_error* errPtr UNUSED) {
int is_new;
reg_registry* reg = (reg_registry*)userdata;
sqlite_int64 id = sqlite3_column_int64(stmt, 0);
Tcl_HashEntry* hash = Tcl_CreateHashEntry(®->open_entries,
(const char*)&id, &is_new);
if (is_new) {
reg_entry* e = malloc(sizeof(reg_entry));
if (!e) {
return 0;
}
e->reg = reg;
e->id = id;
e->proc = NULL;
*entry = e;
Tcl_SetHashValue(hash, e);
} else {
*entry = Tcl_GetHashValue(hash);
}
return 1;
}
Tk_3DBorder
Tk_Get3DBorder(
Tcl_Interp *interp, /* Place to store an error message. */
Tk_Window tkwin, /* Token for window in which border will be
* drawn. */
Tk_Uid colorName) /* String giving name of color for window
* background. */
{
Tcl_HashEntry *hashPtr;
TkBorder *borderPtr, *existingBorderPtr;
int isNew;
XGCValues gcValues;
XColor *bgColorPtr;
TkDisplay *dispPtr;
dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (!dispPtr->borderInit) {
BorderInit(dispPtr);
}
hashPtr = Tcl_CreateHashEntry(&dispPtr->borderTable, colorName, &isNew);
if (!isNew) {
existingBorderPtr = Tcl_GetHashValue(hashPtr);
for (borderPtr = existingBorderPtr; borderPtr != NULL;
borderPtr = borderPtr->nextPtr) {
if ((Tk_Screen(tkwin) == borderPtr->screen)
&& (Tk_Colormap(tkwin) == borderPtr->colormap)) {
borderPtr->resourceRefCount++;
return (Tk_3DBorder) borderPtr;
}
}
} else {
existingBorderPtr = NULL;
}
/*
* No satisfactory border exists yet. Initialize a new one.
*/
bgColorPtr = Tk_GetColor(interp, tkwin, colorName);
if (bgColorPtr == NULL) {
if (isNew) {
Tcl_DeleteHashEntry(hashPtr);
}
return NULL;
}
borderPtr = TkpGetBorder();
borderPtr->screen = Tk_Screen(tkwin);
borderPtr->visual = Tk_Visual(tkwin);
borderPtr->depth = Tk_Depth(tkwin);
borderPtr->colormap = Tk_Colormap(tkwin);
borderPtr->resourceRefCount = 1;
borderPtr->objRefCount = 0;
borderPtr->bgColorPtr = bgColorPtr;
borderPtr->darkColorPtr = NULL;
borderPtr->lightColorPtr = NULL;
borderPtr->shadow = None;
borderPtr->bgGC = None;
borderPtr->darkGC = None;
borderPtr->lightGC = None;
borderPtr->hashPtr = hashPtr;
borderPtr->nextPtr = existingBorderPtr;
Tcl_SetHashValue(hashPtr, borderPtr);
/*
* Create the information for displaying the background color, but delay
* the allocation of shadows until they are actually needed for drawing.
*/
gcValues.foreground = borderPtr->bgColorPtr->pixel;
borderPtr->bgGC = Tk_GetGC(tkwin, GCForeground, &gcValues);
return (Tk_3DBorder) borderPtr;
}
static int
CreateElement(
const char *name, /* Name of the element. */
int create) /* Boolean, whether the element is being
* created explicitly (being registered) or
* implicitly (by a derived element). */
{
ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
Tcl_HashEntry *entryPtr, *engineEntryPtr;
Tcl_HashSearch search;
int newEntry, elementId, genericId = -1;
char *dot;
StyleEngine *enginePtr;
/*
* Find or create the element.
*/
entryPtr = Tcl_CreateHashEntry(&tsdPtr->elementTable, name, &newEntry);
if (!newEntry) {
elementId = PTR2INT(Tcl_GetHashValue(entryPtr));
if (create) {
tsdPtr->elements[elementId].created = 1;
}
return elementId;
}
/*
* The element didn't exist. If it's a derived element, find or create its
* generic element ID.
*/
dot = strchr(name, '.');
if (dot) {
genericId = CreateElement(dot+1, 0);
}
elementId = tsdPtr->nbElements++;
Tcl_SetHashValue(entryPtr, (ClientData) INT2PTR(elementId));
/*
* Reallocate element table.
*/
tsdPtr->elements = (Element *) ckrealloc((char *) tsdPtr->elements,
sizeof(Element) * tsdPtr->nbElements);
InitElement(tsdPtr->elements+elementId,
Tcl_GetHashKey(&tsdPtr->elementTable, entryPtr), elementId,
genericId, create);
/*
* Reallocate style engines' element table.
*/
engineEntryPtr = Tcl_FirstHashEntry(&tsdPtr->engineTable, &search);
while (engineEntryPtr != NULL) {
enginePtr = (StyleEngine *) Tcl_GetHashValue(engineEntryPtr);
enginePtr->elements = (StyledElement *) ckrealloc(
(char *) enginePtr->elements,
sizeof(StyledElement) * tsdPtr->nbElements);
InitStyledElement(enginePtr->elements+elementId);
engineEntryPtr = Tcl_NextHashEntry(&search);
}
return elementId;
}
static Tcl_HashTable *
ThreadStorageGetHashTable(
Tcl_ThreadId id) /* Id of thread to get hash table for */
{
int index = PTR2UINT(id) % STORAGE_CACHE_SLOTS;
Tcl_HashEntry *hPtr;
int isNew;
Tcl_HashTable *hashTablePtr;
/*
* It's important that we pick up the hash table pointer BEFORE comparing
* thread Id in case another thread is in the critical region changing
* things out from under you.
*
* Thread safety: threadStorageCache is accessed w/o locks in order to
* avoid serialization of all threads at this hot-spot. It is safe to
* do this here because (threadStorageCache[index].id != id) test below
* should be atomic on all (currently) supported platforms and there
* are no devastatig side effects of the test.
*
* Note Valgrind users: this place will show up as a race-condition in
* helgrind-tool output. To silence this warnings, define VALGRIND
* symbol at compilation time.
*/
#if !defined(VALGRIND)
hashTablePtr = threadStorageCache[index].hashTablePtr;
if (threadStorageCache[index].id != id) {
Tcl_MutexLock(&threadStorageLock);
#else
Tcl_MutexLock(&threadStorageLock);
hashTablePtr = threadStorageCache[index].hashTablePtr;
if (threadStorageCache[index].id != id) {
#endif
/*
* It's not in the cache, so we look it up...
*/
hPtr = Tcl_FindHashEntry(&threadStorageHashTable, (char *) id);
if (hPtr != NULL) {
/*
* We found it, extract the hash table pointer.
*/
hashTablePtr = Tcl_GetHashValue(hPtr);
} else {
/*
* The thread specific hash table is not found.
*/
hashTablePtr = NULL;
}
if (hashTablePtr == NULL) {
hashTablePtr = (Tcl_HashTable *)
TclpSysAlloc(sizeof(Tcl_HashTable), 0);
if (hashTablePtr == NULL) {
Tcl_Panic("could not allocate thread specific hash table, "
"TclpSysAlloc failed from ThreadStorageGetHashTable!");
}
Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS,
&tclThreadStorageHashKeyType);
/*
* Add new thread storage hash table to the master hash table.
*/
hPtr = Tcl_CreateHashEntry(&threadStorageHashTable, (char *) id,
&isNew);
if (hPtr == NULL) {
Tcl_Panic("Tcl_CreateHashEntry failed from "
"ThreadStorageGetHashTable!");
}
Tcl_SetHashValue(hPtr, hashTablePtr);
}
/*
* Now, we put it in the cache since it is highly likely it will be
* needed again shortly.
*/
threadStorageCache[index].id = id;
threadStorageCache[index].hashTablePtr = hashTablePtr;
#if !defined(VALGRIND)
Tcl_MutexUnlock(&threadStorageLock);
}
#else
}
Tcl_MutexUnlock(&threadStorageLock);
#endif
return hashTablePtr;
}
Tk_Cursor
Tk_GetCursorFromData(
Tcl_Interp *interp, /* Interpreter to use for error reporting. */
Tk_Window tkwin, /* Window in which cursor will be used. */
const char *source, /* Bitmap data for cursor shape. */
const char *mask, /* Bitmap data for cursor mask. */
int width, int height, /* Dimensions of cursor. */
int xHot, int yHot, /* Location of hot-spot in cursor. */
Tk_Uid fg, /* Foreground color for cursor. */
Tk_Uid bg) /* Background color for cursor. */
{
DataKey dataKey;
Tcl_HashEntry *dataHashPtr;
register TkCursor *cursorPtr;
int isNew;
XColor fgColor, bgColor;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (!dispPtr->cursorInit) {
CursorInit(dispPtr);
}
dataKey.source = source;
dataKey.mask = mask;
dataKey.width = width;
dataKey.height = height;
dataKey.xHot = xHot;
dataKey.yHot = yHot;
dataKey.fg = fg;
dataKey.bg = bg;
dataKey.display = Tk_Display(tkwin);
dataHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorDataTable,
(char *) &dataKey, &isNew);
if (!isNew) {
cursorPtr = Tcl_GetHashValue(dataHashPtr);
cursorPtr->resourceRefCount++;
return cursorPtr->cursor;
}
/*
* No suitable cursor exists yet. Make one using the data available and
* add it to the database.
*/
if (XParseColor(dataKey.display, Tk_Colormap(tkwin), fg, &fgColor) == 0) {
Tcl_AppendResult(interp, "invalid color name \"", fg, "\"", NULL);
goto error;
}
if (XParseColor(dataKey.display, Tk_Colormap(tkwin), bg, &bgColor) == 0) {
Tcl_AppendResult(interp, "invalid color name \"", bg, "\"", NULL);
goto error;
}
cursorPtr = TkCreateCursorFromData(tkwin, source, mask, width, height,
xHot, yHot, fgColor, bgColor);
if (cursorPtr == NULL) {
goto error;
}
cursorPtr->resourceRefCount = 1;
cursorPtr->otherTable = &dispPtr->cursorDataTable;
cursorPtr->hashPtr = dataHashPtr;
cursorPtr->objRefCount = 0;
cursorPtr->idHashPtr = Tcl_CreateHashEntry(&dispPtr->cursorIdTable,
(char *) cursorPtr->cursor, &isNew);
cursorPtr->nextPtr = NULL;
if (!isNew) {
Tcl_Panic("cursor already registered in Tk_GetCursorFromData");
}
Tcl_SetHashValue(dataHashPtr, cursorPtr);
Tcl_SetHashValue(cursorPtr->idHashPtr, cursorPtr);
return cursorPtr->cursor;
error:
Tcl_DeleteHashEntry(dataHashPtr);
return None;
}
/**
* find a new unique name given a list of previously used names, and
* the type of naming mode that described what type of affix to use.
*/
static char *
get_new_name(const char *name,
struct db_i *dbip,
Tcl_HashTable *name_tbl,
Tcl_HashTable *used_names_tbl,
struct ged_concat_data *cc_data)
{
struct bu_vls new_name = BU_VLS_INIT_ZERO;
Tcl_HashEntry *ptr = NULL;
char *aname = NULL;
char *ret_name = NULL;
int int_new=0;
long num=0;
RT_CK_DBI(dbip);
BU_ASSERT(name_tbl);
BU_ASSERT(used_names_tbl);
BU_ASSERT(cc_data);
if (!name) {
bu_log("WARNING: encountered NULL name, renaming to \"UNKNOWN\"\n");
name = "UNKNOWN";
}
ptr = Tcl_CreateHashEntry(name_tbl, name, &int_new);
if (!int_new) {
return (char *)Tcl_GetHashValue(ptr);
}
do {
/* iterate until we find an object name that is not in
* use, trying to accommodate the user's requested affix
* naming mode.
*/
bu_vls_trunc(&new_name, 0);
if (cc_data->copy_mode & NO_AFFIX) {
if (num > 0 && cc_data->copy_mode & CUSTOM_PREFIX) {
/* auto-increment prefix */
bu_vls_printf(&new_name, "%ld_", num);
}
bu_vls_strcat(&new_name, name);
if (num > 0 && cc_data->copy_mode & CUSTOM_SUFFIX) {
/* auto-increment suffix */
bu_vls_printf(&new_name, "_%ld", num);
}
} else if (cc_data->copy_mode & CUSTOM_SUFFIX) {
/* use custom suffix */
bu_vls_strcpy(&new_name, name);
if (num > 0) {
bu_vls_printf(&new_name, "_%ld_", num);
}
bu_vls_vlscat(&new_name, &cc_data->affix);
} else if (cc_data->copy_mode & CUSTOM_PREFIX) {
/* use custom prefix */
bu_vls_vlscat(&new_name, &cc_data->affix);
if (num > 0) {
bu_vls_printf(&new_name, "_%ld_", num);
}
bu_vls_strcat(&new_name, name);
} else if (cc_data->copy_mode & AUTO_SUFFIX) {
/* use auto-incrementing suffix */
bu_vls_strcat(&new_name, name);
bu_vls_printf(&new_name, "_%ld", num);
} else if (cc_data->copy_mode & AUTO_PREFIX) {
/* use auto-incrementing prefix */
bu_vls_printf(&new_name, "%ld_", num);
bu_vls_strcat(&new_name, name);
} else {
/* no custom suffix/prefix specified, use prefix */
if (num > 0) {
bu_vls_printf(&new_name, "_%ld", num);
}
bu_vls_strcpy(&new_name, name);
}
/* make sure it fits for v4 */
if (db_version(cc_data->old_dbip) < 5) {
if (bu_vls_strlen(&new_name) > _GED_V4_MAXNAME) {
bu_log("ERROR: generated new name [%s] is too long (%zu > %d)\n", bu_vls_addr(&new_name), bu_vls_strlen(&new_name), _GED_V4_MAXNAME);
}
return NULL;
}
aname = bu_vls_addr(&new_name);
num++;
} while (db_lookup(dbip, aname, LOOKUP_QUIET) != RT_DIR_NULL ||
Tcl_FindHashEntry(used_names_tbl, aname) != NULL);
/* if they didn't get what they asked for, warn them */
if (num > 1) {
if (cc_data->copy_mode & NO_AFFIX) {
bu_log("WARNING: unable to import [%s] without an affix, imported as [%s]\n", name, bu_vls_addr(&new_name));
} else if (cc_data->copy_mode & CUSTOM_SUFFIX) {
bu_log("WARNING: unable to import [%s] as [%s%s], imported as [%s]\n", name, name, bu_vls_addr(&cc_data->affix), bu_vls_addr(&new_name));
} else if (cc_data->copy_mode & CUSTOM_PREFIX) {
bu_log("WARNING: unable to import [%s] as [%s%s], imported as [%s]\n", name, bu_vls_addr(&cc_data->affix), name, bu_vls_addr(&new_name));
}
}
/* we should now have a unique name. store it in the hash */
ret_name = bu_vls_strgrab(&new_name);
Tcl_SetHashValue(ptr, (ClientData)ret_name);
(void)Tcl_CreateHashEntry(used_names_tbl, ret_name, &int_new);
bu_vls_free(&new_name);
return ret_name;
}
static int
ts_lua_shared_dict_set(lua_State *L)
{
int n;
int64_t nkey, nval;
const char *key, *val;
size_t key_len, val_len;
int ktype, vtype;
void *hKey;
int isNew;
Tcl_HashEntry *hPtr;
ts_lua_shared_dict_item *item, *old_item;
ts_lua_shared_dict *dct;
n = lua_gettop(L);
if (n != 3) {
return luaL_error(L, "invalid param for xx:set(key, value)");
}
dct = (ts_lua_shared_dict*)lua_touserdata(L, 1);
if (dct == NULL) {
return luaL_error(L, "userdata is required for xx:set()");
}
if (dct->quota && dct->used > dct->quota) {
lua_pushnumber(L, 0);
lua_pushlstring(L, "no memory", sizeof("no memory") - 1);
return 2;
}
ktype = lua_type(L, 2);
vtype = lua_type(L, 3);
switch (ktype) {
case LUA_TNUMBER:
if (dct->flags & TS_LUA_SHDICT_FLAG_INTKEY) {
nkey = luaL_checknumber(L, 2);
key_len = sizeof(long);
hKey = (void*)nkey;
} else {
key = luaL_checklstring(L, 2, &key_len);
hKey = (void*)key;
}
break;
case LUA_TSTRING:
if (dct->flags & TS_LUA_SHDICT_FLAG_INTKEY) {
return luaL_error(L, "key for xx:set() should be number");
}
key = luaL_checklstring(L, 2, &key_len);
hKey = (void*)key;
break;
default:
return luaL_error(L, "invalid key type: %s for xx:set()", lua_typename(L, ktype));
}
if (key_len > TS_LUA_SHDICT_MAX_KEY_LENGTH)
return luaL_error(L, "key length is too long: %d", (int)key_len);
val_len = 0;
switch (vtype) {
case LUA_TNUMBER:
nval = lua_tonumber(L, 3);
break;
case LUA_TSTRING:
val = lua_tolstring(L, 3, &val_len);
break;
case LUA_TBOOLEAN:
nval = lua_toboolean(L, 3);
break;
case LUA_TNIL:
nval = 0;
break;
default:
return luaL_error(L, "invalid val type: %s for xx:set()", lua_typename(L, vtype));
}
if (val_len > TS_LUA_SHDICT_MAX_VAL_LENGTH)
return luaL_error(L, "val length is too long: %d", (int)val_len);
item = (ts_lua_shared_dict_item*)TSmalloc(sizeof(ts_lua_shared_dict_item) + val_len);
item->vtype = vtype;
item->ksize = key_len;
item->vsize = val_len;
if (vtype == LUA_TSTRING) {
item->v.s = (char*)(((char*)item) + sizeof(ts_lua_shared_dict_item));
memcpy(item->v.s, val, val_len);
} else {
item->v.n = nval;
}
isNew = 0;
old_item = NULL;
TSMutexLock(dct->map.mutexp);
hPtr = Tcl_CreateHashEntry(&(dct->map.t), hKey, &isNew);
if (isNew) {
Tcl_SetHashValue(hPtr, item);
dct->used += sizeof(ts_lua_shared_dict_item) + item->ksize + item->vsize;
} else {
old_item = (ts_lua_shared_dict_item*)Tcl_GetHashValue(hPtr);
Tcl_SetHashValue(hPtr, item);
dct->used += (int)(item->ksize + item->vsize) - (int)(old_item->ksize + old_item->vsize);
}
TSMutexUnlock(dct->map.mutexp);
if (!isNew && old_item) {
TSfree(old_item);
}
lua_pushnumber(L, 1);
lua_pushnil(L);
return 2;
}
static void
MakeTransparentWindowExist(
Tk_Window tkwin, /* Token for window. */
Window parent) /* Parent window. */
{
TkWindow *winPtr = (TkWindow *) tkwin;
Tcl_HashEntry *hPtr;
int notUsed;
TkDisplay *dispPtr;
if (winPtr->window != None) {
return; /* Window already exists. */
}
/*
* Create a transparent window and put it on top.
*/
TkpMakeTransparentWindowExist(tkwin, parent);
dispPtr = winPtr->dispPtr;
hPtr = Tcl_CreateHashEntry(&dispPtr->winTable, (char *) winPtr->window,
¬Used);
Tcl_SetHashValue(hPtr, winPtr);
winPtr->dirtyAtts = 0;
winPtr->dirtyChanges = 0;
if (!(winPtr->flags & TK_TOP_HIERARCHY)) {
TkWindow *winPtr2;
/*
* If any siblings higher up in the stacking order have already been
* created then move this window to its rightful position in the
* stacking order.
*
* NOTE: this code ignores any changes anyone might have made to the
* sibling and stack_mode field of the window's attributes, so it
* really isn't safe for these to be manipulated except by calling
* Tk_RestackWindow.
*/
for (winPtr2 = winPtr->nextPtr; winPtr2 != NULL;
winPtr2 = winPtr2->nextPtr) {
if ((winPtr2->window != None) &&
!(winPtr2->flags & (TK_TOP_HIERARCHY|TK_REPARENTED))) {
XWindowChanges changes;
changes.sibling = winPtr2->window;
changes.stack_mode = Below;
XConfigureWindow(winPtr->display, winPtr->window,
CWSibling | CWStackMode, &changes);
break;
}
}
}
/*
* Issue a ConfigureNotify event if there were deferred configuration
* changes (but skip it if the window is being deleted; the
* ConfigureNotify event could cause problems if we're being called from
* Tk_DestroyWindow under some conditions).
*/
if ((winPtr->flags & TK_NEED_CONFIG_NOTIFY)
&& !(winPtr->flags & TK_ALREADY_DEAD)) {
winPtr->flags &= ~TK_NEED_CONFIG_NOTIFY;
DoConfigureNotify((Tk_FakeWin *) tkwin);
}
}
int
Tk_ImageObjCmd(
ClientData clientData, /* Main window associated with interpreter. */
Tcl_Interp *interp, /* Current interpreter. */
int objc, /* Number of arguments. */
Tcl_Obj *const objv[]) /* Argument strings. */
{
static const char *const imageOptions[] = {
"create", "delete", "height", "inuse", "names", "type", "types",
"width", NULL
};
enum options {
IMAGE_CREATE, IMAGE_DELETE, IMAGE_HEIGHT, IMAGE_INUSE, IMAGE_NAMES,
IMAGE_TYPE, IMAGE_TYPES, IMAGE_WIDTH
};
TkWindow *winPtr = clientData;
int i, isNew, firstOption, index;
Tk_ImageType *typePtr;
ImageMaster *masterPtr;
Image *imagePtr;
Tcl_HashEntry *hPtr;
Tcl_HashSearch search;
char idString[16 + TCL_INTEGER_SPACE];
TkDisplay *dispPtr = winPtr->dispPtr;
const char *arg, *name;
Tcl_Obj *resultObj;
ThreadSpecificData *tsdPtr =
Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "option ?args?");
return TCL_ERROR;
}
if (Tcl_GetIndexFromObjStruct(interp, objv[1], imageOptions,
sizeof(char *), "option", 0, &index) != TCL_OK) {
return TCL_ERROR;
}
switch ((enum options) index) {
case IMAGE_CREATE: {
Tcl_Obj **args;
int oldimage = 0;
if (objc < 3) {
Tcl_WrongNumArgs(interp, 2, objv,
"type ?name? ?-option value ...?");
return TCL_ERROR;
}
/*
* Look up the image type.
*/
arg = Tcl_GetString(objv[2]);
for (typePtr = tsdPtr->imageTypeList; typePtr != NULL;
typePtr = typePtr->nextPtr) {
if ((*arg == typePtr->name[0])
&& (strcmp(arg, typePtr->name) == 0)) {
break;
}
}
if (typePtr == NULL) {
oldimage = 1;
for (typePtr = tsdPtr->oldImageTypeList; typePtr != NULL;
typePtr = typePtr->nextPtr) {
if ((*arg == typePtr->name[0])
&& (strcmp(arg, typePtr->name) == 0)) {
break;
}
}
}
if (typePtr == NULL) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"image type \"%s\" doesn't exist", arg));
Tcl_SetErrorCode(interp, "TK", "LOOKUP", "IMAGE_TYPE", arg, NULL);
return TCL_ERROR;
}
/*
* Figure out a name to use for the new image.
*/
if ((objc == 3) || (*(arg = Tcl_GetString(objv[3])) == '-')) {
do {
dispPtr->imageId++;
sprintf(idString, "image%d", dispPtr->imageId);
name = idString;
} while (Tcl_FindCommand(interp, name, NULL, 0) != NULL);
firstOption = 3;
} else {
TkWindow *topWin;
name = arg;
firstOption = 4;
/*
* Need to check if the _command_ that we are about to create is
* the name of the current master widget command (normally "." but
* could have been renamed) and fail in that case before a really
* nasty and hard to stop crash happens.
*/
topWin = (TkWindow *) TkToplevelWindowForCommand(interp, name);
if (topWin != NULL && winPtr->mainPtr->winPtr == topWin) {
Tcl_SetObjResult(interp, Tcl_NewStringObj(
"images may not be named the same as the main window",
-1));
Tcl_SetErrorCode(interp, "TK", "IMAGE", "SMASH_MAIN", NULL);
return TCL_ERROR;
}
}
/*
* Create the data structure for the new image.
*/
hPtr = Tcl_CreateHashEntry(&winPtr->mainPtr->imageTable, name, &isNew);
if (isNew) {
masterPtr = ckalloc(sizeof(ImageMaster));
masterPtr->typePtr = NULL;
masterPtr->masterData = NULL;
masterPtr->width = masterPtr->height = 1;
masterPtr->tablePtr = &winPtr->mainPtr->imageTable;
masterPtr->hPtr = hPtr;
masterPtr->instancePtr = NULL;
masterPtr->deleted = 0;
masterPtr->winPtr = winPtr->mainPtr->winPtr;
Tcl_Preserve(masterPtr->winPtr);
Tcl_SetHashValue(hPtr, masterPtr);
} else {
/*
* An image already exists by this name. Disconnect the instances
* from the master.
*/
masterPtr = Tcl_GetHashValue(hPtr);
if (masterPtr->typePtr != NULL) {
for (imagePtr = masterPtr->instancePtr; imagePtr != NULL;
imagePtr = imagePtr->nextPtr) {
masterPtr->typePtr->freeProc(imagePtr->instanceData,
imagePtr->display);
imagePtr->changeProc(imagePtr->widgetClientData, 0, 0,
masterPtr->width, masterPtr->height,
masterPtr->width, masterPtr->height);
}
masterPtr->typePtr->deleteProc(masterPtr->masterData);
masterPtr->typePtr = NULL;
}
masterPtr->deleted = 0;
}
/*
* Call the image type manager so that it can perform its own
* initialization, then re-"get" for any existing instances of the
* image.
*/
objv += firstOption;
objc -= firstOption;
args = (Tcl_Obj **) objv;
if (oldimage) {
int i;
args = ckalloc((objc+1) * sizeof(char *));
for (i = 0; i < objc; i++) {
args[i] = (Tcl_Obj *) Tcl_GetString(objv[i]);
}
args[objc] = NULL;
}
Tcl_Preserve(masterPtr);
if (typePtr->createProc(interp, name, objc, args, typePtr,
(Tk_ImageMaster)masterPtr, &masterPtr->masterData) != TCL_OK){
EventuallyDeleteImage(masterPtr, 0);
Tcl_Release(masterPtr);
if (oldimage) {
ckfree(args);
}
return TCL_ERROR;
}
Tcl_Release(masterPtr);
if (oldimage) {
ckfree(args);
}
masterPtr->typePtr = typePtr;
for (imagePtr = masterPtr->instancePtr; imagePtr != NULL;
imagePtr = imagePtr->nextPtr) {
imagePtr->instanceData = typePtr->getProc(imagePtr->tkwin,
masterPtr->masterData);
}
Tcl_SetObjResult(interp, Tcl_NewStringObj(
Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1));
break;
}
case IMAGE_DELETE:
for (i = 2; i < objc; i++) {
arg = Tcl_GetString(objv[i]);
hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->imageTable, arg);
if (hPtr == NULL) {
goto alreadyDeleted;
}
masterPtr = Tcl_GetHashValue(hPtr);
if (masterPtr->deleted) {
goto alreadyDeleted;
}
DeleteImage(masterPtr);
}
break;
case IMAGE_NAMES:
if (objc != 2) {
Tcl_WrongNumArgs(interp, 2, objv, NULL);
return TCL_ERROR;
}
hPtr = Tcl_FirstHashEntry(&winPtr->mainPtr->imageTable, &search);
resultObj = Tcl_NewObj();
for ( ; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
masterPtr = Tcl_GetHashValue(hPtr);
if (masterPtr->deleted) {
continue;
}
Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(
Tcl_GetHashKey(&winPtr->mainPtr->imageTable, hPtr), -1));
}
Tcl_SetObjResult(interp, resultObj);
break;
case IMAGE_TYPES:
if (objc != 2) {
Tcl_WrongNumArgs(interp, 2, objv, NULL);
return TCL_ERROR;
}
resultObj = Tcl_NewObj();
for (typePtr = tsdPtr->imageTypeList; typePtr != NULL;
typePtr = typePtr->nextPtr) {
Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(
typePtr->name, -1));
}
for (typePtr = tsdPtr->oldImageTypeList; typePtr != NULL;
typePtr = typePtr->nextPtr) {
Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(
typePtr->name, -1));
}
Tcl_SetObjResult(interp, resultObj);
break;
case IMAGE_HEIGHT:
case IMAGE_INUSE:
case IMAGE_TYPE:
case IMAGE_WIDTH:
/*
* These operations all parse virtually identically. First check to
* see if three args are given. Then get a non-deleted master from the
* third arg.
*/
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "name");
return TCL_ERROR;
}
arg = Tcl_GetString(objv[2]);
hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->imageTable, arg);
if (hPtr == NULL) {
goto alreadyDeleted;
}
masterPtr = Tcl_GetHashValue(hPtr);
if (masterPtr->deleted) {
goto alreadyDeleted;
}
/*
* Now we read off the specific piece of data we were asked for.
*/
switch ((enum options) index) {
case IMAGE_HEIGHT:
Tcl_SetObjResult(interp, Tcl_NewWideIntObj(masterPtr->height));
break;
case IMAGE_INUSE:
Tcl_SetObjResult(interp, Tcl_NewBooleanObj(
masterPtr->typePtr && masterPtr->instancePtr));
break;
case IMAGE_TYPE:
if (masterPtr->typePtr != NULL) {
Tcl_SetObjResult(interp,
Tcl_NewStringObj(masterPtr->typePtr->name, -1));
}
break;
case IMAGE_WIDTH:
Tcl_SetObjResult(interp, Tcl_NewWideIntObj(masterPtr->width));
break;
default:
Tcl_Panic("can't happen");
}
break;
}
return TCL_OK;
alreadyDeleted:
Tcl_SetObjResult(interp, Tcl_ObjPrintf("image \"%s\" doesn't exist",arg));
Tcl_SetErrorCode(interp, "TK", "LOOKUP", "IMAGE", arg, NULL);
return TCL_ERROR;
}
/*
*---------------------------------------------------------------------------
*
* HtmlImageServerGet --
*
* Retrieve an HtmlImage2 object for the image at URL zUrl from
* an image-server. The caller should match this call with a single
* HtmlImageFree() when the image object is no longer required.
*
* If the image is not already in the cache, the Tcl script
* configured as the widget -imagecmd is invoked. If this command
* raises an error or returns an invalid result, then this function
* returns NULL. A Tcl back-ground error is propagated in this case
* also.
*
* Results:
* Pointer to HtmlImage2 object containing the image from zUrl, or
* NULL, if zUrl was invalid for some reason.
*
* Side effects:
* May invoke -imagecmd script.
*
*---------------------------------------------------------------------------
*/
HtmlImage2 *
HtmlImageServerGet (HtmlImageServer *p, const char *zUrl)
{
Tcl_Obj *pImageCmd = p->pTree->options.imagecmd;
Tcl_Interp *interp = p->pTree->interp;
Tcl_HashEntry *pEntry = 0;
HtmlImage2 *pImage = 0;
/* Try to find the requested image in the hash table. */
if (pImageCmd) {
int new_entry;
pEntry = Tcl_CreateHashEntry(&p->aImage, zUrl, &new_entry);
if (new_entry) {
Tcl_Obj *pEval;
Tcl_Obj *pResult;
int rc;
int nObj;
Tcl_Obj **apObj = 0;
Tk_Image img;
/* The image could not be found in the hash table and an
* -imagecmd callback is configured. The callback script
* must be executed to obtain an image. Build up a script
* in pEval and execute it. Put the result in variable pResult.
*/
pEval = Tcl_DuplicateObj(pImageCmd);
Tcl_IncrRefCount(pEval);
Tcl_ListObjAppendElement(interp, pEval, Tcl_NewStringObj(zUrl, -1));
rc = Tcl_EvalObjEx(interp, pEval, TCL_EVAL_DIRECT|TCL_EVAL_GLOBAL);
Tcl_DecrRefCount(pEval);
if (rc != TCL_OK) {
goto image_get_out;
}
pResult = Tcl_GetObjResult(interp);
/* Read the result into array apObj. If the result was
* not a valid Tcl list, return NULL and raise a background
* error about the badly formed list.
*/
rc = Tcl_ListObjGetElements(interp, pResult, &nObj, &apObj);
if (rc != TCL_OK) {
goto image_get_out;
}
if (nObj==0) {
Tcl_DeleteHashEntry(pEntry);
goto image_unavailable;
}
pImage = HtmlNew(HtmlImage2);
if (nObj == 1 || nObj == 2) {
img = Tk_GetImage(
interp, p->pTree->tkwin, Tcl_GetString(apObj[0]),
imageChanged, pImage
);
}
if ((nObj != 1 && nObj != 2) || !img) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "-imagecmd returned bad value", 0);
HtmlFree(pImage);
pImage = 0;
goto image_get_out;
}
Tcl_SetHashValue(pEntry, (ClientData)pImage);
Tcl_IncrRefCount(apObj[0]);
pImage->pImageName = apObj[0];
if (nObj == 2) {
Tcl_IncrRefCount(apObj[1]);
pImage->pDelete = apObj[1];
}
pImage->pImageServer = p;
pImage->zUrl = Tcl_GetHashKey(&p->aImage, pEntry);
pImage->image = img;
Tk_SizeOfImage(pImage->image, &pImage->width, &pImage->height);
pImage->isValid = 1;
HtmlImagePixmap(pImage);
}
}
image_get_out:
pImage = (HtmlImage2 *)(pEntry ? Tcl_GetHashValue(pEntry) : 0);
HtmlImageRef(pImage);
if (!pImage && pImageCmd) {
Tcl_BackgroundError(interp);
Tcl_ResetResult(interp);
assert(pEntry);
Tcl_DeleteHashEntry(pEntry);
}
image_unavailable:
return pImage;
}
GC
Tk_GetGC(
Tk_Window tkwin, /* Window in which GC will be used. */
register unsigned long valueMask,
/* 1 bits correspond to values specified in
* *valuesPtr; other values are set from
* defaults. */
register XGCValues *valuePtr)
/* Values are specified here for bits set in
* valueMask. */
{
ValueKey valueKey;
Tcl_HashEntry *valueHashPtr, *idHashPtr;
register TkGC *gcPtr;
int isNew;
Drawable d, freeDrawable;
TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;
if (dispPtr->gcInit <= 0) {
GCInit(dispPtr);
}
/*
* Must zero valueKey at start to clear out pad bytes that may be part of
* structure on some systems.
*/
memset(&valueKey, 0, sizeof(valueKey));
/*
* First, check to see if there's already a GC that will work for this
* request (exact matches only, sorry).
*/
if (valueMask & GCFunction) {
valueKey.values.function = valuePtr->function;
} else {
valueKey.values.function = GXcopy;
}
if (valueMask & GCPlaneMask) {
valueKey.values.plane_mask = valuePtr->plane_mask;
} else {
valueKey.values.plane_mask = (unsigned) ~0;
}
if (valueMask & GCForeground) {
valueKey.values.foreground = valuePtr->foreground;
} else {
valueKey.values.foreground = 0;
}
if (valueMask & GCBackground) {
valueKey.values.background = valuePtr->background;
} else {
valueKey.values.background = 1;
}
if (valueMask & GCLineWidth) {
valueKey.values.line_width = valuePtr->line_width;
} else {
valueKey.values.line_width = 0;
}
if (valueMask & GCLineStyle) {
valueKey.values.line_style = valuePtr->line_style;
} else {
valueKey.values.line_style = LineSolid;
}
if (valueMask & GCCapStyle) {
valueKey.values.cap_style = valuePtr->cap_style;
} else {
valueKey.values.cap_style = CapButt;
}
if (valueMask & GCJoinStyle) {
valueKey.values.join_style = valuePtr->join_style;
} else {
valueKey.values.join_style = JoinMiter;
}
if (valueMask & GCFillStyle) {
valueKey.values.fill_style = valuePtr->fill_style;
} else {
valueKey.values.fill_style = FillSolid;
}
if (valueMask & GCFillRule) {
valueKey.values.fill_rule = valuePtr->fill_rule;
} else {
valueKey.values.fill_rule = EvenOddRule;
}
if (valueMask & GCArcMode) {
valueKey.values.arc_mode = valuePtr->arc_mode;
} else {
valueKey.values.arc_mode = ArcPieSlice;
}
if (valueMask & GCTile) {
valueKey.values.tile = valuePtr->tile;
} else {
valueKey.values.tile = None;
}
if (valueMask & GCStipple) {
valueKey.values.stipple = valuePtr->stipple;
} else {
valueKey.values.stipple = None;
}
if (valueMask & GCTileStipXOrigin) {
valueKey.values.ts_x_origin = valuePtr->ts_x_origin;
} else {
valueKey.values.ts_x_origin = 0;
}
if (valueMask & GCTileStipYOrigin) {
valueKey.values.ts_y_origin = valuePtr->ts_y_origin;
} else {
valueKey.values.ts_y_origin = 0;
}
if (valueMask & GCFont) {
valueKey.values.font = valuePtr->font;
} else {
valueKey.values.font = None;
}
if (valueMask & GCSubwindowMode) {
valueKey.values.subwindow_mode = valuePtr->subwindow_mode;
} else {
valueKey.values.subwindow_mode = ClipByChildren;
}
if (valueMask & GCGraphicsExposures) {
valueKey.values.graphics_exposures = valuePtr->graphics_exposures;
} else {
valueKey.values.graphics_exposures = True;
}
if (valueMask & GCClipXOrigin) {
valueKey.values.clip_x_origin = valuePtr->clip_x_origin;
} else {
valueKey.values.clip_x_origin = 0;
}
if (valueMask & GCClipYOrigin) {
valueKey.values.clip_y_origin = valuePtr->clip_y_origin;
} else {
valueKey.values.clip_y_origin = 0;
}
if (valueMask & GCClipMask) {
valueKey.values.clip_mask = valuePtr->clip_mask;
} else {
valueKey.values.clip_mask = None;
}
if (valueMask & GCDashOffset) {
valueKey.values.dash_offset = valuePtr->dash_offset;
} else {
valueKey.values.dash_offset = 0;
}
if (valueMask & GCDashList) {
valueKey.values.dashes = valuePtr->dashes;
} else {
valueKey.values.dashes = 4;
}
valueKey.display = Tk_Display(tkwin);
valueKey.screenNum = Tk_ScreenNumber(tkwin);
valueKey.depth = Tk_Depth(tkwin);
valueHashPtr = Tcl_CreateHashEntry(&dispPtr->gcValueTable,
(char *) &valueKey, &isNew);
if (!isNew) {
gcPtr = Tcl_GetHashValue(valueHashPtr);
gcPtr->refCount++;
return gcPtr->gc;
}
/*
* No GC is currently available for this set of values. Allocate a new GC
* and add a new structure to the database.
*/
gcPtr = ckalloc(sizeof(TkGC));
/*
* Find or make a drawable to use to specify the screen and depth of the
* GC. We may have to make a small pixmap, to avoid doing
* Tk_MakeWindowExist on the window.
*/
freeDrawable = None;
if (Tk_WindowId(tkwin) != None) {
d = Tk_WindowId(tkwin);
} else if (valueKey.depth ==
DefaultDepth(valueKey.display, valueKey.screenNum)) {
d = RootWindow(valueKey.display, valueKey.screenNum);
} else {
d = Tk_GetPixmap(valueKey.display,
RootWindow(valueKey.display, valueKey.screenNum),
1, 1, valueKey.depth);
freeDrawable = d;
}
gcPtr->gc = XCreateGC(valueKey.display, d, valueMask, &valueKey.values);
gcPtr->display = valueKey.display;
gcPtr->refCount = 1;
gcPtr->valueHashPtr = valueHashPtr;
idHashPtr = Tcl_CreateHashEntry(&dispPtr->gcIdTable,
(char *) gcPtr->gc, &isNew);
if (!isNew) {
Tcl_Panic("GC already registered in Tk_GetGC");
}
Tcl_SetHashValue(valueHashPtr, gcPtr);
Tcl_SetHashValue(idHashPtr, gcPtr);
if (freeDrawable != None) {
Tk_FreePixmap(valueKey.display, freeDrawable);
}
return gcPtr->gc;
}
static Tcl_HashTable *
ThreadStorageGetHashTable(
Tcl_ThreadId id) /* Id of thread to get hash table for */
{
int index = PTR2UINT(id) % STORAGE_CACHE_SLOTS;
Tcl_HashEntry *hPtr;
int isNew;
/*
* It's important that we pick up the hash table pointer BEFORE comparing
* thread Id in case another thread is in the critical region changing
* things out from under you.
*/
Tcl_HashTable *hashTablePtr = threadStorageCache[index].hashTablePtr;
if (threadStorageCache[index].id != id) {
Tcl_MutexLock(&threadStorageLock);
/*
* It's not in the cache, so we look it up...
*/
hPtr = Tcl_FindHashEntry(&threadStorageHashTable, (char *) id);
if (hPtr != NULL) {
/*
* We found it, extract the hash table pointer.
*/
hashTablePtr = Tcl_GetHashValue(hPtr);
} else {
/*
* The thread specific hash table is not found.
*/
hashTablePtr = NULL;
}
if (hashTablePtr == NULL) {
hashTablePtr = (Tcl_HashTable *)
TclpSysAlloc(sizeof(Tcl_HashTable), 0);
if (hashTablePtr == NULL) {
Tcl_Panic("could not allocate thread specific hash table, "
"TclpSysAlloc failed from ThreadStorageGetHashTable!");
}
Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS,
&tclThreadStorageHashKeyType);
/*
* Add new thread storage hash table to the master hash table.
*/
hPtr = Tcl_CreateHashEntry(&threadStorageHashTable, (char *) id,
&isNew);
if (hPtr == NULL) {
Tcl_Panic("Tcl_CreateHashEntry failed from "
"ThreadStorageGetHashTable!");
}
Tcl_SetHashValue(hPtr, hashTablePtr);
}
/*
* Now, we put it in the cache since it is highly likely it will be
* needed again shortly.
*/
threadStorageCache[index].id = id;
threadStorageCache[index].hashTablePtr = hashTablePtr;
Tcl_MutexUnlock(&threadStorageLock);
}
return hashTablePtr;
}