static
Vuln_t *locate_identifier(char *identifier)
{
Vuln_t * data = NULL;
if (ratslexer.langhash)
data = (Vuln_t *)HashGet(ratslexer.langhash, identifier);
if ((data == NULL) && defaultdb)
data = (Vuln_t *)HashGet(defaultdb, identifier);
return data;
}
const
#endif
char *HashGetName (int hashId)
{
#ifdef TC_WINDOWS_BOOT
return HashGet(hashId) -> Name;
#else
Hash* pHash = HashGet(hashId);
return pHash? pHash -> Name : "";
#endif
}
void PrintObject(CLOSURE* context)
{
VALUE key;
key.type = VAL_REFERENCE;
key.data.reference = context;
// check for recursion
if (HashGet(key, duck_print_records).type != VAL_NIL) {
printf("...");
return;
} else {
VALUE value;
value.type = VAL_PRIMITIVE;
value.data.primitive = 1;
HashStore(key, value, duck_print_records);
}
printf("[");
PAIR* list = context->list;
while (list)
{
PrintValue(list->value);
if (list->next)
printf(", ");
list = list->next;
}
printf("]");
}
void PrintDictionaryString(char** string, unsigned int* size, HASH_TABLE* dictionary)
{
VALUE key;
unsigned int i, dictionary_size;
dictionary_size = dictionary->size;
key.type = VAL_DICTIONARY;
key.data.dictionary = dictionary;
// check for recursion
if (HashGet(key, duck_print_records).type != VAL_NIL) {
PrintString(string, size, "...");
return;
} else {
VALUE value;
value.type = VAL_PRIMITIVE;
value.data.primitive = 1;
HashStore(key, value, duck_print_records);
}
PrintString(string, size, "[");
for (i = 0; i < dictionary->capacity; i++)
{
if (dictionary->table[i].key.type != VAL_NIL)
{
dictionary_size--;
PrintValueString(string, size, dictionary->table[i].key);
PrintString(string, size, ": ");
PrintValueString(string, size, dictionary->table[i].value);
if (dictionary_size) { PrintString(string, size, ", "); }
}
}
PrintString(string, size, "]");
}
void PrintObjectString(char** dest, unsigned int* size, CLOSURE* context)
{
VALUE key;
key.type = VAL_REFERENCE;
key.data.reference = context;
// check for recursion
if (HashGet(key, duck_print_records).type != VAL_NIL) {
PrintString(dest, size, "...");
return;
} else {
VALUE value;
value.type = VAL_PRIMITIVE;
value.data.primitive = 1;
HashStore(key, value, duck_print_records);
}
PrintString(dest, size, "[");
PAIR* list = context->list;
while (list)
{
PrintValueString(dest, size, list->value);
if (list->next) {
PrintString(dest, size, ", ");
}
list = list->next;
}
PrintString(dest, size, "]");
}
int main()
{
Hash *h = HashCreateN(1024);
HashSet(h, (String) { "abc", 3 }, "def");
printf("%s\n", (char*) HashGet(h, (String) { GC_STRDUP("abc"), 3 }));
}
static uint LookupAnswer(Hash const H, const uint x)
{
Thing wx = Word(x);
Thing ans = HashGet(H, wx);
//if (ans) printf("Found answer!\n");
return((ans) ? (uint)IntWord(ans) : 0);
}
void PrintDictionary(HASH_TABLE* dictionary)
{
unsigned int i, size;
size = dictionary->size;
VALUE key;
key.type = VAL_DICTIONARY;
key.data.dictionary = dictionary;
// check for recursion
if (HashGet(key, duck_print_records).type != VAL_NIL) {
printf("...");
return;
} else {
VALUE value;
value.type = VAL_PRIMITIVE;
value.data.primitive = 1;
HashStore(key, value, duck_print_records);
}
printf("[");
for (i = 0; i < dictionary->capacity; i++)
{
if (dictionary->table[i].key.type != VAL_NIL)
{
size--;
PrintValue(dictionary->table[i].key);
printf(": ");
PrintValue(dictionary->table[i].value);
if (size) printf(", ");
}
}
printf("]");
}
int Ardb::HIncrbyFloat(Context& ctx, RedisCommandFrame& cmd)
{
double increment, val = 0;
if (!GetDoubleValue(ctx, cmd.GetArguments()[2], increment))
{
return 0;
}
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
Data value;
Data field(cmd.GetArguments()[1]);
if (0 == err)
{
HashGet(ctx, meta, field, value);
if (!value.GetDouble(val))
{
fill_error_reply(ctx.reply, "value is not a float or out of range");
return 0;
}
}
val += increment;
std::string tmp;
fast_dtoa(val, 10, tmp);
value.SetString(tmp, false);
HashSet(ctx, meta, field, value);
fill_str_reply(ctx.reply, tmp);
return 0;
}
int Ardb::HIncrby(Context& ctx, RedisCommandFrame& cmd)
{
int64 increment, val = 0;
if (!GetInt64Value(ctx, cmd.GetArguments()[2], increment))
{
return 0;
}
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
Data field(cmd.GetArguments()[1]);
Data value;
if (err == 0)
{
err = HashGet(ctx, meta, field, value);
}
if (err == ERR_NOT_EXIST)
{
value.SetInt64(increment);
}
else
{
if (!value.GetInt64(val))
{
fill_error_reply(ctx.reply, "value is not a integer or out of range");
return 0;
}
value.SetInt64(val + increment);
}
HashSet(ctx, meta, field, value);
fill_int_reply(ctx.reply, val + increment);
return 0;
}
int Ardb::HMGet(Context& ctx, RedisCommandFrame& cmd)
{
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
ctx.reply.type = REDIS_REPLY_ARRAY;
if (err == 0)
{
for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
{
Data value;
Data field(cmd.GetArguments()[i]);
RedisReply& r = ctx.reply.AddMember();
if (0 == HashGet(ctx, meta, field, value))
{
r.type = REDIS_REPLY_STRING;
value.GetDecodeString(r.str);
}
else
{
r.type = REDIS_REPLY_NIL;
}
}
}
else
{
ctx.reply.ReserveMember(cmd.GetArguments().size());
}
return 0;
}
void TestHash()
{
Thing key = Word(7);
Thing item = Word(11);
Thing X, Y;
CommentLine("Testing Hashtable");
Hash H = NewHash(NULL);
HashIns(H, key, item);
//BAD CODE: if (IntWord(HashGet(H, key)) != 11)
//{ printf("no match!\n"); }
//HashGet can return NULL!
X = HashGet(H, key);
assert(X);
assert(SameThing(X, item));
if (ThingCmp(X, item) != EQ) printf("error in retr hash");
Y = HashRm(H, key);
assert(SameThing(Y, item));
assert(SameThing(X, Y));
DelThing(X);
X = HashRm(H, key);
assert(X == NULL);
DelHash(H);
//asm("int3");
DelThing(Y); // this calls the dtor on item
DelThing(key);
printf("Basic insert/retrieve in hash table done.\n");
}
void HashGetName2 (char *buf, int hashId)
{
Hash* pHash = HashGet(hashId);
if (pHash)
strcpy(buf, pHash -> Name);
else
buf[0] = '\0';
}
//==============================================================
static sParam *objGetParam(char *id_str)
//--------------------------------------------------------------
// パラメータを取得
//--------------------------------------------------------------
// in: id_str = 識別子
//--------------------------------------------------------------
// out: データポインタ(NULL = データ無し)
//==============================================================
{
return (sParam *)HashGet(param_hash, id_str);
}
void setup_perl(FILE *fd)
{
yyperlin = fd;
ratslexer.lex_column = &perllex_column;
ratslexer.yytext = &yyperltext;
ratslexer.yyin = fd;
ratslexer.yylex = yyperllex;
ratslexer.yycomment = &yyperlcomment;
ratslexer.lex_lineno = &perllex_lineno;
ratslexer.langhash = (Hash)HashGet(database, "perl");
ratslexer.lang = LANG_PERL;
}
void setup_python(FILE *fd)
{
yypin = fd;
ratslexer.yytext = &yyptext;
ratslexer.yyin = fd;
ratslexer.yylex = yyplex;
ratslexer.yycomment = &yypcomment;
ratslexer.lex_lineno = &plex_lineno;
ratslexer.langhash = (Hash)HashGet(database, "python");
ratslexer.lex_column = &plex_column;
ratslexer.lang = LANG_PYTHON;
}
void setup_c(FILE *fd)
{
yycin = fd;
ratslexer.yytext = &yyctext;
ratslexer.yyin = fd;
ratslexer.yylex = yyclex;
ratslexer.yycomment = &yyccomment;
ratslexer.lex_lineno = &clex_lineno;
ratslexer.langhash = (Hash)HashGet(database, "c");
ratslexer.lex_column = &clex_column;
ratslexer.lang = LANG_C;
}
void setup_php(FILE *fd)
{
yyphpin = fd;
ratslexer.yytext = &yyphptext;
ratslexer.yyin = fd;
ratslexer.yylex = yyphplex;
ratslexer.yycomment = &yyphpcomment;
ratslexer.lex_lineno = &phplex_lineno;
ratslexer.langhash = (Hash)HashGet(database, "php");
ratslexer.lex_column = &phplex_column;
ratslexer.lang = LANG_PHP;
}
void setup_ruby(FILE *fd)
{
yyrubyin = fd;
ratslexer.yytext = &yyrubytext;
ratslexer.yyin = fd;
ratslexer.yylex = yyrubylex;
ratslexer.yycomment = &yyrubycomment;
ratslexer.lex_lineno = &rubylex_lineno;
ratslexer.langhash = (Hash)HashGet(database, "ruby");
ratslexer.lex_column = &rubylex_column;
ratslexer.lang = LANG_RUBY;
}
int Ardb::HDel(Context& ctx, RedisCommandFrame& cmd)
{
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
int count = 0;
if (err == 0)
{
BatchWriteGuard guard(GetKeyValueEngine());
for (uint32 i = 1; i < cmd.GetArguments().size(); i++)
{
Data field(cmd.GetArguments()[i]);
Data value;
err = HashGet(ctx, meta, field, value);
if (err == 0)
{
if (meta.meta.encoding != COLLECTION_ECODING_ZIPMAP)
{
KeyObject k;
k.db = ctx.currentDB;
k.key = cmd.GetArguments()[0];
k.type = HASH_FIELD;
k.element = field;
DelKeyValue(ctx, k);
if (meta.meta.len > 0)
{
meta.meta.len--;
}
}
else
{
meta.meta.zipmap.erase(field);
}
count++;
}
}
if (count > 0)
{
if (meta.meta.Length() != 0)
{
SetKeyValue(ctx, meta);
}
else
{
DelKeyValue(ctx, meta.key);
}
}
}
fill_int_reply(ctx.reply, count);
return 0;
}
static Object symbolFromCString(string str) {
Object oString = makeStringFromCString(str);
Object obj = HashGet(symbol_table, oString);
if (!obj) {
obj = malloc(sizeof(sObject));
obj->type = SYMBOL;
obj->value.stringValue = str;
obj->print = &printSymbol;
obj->eval = &evalSymbol;
HashSet(symbol_table, oString, obj);
}
return obj;
}
int Ardb::HMIncrby(Context& ctx, RedisCommandFrame& cmd)
{
if ((cmd.GetArguments().size() - 1) % 2 != 0)
{
fill_error_reply(ctx.reply, "wrong number of arguments for HMIncrby");
return 0;
}
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
ctx.reply.type = REDIS_REPLY_ARRAY;
DataMap fs;
Int64Array vs;
for (uint32 i = 1; i < cmd.GetArguments().size(); i += 2)
{
int64 inc = 0;
if (!GetInt64Value(ctx, cmd.GetArguments()[i + 1], inc))
{
return 0;
}
Data field(cmd.GetArguments()[i]);
if (err == ERR_NOT_EXIST)
{
fs[field].SetInt64(inc);
vs.push_back(inc);
}
else
{
Data value;
HashGet(ctx, meta, field, value);
int64 val = 0;
if (!value.GetInt64(val))
{
fill_error_reply(ctx.reply, "value is not a float or out of range");
return 0;
}
fs[field].SetInt64(inc + val);
vs.push_back(inc + val);
}
}
HashMultiSet(ctx, meta, fs);
fill_int_array_reply(ctx.reply, vs);
return 0;
}
int Ardb::HashGet(Context& ctx, const std::string& key, const std::string& field, Data& v)
{
ValueObject meta;
int err = GetMetaValue(ctx, key, HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
Data f;
f.SetString(field, true);
err = HashGet(ctx, meta, f, v);
if (err == ERR_NOT_EXIST)
{
ctx.reply.type = REDIS_REPLY_NIL;
}
else
{
ctx.reply.type = REDIS_REPLY_STRING;
v.GetDecodeString(ctx.reply.str);
}
return 0;
}
int Ardb::HSetNX(Context& ctx, RedisCommandFrame& cmd)
{
ValueObject meta;
int err = GetMetaValue(ctx, cmd.GetArguments()[0], HASH_META, meta);
CHECK_ARDB_RETURN_VALUE(ctx.reply, err);
Data value;
Data field(cmd.GetArguments()[1]);
err = HashGet(ctx, meta, field, value);
if (err == ERR_NOT_EXIST)
{
value.SetString(cmd.GetArguments()[2], true);
HashSet(ctx, meta, field, value);
err = 1;
}
else
{
err = 0;
}
fill_int_reply(ctx.reply, err);
return 0;
}
//==============================================================
sParam *ObjSetup(char *id_str)
//--------------------------------------------------------------
// オブジェクトのセットアップ
// ※同じ名前が存在する場合、読み込み直す
//--------------------------------------------------------------
// in: id_str = 識別子
//--------------------------------------------------------------
// out: 読み込んだパラメータ
//==============================================================
{
char file[FNAME_MAXLEN];
sParam *param;
param = (sParam *)HashGet(param_hash, id_str);
if(param) ParamDestroy(param);
sprintf(file, OBJ_FILE_PATH"/%s.param", id_str);
param = ParamRead(file);
HashAdd(param_hash, id_str, param);
return param;
}
BOOL HashForSystemEncryption (int hashId)
{
Hash* pHash = HashGet(hashId);
return pHash? pHash -> SystemEncryption : FALSE;
}
BOOL HashIsDeprecated (int hashId)
{
return HashGet (hashId) -> Deprecated;
}
char *HashGetName (int hashId)
{
return HashGet (hashId) -> Name;
}
int Ardb::HGet(Context& ctx, RedisCommandFrame& cmd)
{
Data v;
HashGet(ctx, cmd.GetArguments()[0], cmd.GetArguments()[1], v);
return 0;
}
BOOL HashIsDeprecated (int hashId)
{
Hash* pHash = HashGet(hashId);
return pHash? pHash -> Deprecated : FALSE;
}
