[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
/*****************************************************************************/
/*
dict.c
A hash dictionary (associative array) of key-value pairs. Both key and value
are commonly strings but actually can be any sized blob. Keys that begin with
a digit have special meaning to response header processing and so should be
avoided in that type (especially). Inserting a key that already exists
effectively replaces the previous value - unless - the uniquifier bit :-} is
set, in which case a dictionary-unique integer (followed by a colon) is
prefixed to the key allowing multiple entries having (essentially) the same
key. As memory allocation can change due to value length increase any
reference to the entry or its value must be re-set.
All keys are pushed to lower-case on insertion, though key lookup is case
insensitive. Each key has a "type", represented by a specific,
non-alphanumeric character.
o $ request processing (server internal)
o ~ meta configuration (DICT and SET DICT=..)
o > request header field
o < response header field
(There are others, some currently unused.) These allow entries that can be
discriminated between quite simply. For example, iterating through all request
header fields. Some configuration uses of the dictionary (i.e. the DICT
directive and the mapping SET DICT=.. rule) will accept a key with a leading
non-alpha-numeric that allows a specific type key to be looked up and also
inserted. This allows the perhaps dangerous changing of server internal,
request processing dictionary entries. But hey, sysadmins know what they're
doing :-}
A load factor of 10 collision list entries to 1 hash table element
(empirically) seems to be a performance sweet spot so a table size of 32 means
up to some 300 entries will be efficiently handled (and theoretically, a table
of 512 elements would efficiently support 50k entries - though that's not the
design objective for this purpose). For server request processing purposes the
table size is set at 32 although expected entries would number less than a
couple of dozen (request and response header fields predominating).
A dictionary built using request memory does not need to be explicitly
destroyed when RequestFreeHeap() is deployed. If the request is just zeroized
then it does need destruction ready for any subsequent request.
With HTTP/1.n and HTTP/2 having fundamentally different header representations
there was a distinct need for an intermediate abstraction from which these both
could be interfaced with the server-internal requirements. Although the
implementation is quite general purpose, the role of this WASD dictionary is to
act as a repository for request and response header field names and values,
internally used strings (and potentially binary objects), and a new
configuration and request processing (mapping/authorization) abstraction based
on matching key-value pairs. (And it gave me a chance to play with an
associative array implementation :-)
The implementation is a bog-standard hash array with collision linked-list. An
associated list allows iteration in order of insertion. Each associative array
(dictionary) is dynamically allocated, as are entries in those arrays. As the
entry behaviour seems mostly static after insertion (i.e. values do not change
often if at all) each entry is allocated with space enough for the entry data
structure, key and value. One allocation per insertion. Makes value length
increases a little more complex but that's the tradeoff. Memory is generally
allocated from request heap zones and so disposes of itself when the request
structure is itself disposed of.
VERSION HISTORY
---------------
13-JAN-2020 MGD bugfix; "tmptr && tmptr->clink.."
25-FEB-2018 MGD 'uniquifier' delimiter changed from period to colon
22-DEC-2015 MGD initial
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
#include <stdio.h>
#include <ctype.h>
#include "wasd.h"
#define WASD_MODULE "DICT"
/******************/
/* global storage */
/******************/
static uint DictLookupHash,
DictLookupKlen;
/********************/
/* external storage */
/********************/
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck [];
extern CONFIG_STRUCT Config;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Create a new dictionary.
*/
DICT_STRUCT* DictCreate
(
REQUEST_STRUCT *rqptr,
int size
)
{
int idx;
DICT_STRUCT *dicptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictCreate()");
if (rqptr)
dicptr = VmGetHeap (rqptr, sizeof(DICT_STRUCT));
else
dicptr = VmGet (sizeof(DICT_STRUCT));
dicptr->RequestPtr = rqptr;
if ((int)(dicptr->size = size) <= 0) dicptr->size = DICT_DEFAULT_SIZE;
if (dicptr->size > 4096)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
dicptr->bytes = sizeof(DICT_ENTRY_STRUCT*) * dicptr->size;
if (rqptr)
dicptr->table = VmGetHeap (rqptr, dicptr->bytes);
else
dicptr->table = VmGet (dicptr->bytes);
return (dicptr);
}
/*****************************************************************************/
/*
Delete all dictionary items and then the dictionary itself.
Returns a NULL pointer.
*/
DICT_STRUCT* DictDestroy (DICT_STRUCT *dicptr)
{
DICT_ENTRY_STRUCT *denptr, *flink;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictDestroy()");
for (denptr = dicptr->head; denptr != NULL; denptr = flink)
{
flink = denptr->flink;
if (rqptr)
VmFreeFromHeap (rqptr, denptr, FI_LI);
else
VmFree (denptr, FI_LI);
}
if (rqptr)
VmFreeFromHeap (rqptr, dicptr, FI_LI);
else
VmFree (dicptr, FI_LI);
return (NULL);
}
/*****************************************************************************/
/*
Return the value of the dirty flag and reset.
*/
uint DictDirty (DICT_STRUCT *dicptr)
{
uint dirty;
/*********/
/* begin */
/*********/
if (dicptr == NULL) return (NULL);
dirty = dicptr->dirty;
dicptr->dirty = 0;
return (dirty);
}
/*****************************************************************************/
/*
Return a pointer to an exact duplicate of the supplied dictionary. If the
request pointer is supplied it is duplicated into that request. This can be
the same request as the dictionary being duplicated or another. If the
request pointer is NULL then it is duplicated into global memory, and of
course that may be where the original dictionary also resides. It can be
duplicated in any combination.
*/
DICT_STRUCT* DictDuplicate
(
REQUEST_STRUCT *rqptr,
DICT_STRUCT *dicptr
)
{
DICT_STRUCT *duptr;
DICT_ENTRY_STRUCT *denptr, *nxtptr;
/*********/
/* begin */
/*********/
if (dicptr == NULL) return (NULL);
duptr = DictCreate (rqptr, dicptr->size);
nxtptr = dicptr->head;
while ((denptr = nxtptr) != NULL)
{
nxtptr = denptr->flink;
DictInsert (duptr, denptr->type, denptr->key, denptr->klen,
denptr->value, denptr->vlen);
}
return (duptr);
}
/*****************************************************************************/
/*
Expand the specified entry's available value space by the specified quantity,
copying any existing content to the new memory. As the memory allocation is
likely to change any reference to the entry or its value must be re-set.
*/
DICT_ENTRY_STRUCT* DictExpandEntry
(
DICT_ENTRY_STRUCT *denptr,
uint bytes
)
{
ulong hash;
uchar *cptr, *sptr, *zptr;
DICT_STRUCT *dicptr;
DICT_ENTRY_STRUCT *newptr, *tmptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
dicptr = denptr->DictPtr;
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictExpandEntry()");
/* this is *additional* value space */
bytes += denptr->bytes;
/* plus two terminating nulls and some "elbow-room" */
if (rqptr)
newptr = VmGetHeap (rqptr, sizeof(DICT_ENTRY_STRUCT) + bytes + 8);
else
newptr = VmGet (sizeof(DICT_ENTRY_STRUCT) + bytes + 8);
newptr->bytes = bytes;
newptr->hash = hash = denptr->hash;
newptr->type[0] = denptr->type[0];
newptr->DictPtr = denptr->DictPtr;
/* reproduce the key */
newptr->klen = denptr->klen;
zptr = (sptr = newptr->key = newptr->buffer) + newptr->klen;
for (cptr = denptr->key; sptr < zptr; *sptr++ = *cptr++);
/* reproduce any value (see DictInsert() "just a little too clever") */
newptr->value = newptr->buffer + newptr->klen + 1;
/* if just reserving space (still valid with an expansion) */
if (denptr->value == NULL)
newptr->vlen = 0;
else
{
zptr = (sptr = newptr->value) + (newptr->vlen = denptr->vlen);
for (cptr = denptr->value; sptr < zptr; *sptr++ = *cptr++);
}
/* adjust the hash table / collision list */
if (dicptr->table[hash] == denptr)
dicptr->table[hash] = newptr;
else
{
for (tmptr = dicptr->table[hash];
tmptr && tmptr->clink != denptr;
tmptr = tmptr->clink);
tmptr->clink = newptr;
}
newptr->clink = denptr->clink;
/* adjust the ordered list */
if (dicptr->head == denptr) dicptr->head = newptr;
if (dicptr->tail == denptr) dicptr->tail = newptr;
if (denptr->flink != NULL) denptr->flink->blink = newptr;
if (denptr->blink != NULL) denptr->blink->flink = newptr;
newptr->flink = denptr->flink;
newptr->blink = denptr->blink;
/* if necessary adjust the iterator */
if (dicptr->next == denptr) dicptr->next = newptr;
if (rqptr)
VmFreeFromHeap (rqptr, denptr, FI_LI);
else
VmFree (denptr, FI_LI);
return (newptr);
}
/*****************************************************************************/
/*
Extract the specified entry from its dictionary.
*/
DICT_ENTRY_STRUCT* DictExtractEntry (DICT_ENTRY_STRUCT *denptr)
{
uint hash;
DICT_STRUCT *dicptr;
DICT_ENTRY_STRUCT *tmptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
dicptr = denptr->DictPtr;
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictExtractEntry()");
/* extract from the hash table / collision list */
hash = denptr->hash;
if (dicptr->table[hash] == denptr)
dicptr->table[hash] = denptr->clink;
else
{
for (tmptr = dicptr->table[hash];
tmptr && tmptr->clink != denptr;
tmptr = tmptr->clink);
tmptr->clink = denptr->clink;
}
/* remove from the ordered list */
if (dicptr->head == denptr) dicptr->head = denptr->flink;
if (dicptr->tail == denptr) dicptr->tail = denptr->blink;
if (denptr->flink != NULL) denptr->flink->blink = denptr->blink;
if (denptr->blink != NULL) denptr->blink->flink = denptr->flink;
/* if necessary adjust the iterator */
if (dicptr->next == denptr) dicptr->next = denptr->flink;
dicptr->count--;
dicptr->bytes -= denptr->bytes;
dicptr->dirty++;
/* for detecting any subsequent (re)insertion */
denptr->extract = dicptr->size;
return (denptr);
}
/*****************************************************************************/
/*
Insert the specified key and value into the specified dictionary. If the key
already exists then that entry will be removed and replaced with this one. If
the type has the DICT_TYPE_UNIQUE bit set then unique entries are created by
prefixing the key with a number 1..n and period (e.g. "10:example"). Generally
the digits and colon leading the supplied key need to be excised before use.
*/
DICT_ENTRY_STRUCT* DictInsert
(
DICT_STRUCT *dicptr,
uchar *type,
uchar *key,
int klen,
uchar *value,
int vlen
)
{
static char type2 [2];
static char KeyBuf [256];
static $DESCRIPTOR (KeyBufDsc, KeyBuf);
static $DESCRIPTOR (KeyFaoDsc, "!UL:!#AZ");
BOOL reuse;
int cnt, len;
ushort slen;
ulong bytes, hash;
uchar *cptr, *sptr, *zptr;
DICT_ENTRY_STRUCT *denptr, *tmptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"DictInsert() !&C !SL !#AZ = !SL !#AZ",
type[0], klen, klen, key, vlen, vlen, value);
/* cannot use an empty key */
if (klen == 0 || !key[0]) return (NULL);
if (vlen < 0)
{
for (cptr = value; *cptr; cptr++);
vlen = cptr - value;
}
/* buffer a type that's free of any potential "uniquifier bit" */
type2[0] = type[0] & ~DICT_TYPE_UNIQUE;
denptr = DictLookup (dicptr, type2, key, klen);
/* cannot use a silly (buggy?) sized key (allowing for enumeration) */
if ((klen = DictLookupKlen) > sizeof(KeyBuf)-8) return (NULL);
/* generated by DictLookup() no need to do it again */
hash = DictLookupHash;
if (denptr != NULL)
{
/* entry already exists */
if ((type[0] & DICT_TYPE_UNIQUE) &&
type2[0] != DICT_TYPE_OPAQUE_KEY)
{
/* enumerated (unique) entries */
sys$fao (&KeyFaoDsc, &slen, &KeyBufDsc, ++dicptr->unique, klen, key);
KeyBuf[slen] = '\0';
key = KeyBuf;
klen = slen;
/* compute the hash */
hash = type2[0];
for (cptr = key; slen--; cptr++) hash = hash * DICT_HASH_MULT + *cptr;
hash = hash % dicptr->size;
/* need a fresh one */
denptr = NULL;
reuse = false;
}
else
{
/* can the entry's value buffer be reused */
if (klen + vlen > denptr->bytes)
{
/* won't fit, expand using new value (just a little too clever) */
denptr->value = value;
denptr->vlen = vlen;
denptr = DictExpandEntry (denptr, (klen + vlen) - denptr->bytes);
return (denptr);
}
/* existing entry can contain the new value */
reuse = true;
}
}
/* if entry did not already exist allocate and initialise a fresh one */
if (denptr == NULL)
{
bytes = klen + vlen;
/* to (perhaps) improve memory management impose a minimum sized chunk */
if (bytes < DICT_MIN_BYTES) bytes = DICT_MIN_BYTES;
/* plus two terminating nulls and some "elbow-room" */
if (rqptr)
denptr = VmGetHeap (rqptr, sizeof(DICT_ENTRY_STRUCT) + bytes + 8);
else
denptr = VmGet (sizeof(DICT_ENTRY_STRUCT) + bytes + 8);
denptr->bytes = bytes;
denptr->hash = hash;
denptr->type[0] = type2[0];
denptr->DictPtr = dicptr;
denptr->klen = klen;
zptr = (sptr = denptr->key = denptr->buffer) + klen;
/* push key to lower-case! (no null required in zeroed memory) */
for (cptr = key; sptr < zptr; *sptr++ = TOLO(*cptr++));
reuse = false;
}
denptr->value = denptr->buffer + denptr->klen + 1;
/* if the value is NULL then just reserving space */
if (value == NULL)
denptr->vlen = 0;
else
{
zptr = (sptr = denptr->value) + (denptr->vlen = vlen);
for (cptr = value; sptr < zptr; *sptr++ = *cptr++);
/* in case a shorter value is being overwritten */
*sptr = '\0';
}
if (reuse)
dicptr->dirty++;
else
DictInsertEntry (dicptr, denptr);
return (denptr);
}
/*****************************************************************************/
/*
Insert the specified entry into the specified dictionary.
*/
DICT_ENTRY_STRUCT* DictInsertEntry
(
DICT_STRUCT *dicptr,
DICT_ENTRY_STRUCT *denptr
)
{
int len;
ulong hash;
uchar *cptr;
DICT_ENTRY_STRUCT *tmptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictInsertEntry()");
/* if extracted from a(nother) dictionary */
if (denptr->extract)
{
/* check that the memory belongs to the same environment */
if (dicptr->RequestPtr != denptr->DictPtr->RequestPtr)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
/* check if there's an existing entry and remove as required */
if (tmptr = DictLookup (dicptr, denptr->type, denptr->key, denptr->klen))
DictRemoveEntry (tmptr);
/* we've certainly done this! */
denptr->DictPtr = dicptr;
if (denptr->extract != dicptr->size);
{
/* need to recalculate the hash */
hash = denptr->type[0];
len = denptr->klen;
for (cptr = denptr->key; len--; cptr++)
hash = hash * DICT_HASH_MULT + *cptr;
denptr->hash = hash % dicptr->size;
}
/* reset the extraction indicator (size of original dictionary) */
denptr->extract = 0;
}
/* insert into the hash table / collision list */
hash = denptr->hash;
if (dicptr->table[hash] == NULL)
dicptr->table[hash] = denptr;
else
{
for (tmptr = dicptr->table[hash];
tmptr && tmptr->clink != NULL;
tmptr = tmptr->clink);
tmptr->clink = denptr;
}
/* in case it's been extracted from another dictionary */
denptr->clink = NULL;
/* append to the tail of the ordered list */
if (dicptr->head == NULL) dicptr->head = denptr;
if (dicptr->tail != NULL)
{
dicptr->tail->flink = denptr;
denptr->blink = dicptr->tail;
}
dicptr->tail = denptr;
/* in case it's been extracted from another dictionary */
denptr->flink = NULL;
dicptr->dirty++;
dicptr->count++;
dicptr->bytes += sizeof(DICT_ENTRY_STRUCT) + denptr->bytes;
return (denptr);
}
/*****************************************************************************/
/*
Iterate through dictionary entries. List is ordered first to last insertion.
Second parameter as NULL resets to head, "*" selects all, "<char>\0" those of
that type, and "<expression>\0" a string match. Return a pointer to the entry
or NULL on exhaustion or empty dictionary. On reset the returned pointer
should only be considered informational as to empty or not.
*/
DICT_ENTRY_STRUCT* DictIterate
(
DICT_STRUCT *dicptr,
uchar *which
)
{
DICT_ENTRY_STRUCT *denptr;
/*********/
/* begin */
/*********/
if (which != NULL)
{
while ((denptr = dicptr->next) != NULL)
{
dicptr->next = denptr->flink;
if (!which[0] || MATCH2 (which, "*")) break;
if (which[0] && !which[1])
if (denptr->type[0] == which[0])
break;
else
continue;
if (StringMatch (NULL, denptr->key, which)) break;
}
return (denptr);
}
/* reset to start */
return (dicptr->next = dicptr->head);
}
/*****************************************************************************/
/*
Look in the specified dictionary for the specified key. If key length is -1
then assume key is null-terminated string, otherwise some other opaque blob.
String key matching is case-insensitive. Lookup includes the entry type.
Return a pointer to the dictionary item found or NULL if not.
*/
DICT_ENTRY_STRUCT* DictLookup
(
DICT_STRUCT *dicptr,
uchar *type,
uchar *key,
int klen
)
{
uint len;
ulong hash;
uchar *cptr, *sptr, *zptr;
DICT_ENTRY_STRUCT *denptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"DictLookup() !&C !SL !#AZ", type[0], klen, klen, key);
/* cannot use an empty key */
if (klen == 0 || (klen < 0 && !key[0])) return (NULL);
/* make the type character part of the hash */
hash = type[0];
if (klen < 0)
{
for (cptr = key; *cptr; cptr++) hash = hash * DICT_HASH_MULT + *cptr;
klen = cptr - key;
}
else
{
len = klen;
for (cptr = key; len--; cptr++) hash = hash * DICT_HASH_MULT + *cptr;
}
hash = hash % dicptr->size;
/* save these so that they don't need to be generated again */
DictLookupHash = hash;
DictLookupKlen = klen;
zptr = key + klen;
for (denptr = dicptr->table[hash]; denptr != NULL; denptr = denptr->clink)
{
if (denptr->type[0] != type[0]) continue;
if (denptr->klen != klen) continue;
cptr = key;
sptr = denptr->key;
if (denptr->type[0] == DICT_TYPE_OPAQUE_KEY)
while (cptr < zptr && *cptr == *sptr) { cptr++; sptr++; }
else
/* all keys are pushed to lower-case on insertion */
while (cptr < zptr && TOLO(*cptr) == *sptr) { cptr++; sptr++; }
if (cptr == zptr && sptr == denptr->key + denptr->klen) break;
}
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "denptr:!&X", denptr);
return (denptr);
}
/*****************************************************************************/
/*
Delete the specified key from the dictionary. Returns NULL if the key was not
found or a pointer to the entry if the key was found. The pointer is
informational and must not subsequently be accessed.
*/
DICT_ENTRY_STRUCT* DictRemove
(
DICT_STRUCT *dicptr,
uchar *type,
uchar *key,
int klen
)
{
uint hash;
DICT_ENTRY_STRUCT *denptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER,
"DictRemove() !AZ !&Z", type, key);
if ((denptr = DictLookup (dicptr, type, key, klen)) == NULL) return (NULL);
DictExtractEntry (denptr);
if (rqptr)
VmFreeFromHeap (rqptr, denptr, FI_LI);
else
VmFree (denptr, FI_LI);
return (denptr);
}
/*****************************************************************************/
/*
Delete the specified entry from the dictionary. Returns the freed pointer,
which is informational and must not subsequently be accessed.
*/
DICT_ENTRY_STRUCT* DictRemoveEntry (DICT_ENTRY_STRUCT *denptr)
{
DICT_STRUCT *dicptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
dicptr = denptr->DictPtr;
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictRemoveEntry()");
DictExtractEntry (denptr);
if (rqptr)
VmFreeFromHeap (rqptr, denptr, FI_LI);
else
VmFree (denptr, FI_LI);
return (denptr);
}
/*****************************************************************************/
/*
Set the value length of the specified entry. Check the size is within the
storage allocated. Adjustments to the value string can be made (within
constraints) because it's stored at the trailing end of the buffer space
following the key.
*/
void DictValueLength
(
DICT_ENTRY_STRUCT *denptr,
uint length
)
{
DICT_STRUCT *dicptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
dicptr = denptr->DictPtr;
rqptr = dicptr->RequestPtr;
if (WATCHMOD (rqptr, WATCH_MOD__OTHER))
WatchThis (WATCHITM(rqptr), WATCH_MOD__OTHER, "DictValueLength()");
if (denptr->klen + length > denptr->bytes)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
denptr->vlen = length;
}
/*****************************************************************************/
/*
WATCH the contents of the dictionary. If |which| is NULL all entries are
reported. If |which| is a single character string then it should be an entry
type character and only matching entries are reported. If |which| is a string
beginning and entry type character and followed by a key string then report
only that entry.
*/
void DictWatch
(
DICT_STRUCT *dicptr,
uchar *type,
uchar *which
)
{
char *cptr;
DICT_ENTRY_STRUCT *denptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
rqptr = dicptr->RequestPtr;
if (which == NULL || (type == NULL && which[0] == '*'))
{
WatchThis (WATCHITM(rqptr), WATCH_INTERNAL,
"DICTIONARY size:!UL count:!UL bytes:!UL",
dicptr->size, dicptr->count, dicptr->bytes);
DictWatchEntry (NULL);
}
if (which && which[1])
{
if (type == NULL) type = DICT_TYPE_INTERNAL;
denptr = DictLookup (rqptr->rqDictPtr, type, which, -1);
if (denptr != NULL) DictWatchEntry (denptr);
return;
}
for (denptr = dicptr->head; denptr != NULL; denptr = denptr->flink)
if (which == NULL || type == NULL || type[0] == denptr->type[0])
DictWatchEntry (denptr);
}
/*****************************************************************************/
/*
WATCH the specified entry. Entry pointer as NULL resets the counter.
*/
void DictWatchEntry (DICT_ENTRY_STRUCT *denptr)
{
static int count = 0;
char *cptr, *sptr;
DICT_STRUCT *dicptr;
/*********/
/* begin */
/*********/
if (denptr == NULL)
{
count = 0;
return;
}
dicptr = denptr->DictPtr;
if (denptr == dicptr->table[denptr->hash])
cptr = "[]";
else
cptr = "..";
if (denptr->type[0] == DICT_TYPE_OPAQUE ||
denptr->type[0] == DICT_TYPE_OPAQUE_KEY)
WatchDataFormatted ("ENTRY !3ZL !&C!3ZL!&C !&C {!UL}!-!#&H={!UL}!-!#&H\n",
++count, cptr[0], denptr->hash, cptr[1],
denptr->type[0], denptr->klen, denptr->key,
denptr->vlen, denptr->value);
else
{
if (denptr->vlen && denptr->value[denptr->vlen-1] == '\n')
sptr = "";
else
sptr = "\n";
WatchDataFormatted ("ENTRY !3ZL !&C!3ZL!&C !&C {!UL}!-!#AZ={!UL}!-!#AZ!AZ",
++count, cptr[0], denptr->hash, cptr[1],
denptr->type[0], denptr->klen, denptr->key,
denptr->vlen, denptr->value, sptr);
}
}
/*****************************************************************************/
/*
Exercise the dictionary functions. Provide some indicative timings.
fname=<filename> should be a list of words such as found at:
https://raw.githubusercontent.com/first20hours/google-10000-english/master/20k.txt
Some results on an Alpha PWS500 OpenVMS V8.3.
$! 8 hash, 1,000 additions results in a rate of 85k insertions/sec
$ httpd /tests dictionary=size=8,count=10000,fname=20kwords.txt
8< snip 8<
size:8 count:1000 max:0 min:0
total:1000 klen0:62 failures:62 duplicates:53 expands:32 deletions:0 duration:0.011718 85338.797/sec 0.000012/each
table:[0]100 [1]99 [2]123 [3]119 [4]108 [5]109 [6]114 [7]103
$! 16 hash, 1,000 additions results in 102k insertions/sec
$ httpd /tests dictionary=size=16,count=10000,fname=20kwords.txt
8< snip 8<
size:16 count:1000 max:0 min:0
total:1000 klen0:57 failures:57 duplicates:52 expands:49 deletions:0 duration:0.009765 102406.555/sec 0.000010/each
table:[0]57 [1]59 [2]61 [3]55 [4]48 [5]67 [6]51 [7]57 [8]56 [9]52 [10]44 [11]67 [12]51 [13]63 [14]39 [15]51
$! 32 hash, 100 additions, results in 114k insertions/sec
$ httpd /tests dictionary=size=32,count=1000,fname=20kwords.txt
8< snip 8<
size:32 count:1000 max:0 min:0
total:1000 klen0:58 failures:58 duplicates:46 expands:46 deletions:0 duration:0.008788 113785.062/sec 0.000009/each
table:[0]28 [1]37 [2]25 [3]23 [4]30 [5]32 [6]31 [7]23 [8]30 [9]26 [10]28 [11]23 [12]25 [13]29 [14]27 [15]27 [16]28 [17]25 [18]27
[19]34 [20]30 [21]33 [22]19 [23]29 [24]25 [25]29 [26]27 [27]30 [28]22 [29]22 [30]35 [31]28
$! 64 hash, 100 additions, results in 114k insertions/sec
$ httpd /tests dictionary=size=32,count=1000,fname=20kwords.txt
8< snip 8<
size:64 count:1000 max:0 min:0
total:1000 klen0:60 failures:60 duplicates:51 expands:39 deletions:0 duration:0.008788 113785.062/sec 0.000009/each
table:[0]14 [1]12 [2]13 [3]20 [4]17 [5]12 [6]14 [7]12 [8]13 [9]13 [10]16 [11]10 [12]11 [13]20 [14]13 [15]16 [16]14 [17]12 [18]10
[19]14 [20]16 [21]15 [22]16 [23]8 [24]15 [25]9 [26]15 [27]10 [28]11 [29]14 [30]9 [31]11 [32]10 [33]16 [34]9 [35]13 [36]10 [37]15
[38]12 [39]15 [40]5 [41]17 [42]14 [43]13 [44]21 [45]20 [46]18 [47]20 [48]17 [49]12 [50]16 [51]12 [52]10 [53]14 [54]12 [55]14
[56]12 [57]17 [58]15 [59]18 [60]13 [61]17 [62]16 [63]13
*/
#if WATCH_MOD
void DictTest (char *cliptr)
{
#define KEY_SIZE 31
#define KEY_VARY(ran) (ran & 0x1f)
#define VALUE_SIZE 127
#define VALUE_VARY(ran) (ran & 0x7f)
#include <stat.h>
#include <errno.h>
int count, deletions, duplicates, expands, failures,
klen, klen0, max, min, size, status, total, vlen;
int64 random,
DeltaTime64,
NowTime64,
ThenTime64;
uchar ch;
uchar *bptr, *cptr, *fname, *sptr, *wptr, *zptr;
uchar key [KEY_SIZE+1],
value [VALUE_SIZE+1];
float fsecs;
stat_t statbuf;
FILE *fptr;
DICT_STRUCT *dicptr;
DICT_ENTRY_STRUCT *denptr;
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
for (cptr = cliptr; *cptr; cptr++) *cptr = tolower(*cptr);
size = 0;
cptr = strstr (cliptr, "size=");
if (cptr) size = atoi(cptr+5);
if (size <= 0) size = DICT_DEFAULT_SIZE;
count = 0;
cptr = strstr (cliptr, "count=");
if (cptr) count = atoi(cptr+6);
if (count <= 0) count = size * 10;
/* maximum number of entries before a deletion cycle */
max = 0;
cptr = strstr (cliptr, "max=");
if (cptr) max = atoi(cptr+4);
/* minimum number of entries at end of delete cycle */
min = 0;
cptr = strstr (cliptr, "min=");
if (cptr) min = atoi(cptr+4);
if (min < 0) min = 32;
if (max < min) max = min * 2;
cptr = strstr (cliptr, "fname=");
if (cptr) fname = cptr+6;
/* read in the file of strings */
if (stat (fname, &statbuf) < 0) exit (vaxc$errno);
if ((fptr = fopen (fname, "r")) == NULL) exit (vaxc$errno);
bptr = calloc (1, statbuf.st_size);
if ((wptr = bptr) == NULL) exit (vaxc$errno);
while (fgets (wptr, 256, fptr) != NULL)
{
while (*wptr && *wptr != '\n') wptr++;
*wptr++ = ' ';
*wptr = '\0';
}
fclose (fptr);
if (!*bptr) exit (SS$_ABORT);
VmRequestInit ();
rqptr = VmGetRequest (999999999);
if (Watch.CliEnabled)
{
Watch.Category = Watch.Module = -1;
WatchSetWatch (rqptr, WATCH_NEW_ITEM);
}
dicptr = DictCreate (rqptr, size);
sys$gettim (&ThenTime64);
random = ThenTime64 & (ThenTime64 << 40);
deletions = duplicates = expands = failures = klen0 = 0;
for (total = 0; total < count; total++)
{
random = random * 69069 + 1;
/* ensure 5% (or so) are duplicate keys to exercise that aspect */
if (random % 21)
{
zptr = sptr = key;
zptr += KEY_VARY(random) - 1; /* vary size */
while (sptr < zptr)
{
if (!*wptr) wptr = bptr;
*sptr++ = *wptr++;
}
*sptr = '\0';
klen = sptr - key;
}
else
duplicates++;
/* generate random value */
random = random * 69069 + 1;
zptr = sptr = value;
zptr += VALUE_VARY(random) - 1; /* vary size */
while (sptr < zptr)
{
if (!*wptr) wptr = bptr;
*sptr++ = *wptr++;
}
*sptr = '\0';
vlen = sptr - value;
/* insert the key into the dictionary either of the two calls */
if (random % 2)
denptr = DictInsert (dicptr, DICT_TYPE_INTERNAL, key, -1, value, -1);
else
denptr = DictInsert (dicptr, DICT_TYPE_INTERNAL, key, klen, value, vlen);
/* a zero length key should fail */
if (denptr == NULL) failures++;
if (klen == 0) klen0++;
/* ensure another small percentage are expanded by 100% */
if ((random % 21) == 0)
if (denptr != NULL)
{
DictExpandEntry (denptr, DICT_GET_BYTES(denptr) * 2);
expands++;
}
/* if no deletion cycle */
if (!(max && min))
if (total < count)
continue;
else
break;
if (dicptr->count > max || total >= count)
{
DictIterate (dicptr, NULL);
while (dicptr->count > min)
{
/* trim back down to min by choosing entries at random */
random = random * 69069 + 1;
for (int cnt = (random & 0xf) + 1; cnt; cnt--)
{
while (denptr = DictIterate (dicptr, "*"));
if (denptr) break;
if ((denptr = DictIterate (dicptr, NULL)) == NULL) break;
}
if (denptr == NULL) break;
if (dicptr->count % 2)
DictRemove (dicptr, DICT_TYPE_INTERNAL, denptr->key, -1);
else
DictRemove (dicptr, DICT_TYPE_INTERNAL,
denptr->key, denptr->klen);
deletions++;
}
if (denptr == NULL) break;
}
if (denptr == NULL) break;
}
sys$gettim (&NowTime64);
DeltaTime64 = ThenTime64 - NowTime64;
fsecs = FloatDeltaTime (&DeltaTime64);
Watch.StdoutOnly = true;
Watch.Category = WATCH_INTERNAL;
DictWatch (dicptr, NULL, NULL);
fprintf (stdout,
"size:%d count:%d max:%d min:%d\n\
total:%d klen0:%d failures:%d duplicates:%d expands:%d deletions:%d \
duration:%s %3.3f/sec %f/each\n",
size, count, max, min,
total, klen0, failures, duplicates, expands, deletions,
DurationString (rqptr, &DeltaTime64),
(float)total/fsecs, fsecs/(float)total);
fputs ("table:", stdout);
for (int idx = 0; idx < dicptr->size; idx++)
{
int cnt = 0;
for (denptr = dicptr->table[idx]; denptr != NULL; denptr = denptr->clink)
cnt++;
fprintf (stdout, "[%d]%d ", idx, cnt);
}
fputs ("\n", stdout);
DictDestroy (dicptr);
}
#endif /* WATCH_MOD */
/*****************************************************************************/