void
CBSymbolTable::Receive
(
JBroadcaster* sender,
const Message& message
)
{
if (sender == itsSymbolList && message.Is(CBSymbolList::kChanged))
{
RebuildTable();
}
else if (sender == CBGetSymbolTypeList() &&
message.Is(CBSymbolTypeList::kVisibilityChanged))
{
RebuildTable();
}
else if (sender == CBGetSymbolTypeList() &&
message.Is(CBSymbolTypeList::kStyleChanged))
{
Refresh();
}
else
{
JXTable::Receive(sender, message);
}
}
BOOL MapParamDlg::OnInitDialog()
{
CDialog::OnInitDialog();
m_frame = (CMainFrame *)AfxGetMainWnd();
m_table_list.SetListFont(GetFont());
m_table_list.SetExtendedStyle(LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT);
m_table_list.m_show_selection = false;
RECT r;
m_table_list.GetClientRect(&r);
int len_N = 25, len_other = (r.right - r.left) - len_N - WIDTH_DATA_COL - 16;
m_table_list.InsertColumn(0, "N", LVCFMT_LEFT, len_N);
m_table_list.InsertColumn(1, "Параметр", LVCFMT_LEFT, len_other);
m_table_list.InsertColumn(3, "Исходные данные", LVCFMT_LEFT, WIDTH_DATA_COL);
RebuildTable();
m_prev_selection = m_table_list.GetCurItem();
m_table_list.m_lb_click_msg = WM_LIST_SELECTION_CHANGED;
m_table_list.m_key_down_msg = WM_LIST_SELECTION_CHANGED;
m_table_list.m_messages_wnd = this;
return TRUE;
}
void MapParamDlg::OnButtonDelete()
{
int mark = m_table_list.GetCurItem();
DWORD param_num = m_table_list.GetItemData(mark);
if (param_num <= MAX_PARAM)
{
MessageBox("Нельзя удалять зарезервированные параметры", "Параметр не будет удален");
return;
}
if (MessageBox("Вы действительно хотите удалить параметр?", "Удалить параметр?", MB_YESNO) == IDYES)
{
{
MutexWrap params_access(m_params_map_mutex);
CParam* param_to_delete;
if (!m_MapParamDefault.Lookup(param_num, param_to_delete))
return;
pApp->SendMessageToActiveView(PM_DELETE_EXT_PARAM, param_num, 0);
m_MapParamDefault.RemoveKey(param_num);
m_MapParam.RemoveKey(param_num);
delete param_to_delete;
m_table_list.SetCurItem(mark - 1);
m_prev_selection = m_table_list.GetCurItem();
}
RebuildTable();
}
}
static HashEntry *
ArrayCreate(HashTable *tablePtr, const void *key, int *newPtr) {
#if 0
HashTable *tablePtr; /* Table in which to lookup entry. */
const void *key; /* Key to use to find or create matching
* entry. */
int *newPtr; /* Store info here telling whether a new
* entry was created. */
#endif
HashEntry *hPtr = NULL;
unsigned int idx = HashArray(tablePtr, key);
idx = RANDOM_INDEX(tablePtr, idx);
/*
* Search all of the entries in the appropriate bucket.
*/
for (hPtr = tablePtr->buckets[idx];
hPtr != NULL;
hPtr = hPtr->nextPtr) {
if (memcmp(key, (void *)hPtr->key.bytes, tablePtr->keyLen) == 0) {
*newPtr = 0;
return hPtr;
}
}
/*
* Entry not found. Add a new one to the bucket.
*/
hPtr = (HashEntry *)malloc(sizeof(HashEntry) - sizeof(hPtr->key) +
tablePtr->keyLen);
if (hPtr != NULL) {
*newPtr = 1;
hPtr->tablePtr = tablePtr;
hPtr->bucketPtr = &(tablePtr->buckets[idx]);
hPtr->nextPtr = *hPtr->bucketPtr;
hPtr->clientData = 0;
(void)memcpy((void *)hPtr->key.bytes, key, tablePtr->keyLen);
*hPtr->bucketPtr = hPtr;
tablePtr->numEntries++;
/*
* If the table has exceeded a decent size, rebuild it with many
* more buckets.
*/
if (tablePtr->numEntries >= tablePtr->rebuildSize) {
RebuildTable(tablePtr);
}
} else {
*newPtr = 0;
}
return hPtr;
}
static HashEntry *
OneWordCreate(HashTable *tablePtr, const void *key, int *newPtr) {
#if 0
HashTable *tablePtr; /* Table in which to lookup entry. */
const void *key; /* Key to use to find or create matching
* entry. */
int *newPtr; /* Store info here telling whether a new
* entry was created. */
#endif
HashEntry *hPtr;
unsigned int idx;
idx = RANDOM_INDEX(tablePtr, key);
/*
* Search all of the entries in this bucket.
*/
for (hPtr = tablePtr->buckets[idx];
hPtr != NULL;
hPtr = hPtr->nextPtr) {
if (hPtr->key.oneWordKey == key) {
*newPtr = 0;
return hPtr;
}
}
/*
* Entry not found. Add a new one to the bucket.
*/
hPtr = (HashEntry *)malloc(sizeof(HashEntry));
if (hPtr != NULL) {
*newPtr = 1;
hPtr->tablePtr = tablePtr;
hPtr->bucketPtr = &(tablePtr->buckets[idx]);
hPtr->nextPtr = *hPtr->bucketPtr;
hPtr->clientData = 0;
hPtr->key.oneWordKey = key;
*hPtr->bucketPtr = hPtr;
tablePtr->numEntries++;
/*
* If the table has exceeded a decent size, rebuild it with
* many more buckets.
*/
if (tablePtr->numEntries >= tablePtr->rebuildSize) {
RebuildTable(tablePtr);
}
} else {
*newPtr = 0;
}
return hPtr;
}
void
CBSymbolTable::SetDisplayList
(
const JArray<JIndex>& list
)
{
*itsVisibleList = list;
itsVisibleList->SetBlockSize(CBSymbolList::kBlockSize);
itsVisibleListLockedFlag = kJTrue;
ScrollTo(0,0);
RebuildTable();
}
Hash_Entry *
Hash_CreateEntry(
register Hash_Table *t, /* Hash table to search. */
char *key, /* A hash key. */
Boolean *newPtr) /* Filled in with TRUE if new entry created,
* FALSE otherwise. */
{
register Hash_Entry *e;
register unsigned h;
register char *p;
int keylen;
struct Hash_Entry **hp;
/*
* Hash the key. As a side effect, save the length (strlen) of the
* key in case we need to create the entry.
*/
for (h = 0, p = key; *p;)
h = (h << 5) - h + *p++;
keylen = p - key;
p = key;
for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
if (e->namehash == h && strcmp(e->name, p) == 0) {
if (newPtr != NULL)
*newPtr = FALSE;
return (e);
}
}
/*
* The desired entry isn't there. Before allocating a new entry,
* expand the table if necessary (and this changes the resulting
* bucket chain).
*/
if (t->numEntries >= rebuildLimit * t->size)
RebuildTable(t);
e = (Hash_Entry *) emalloc(sizeof(*e) + keylen);
hp = &t->bucketPtr[h & t->mask];
e->next = *hp;
*hp = e;
e->clientData = NULL;
e->namehash = h;
(void) strcpy(e->name, p);
t->numEntries++;
if (newPtr != NULL)
*newPtr = TRUE;
return (e);
}
void
CBSymbolTable::ShowAll()
{
itsVisibleListLockedFlag = kJFalse;
itsVisibleList->RemoveAll(); // force rebuild of entire list
delete itsNameFilter;
itsNameFilter = NULL;
delete itsNameLiteral;
itsNameLiteral = NULL;
ScrollTo(0,0);
RebuildTable();
}
Hash_Entry *
Hash_CreateEntry(Hash_Table *t, const char *key, Boolean *newPtr)
{
Hash_Entry *e;
unsigned h;
const char *p;
int keylen;
struct Hash_Entry **hp;
/*
* Hash the key. As a side effect, save the length (strlen) of the
* key in case we need to create the entry.
*/
for (h = 0, p = key; *p;)
h = (h << 5) - h + *p++;
keylen = p - key;
p = key;
for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
if (e->namehash == h && strcmp(e->name, p) == 0) {
if (newPtr != NULL)
*newPtr = FALSE;
return (e);
}
}
/*
* The desired entry isn't there. Before allocating a new entry,
* expand the table if necessary (and this changes the resulting
* bucket chain).
*/
if (t->numEntries >= rebuildLimit * t->size)
RebuildTable(t);
e = bmake_malloc(sizeof(*e) + keylen);
hp = &t->bucketPtr[h & t->mask];
e->next = *hp;
*hp = e;
Hash_SetValue(e, NULL);
e->namehash = h;
(void)strcpy(e->name, p);
t->numEntries++;
if (newPtr != NULL)
*newPtr = TRUE;
return (e);
}
void MapParamDlg::OnButtonAdd()
{
CParam *param = new CParam(), *other;
param->sName = "Новый параметр";
param->m_channel_num = -1;
for (param->m_num_par = MAX_PARAM + 1; param->m_num_par < 10000; param->m_num_par++)
if (!m_MapParamDefault.Lookup(param->m_num_par, other))
break;
NewCorrespondenceDlg dlg(param, true);
if (dlg.DoModal() == IDOK)
{
param->Init();
m_MapParamDefault[param->m_num_par] = param;
if (param->bParamActive)
m_MapParam[param->m_num_par] = param;
RebuildTable();
}
}
hash_entry_t *
Hash_CreateEntry(hash_table_t *table, /* Hash table to search. */
unsigned int hash, /* A hash key. */
int *newPtr /* Filled in with TRUE if new entry created,
* FALSE otherwise. */
)
{
hash_entry_t *e;
for (e = table->bucketPtr[hash & table->mask]; e != NULL; e = e->next) {
if (e->namehash == hash) {
if (newPtr != NULL) {
*newPtr = FALSE;
}
break;
}
}
if (!e) {
/*
* The desired entry isn'table there. Before allocating a new entry,
* expand the table if necessary (and this changes the resulting
* bucket chain).
*/
if ((table->numEntries < (rebuildLimit * table->size)) || RebuildTable(table))
{
e = (hash_entry_t *) malloc(sizeof(hash_entry_t));/*emalloc(sizeof(*e) + keylen);*/
if (e) {
hash_entry_t **hp= &table->bucketPtr[hash & table->mask];
e->next = *hp; // point at whatever was in the bucket
*hp = e; // put us in the bucket
e->clientData = NULL;
e->clientFlags= 0;
e->namehash = hash;
++table->numEntries;
if (newPtr != NULL) {
*newPtr = TRUE;
}
}
}
}
return (e);
}
JError
CBSymbolTable::SetNameFilter
(
const JCharacter* filterStr,
const JBoolean isRegex
)
{
delete itsNameFilter;
itsNameFilter = NULL;
delete itsNameLiteral;
itsNameLiteral = NULL;
JError result = JNoError();
if (isRegex)
{
itsNameFilter = new JRegex;
assert( itsNameFilter != NULL );
result = itsNameFilter->SetPattern(filterStr);
if (!result.OK())
{
delete itsNameFilter;
itsNameFilter = NULL;
}
}
else
{
itsNameLiteral = new JString(filterStr);
assert( itsNameLiteral != NULL );
}
itsVisibleListLockedFlag = kJFalse;
ScrollTo(0,0);
RebuildTable();
return result;
}
static HashEntry *
StringCreate(HashTable *tablePtr, const void *vKey, int *newPtr) {
#if 0
HashTable *tablePtr; /* Table in which to lookup entry. */
const void *key; /* Key to use to find or create matching
* entry. */
int *newPtr; /* Store info here telling whether a new
* entry was created. */
#endif
const char *key = (const char *)vKey;
HashEntry *hPtr = NULL;
if (key != NULL) {
unsigned int idx = HashString(key) & tablePtr->mask;
size_t kLen = strlen(key);
/*
* Search all of the entries in this bucket.
*/
for (hPtr = tablePtr->buckets[idx];
hPtr != NULL;
hPtr = hPtr->nextPtr) {
if (strcmp(key, hPtr->key.string) == 0) {
*newPtr = 0;
return hPtr;
}
}
/*
* Entry not found. Add a new one to the bucket.
*/
hPtr = (HashEntry *)malloc(sizeof(HashEntry) - sizeof(hPtr->key) +
kLen + 1);
if (hPtr != NULL) {
*newPtr = 1;
hPtr->tablePtr = tablePtr;
hPtr->bucketPtr = &(tablePtr->buckets[idx]);
hPtr->nextPtr = *hPtr->bucketPtr;
hPtr->clientData = 0;
(void)memcpy((void *)(hPtr->key.string), (void *)key, kLen + 1);
*hPtr->bucketPtr = hPtr;
tablePtr->numEntries++;
/*
* If the table has exceeded a decent size, rebuild it with many
* more buckets.
*/
if (tablePtr->numEntries >= tablePtr->rebuildSize) {
RebuildTable(tablePtr);
}
} else {
*newPtr = 0;
}
} else {
*newPtr = 0;
}
return hPtr;
}
Tcl_HashEntry *
Tcl_CreateHashEntry(
Tcl_HashTable *tablePtr, /* Table in which to lookup entry. */
const char *key, /* Key to use to find or create matching
* entry. */
int *newPtr) /* Store info here telling whether a new entry
* was created. */
{
register Tcl_HashEntry *hPtr;
const Tcl_HashKeyType *typePtr;
unsigned int hash;
int index;
if (tablePtr->keyType == TCL_STRING_KEYS) {
typePtr = &tclStringHashKeyType;
} else if (tablePtr->keyType == TCL_ONE_WORD_KEYS) {
typePtr = &tclOneWordHashKeyType;
} else if (tablePtr->keyType == TCL_CUSTOM_TYPE_KEYS
|| tablePtr->keyType == TCL_CUSTOM_PTR_KEYS) {
typePtr = tablePtr->typePtr;
} else {
typePtr = &tclArrayHashKeyType;
}
if (typePtr->hashKeyProc) {
hash = typePtr->hashKeyProc(tablePtr, (void *) key);
if (typePtr->flags & TCL_HASH_KEY_RANDOMIZE_HASH) {
index = RANDOM_INDEX (tablePtr, hash);
} else {
index = hash & tablePtr->mask;
}
} else {
hash = PTR2UINT(key);
index = RANDOM_INDEX (tablePtr, hash);
}
/*
* Search all of the entries in the appropriate bucket.
*/
if (typePtr->compareKeysProc) {
Tcl_CompareHashKeysProc *compareKeysProc = typePtr->compareKeysProc;
for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
hPtr = hPtr->nextPtr) {
#if TCL_HASH_KEY_STORE_HASH
if (hash != PTR2UINT(hPtr->hash)) {
continue;
}
#endif
if (compareKeysProc((void *) key, hPtr)) {
if (newPtr) {
*newPtr = 0;
}
return hPtr;
}
}
} else {
for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
hPtr = hPtr->nextPtr) {
#if TCL_HASH_KEY_STORE_HASH
if (hash != PTR2UINT(hPtr->hash)) {
continue;
}
#endif
if (key == hPtr->key.oneWordValue) {
if (newPtr) {
*newPtr = 0;
}
return hPtr;
}
}
}
if (!newPtr) {
return NULL;
}
/*
* Entry not found. Add a new one to the bucket.
*/
*newPtr = 1;
if (typePtr->allocEntryProc) {
hPtr = typePtr->allocEntryProc(tablePtr, (void *) key);
} else {
hPtr = (Tcl_HashEntry *) ckalloc((unsigned) sizeof(Tcl_HashEntry));
hPtr->key.oneWordValue = (char *) key;
hPtr->clientData = 0;
}
hPtr->tablePtr = tablePtr;
#if TCL_HASH_KEY_STORE_HASH
hPtr->hash = UINT2PTR(hash);
hPtr->nextPtr = tablePtr->buckets[index];
tablePtr->buckets[index] = hPtr;
#else
hPtr->bucketPtr = &(tablePtr->buckets[index]);
hPtr->nextPtr = *hPtr->bucketPtr;
*hPtr->bucketPtr = hPtr;
#endif
tablePtr->numEntries++;
/*
* If the table has exceeded a decent size, rebuild it with many more
* buckets.
*/
if (tablePtr->numEntries >= tablePtr->rebuildSize) {
RebuildTable(tablePtr);
}
return hPtr;
}
