void HashratSignFile(char *Path, HashratCtx *Ctx)
{
STREAM *S;
char *Tempstr=NULL, *HashStr=NULL;
double pos;
THash *Hash;
S=STREAMOpenFile(Path, SF_RDWR);
if (! S) return;
Hash=HashInit(Ctx->HashType);
HashratFinishHash(&HashStr, Ctx, Hash);
pos=STREAMSeek(S,0,SEEK_END);
Tempstr=MCopyStr(Tempstr,"hashrat-placeholder---: ",GetDateStr("%Y/%m/%d %H:%M:%S",NULL)," ",Ctx->HashType,":", HashStr,"\n",NULL);
STREAMWriteLine(Tempstr,S);
STREAMFlush(S);
STREAMSeek(S,0,SEEK_SET);
Hash=HashInit(Ctx->HashType);
HashratHashFile(Ctx, Hash, FT_FILE, Path, (off_t) pos);
HashratFinishHash(&HashStr, Ctx, Hash);
Tempstr=MCopyStr(Tempstr,"hashrat-integrity-mark: ",GetDateStr("%Y/%m/%d %H:%M:%S",NULL)," ",Ctx->HashType,":", HashStr,"\n",NULL);
STREAMSeek(S,pos,SEEK_SET);
STREAMWriteLine(Tempstr,S);
STREAMFlush(S);
DestroyString(Tempstr);
DestroyString(HashStr);
}
void
Y_set_vars(int nArgs)
{
Symbol *stack = sp - nArgs + 1;
IOStream *file, *child;
char **vars, **rvars;
long i, nvars, nrvars;
Dimension *dims;
if (nArgs<2 || nArgs>3 || !stack[0].ops || !stack[1].ops)
YError("set_vars takes exactly two or three arguments");
file = YGetFile(stack++);
child = file->history? file->history->child : 0;
vars = YGet_Q(stack++, 1, &dims);
nvars = (vars&&dims)? (dims->next? -1 : dims->number) : 0;
if (nArgs==3) {
rvars = YGet_Q(stack++, 1, &dims);
nrvars = (vars&&dims)? (dims->next? -1 : dims->number) : 0;
} else {
rvars = 0;
nrvars = 0;
}
if (nvars<0 || nrvars<0) YError("set_vars var lists must be 1D");
if ((nvars && nvars!=file->dataTable.nItems) ||
(nrvars && nrvars!=(child? child->dataTable.nItems : 0)))
YError("set_vars var lists must match number of vars in file");
if (nvars) {
HashTable tmp;
y_hashtmp *h = y_new_tmpobj(sizeof(y_hashtmp), y_zap_hashtmp);
HashInit(&h->table, nvars);
PushDataBlock(h);
for (i=0 ; i<nvars ; i++)
if (HashAdd(&h->table, vars[i], 0)) break;
if (i<nvars) YError("duplicate names in set_vars static var list");
if (p_signalling) p_abort();
tmp = h->table;
h->table = file->dataTable;
file->dataTable = tmp;
Drop(1);
}
if (nrvars) {
HashTable tmp;
y_hashtmp *h = y_new_tmpobj(sizeof(y_hashtmp), y_zap_hashtmp);
HashInit(&h->table, nvars);
PushDataBlock(h);
for (i=0 ; i<nrvars ; i++)
if (HashAdd(&h->table, rvars[i], 0)) break;
if (i<nrvars) YError("duplicate names in set_vars record var list");
if (p_signalling) p_abort();
tmp = h->table;
h->table = child->dataTable;
child->dataTable = tmp;
Drop(1);
}
}
void
EFInit()
{
EFLayerNumNames = 1;
EFDevNumTypes = 0;
EFCompat = TRUE;
HashInit(&efFreeHashTable, 32, HT_WORDKEYS);
HashInit(&efDefHashTable, INITDEFSIZE, 0);
HashInit(&efDevParamTable, 8, HT_STRINGKEYS);
efSymInit();
}
void HMACInit(HASH *Hash)
{
Hash->Ctx=(void *) HashInit(Hash->Type+5);
Hash->Update=HMACPrepare;
Hash->Finish=HMACFinish;
}
void NewScope(const char *name)
/*
* Thread safe
*/
{
Scope *ptr;
CfDebug("Adding scope data %s\n", name);
if (!ThreadLock(cft_vscope))
{
CfOut(cf_error, "", "!! Could not lock VSCOPE");
return;
}
for (ptr = VSCOPE; ptr != NULL; ptr = ptr->next)
{
if (strcmp(ptr->scope, name) == 0)
{
ThreadUnlock(cft_vscope);
CfDebug("SCOPE Object %s already exists\n", name);
return;
}
}
ptr = xcalloc(1, sizeof(Scope));
ptr->next = VSCOPE;
ptr->scope = xstrdup(name);
ptr->hashtable = HashInit();
VSCOPE = ptr;
ThreadUnlock(cft_vscope);
}
int HashFile(char **Return, const char *Type, const char *Path, int Encoding)
{
HASH *Hash;
STREAM *S;
char *Tempstr=NULL;
int result;
S=STREAMOpen(Path,"r");
if (! S) return(FALSE);
Hash=HashInit(Type);
if (! Hash)
{
STREAMClose(S);
return(FALSE);
}
Tempstr=SetStrLen(Tempstr,4096);
result=STREAMReadBytes(S,Tempstr,4096);
while (result !=EOF)
{
Hash->Update(Hash, Tempstr, result);
result=STREAMReadBytes(S,Tempstr,4096);
}
DestroyString(Tempstr);
STREAMClose(S);
result=HashFinish(Hash, Encoding, Return);
return(result);
}
Scope *ScopeNew(const char *name)
{
Scope *ptr;
if (!ThreadLock(cft_vscope))
{
Log(LOG_LEVEL_ERR, "Could not lock VSCOPE");
return NULL;
}
for (ptr = VSCOPE; ptr != NULL; ptr = ptr->next)
{
if (strcmp(ptr->scope, name) == 0)
{
ThreadUnlock(cft_vscope);
return NULL;
}
}
ptr = xcalloc(1, sizeof(Scope));
ptr->next = VSCOPE;
ptr->scope = xstrdup(name);
ptr->hashtable = HashInit();
VSCOPE = ptr;
ThreadUnlock(cft_vscope);
return ptr;
}
void ScopeClear(const char *ns, const char *name)
{
assert(name);
assert(!ScopeIsReserved(name));
if (!ns)
{
ns = "default";
}
if (!ThreadLock(cft_vscope))
{
Log(LOG_LEVEL_ERR, "Could not lock VSCOPE");
return;
}
Scope *scope = ScopeGet(ns, name);
if (!scope)
{
Log(LOG_LEVEL_DEBUG, "No scope '%s' to clear", name);
ThreadUnlock(cft_vscope);
return;
}
HashFree(scope->hashtable);
scope->hashtable = HashInit();
Log(LOG_LEVEL_DEBUG, "Scope '%s' cleared", name);
ThreadUnlock(cft_vscope);
}
int HashratCheckSignedFile(char *Path, HashratCtx *Ctx)
{
STREAM *S;
char *Tempstr=NULL, *HashStr=NULL;
THash *Hash, *tmpHash;
int LineCount=0;
S=STREAMOpenFile(Path, SF_RDWR);
if (! S) return(FALSE);
Hash=HashInit(Ctx->HashType);
Tempstr=STREAMReadLine(Tempstr, S);
while (Tempstr)
{
LineCount++;
//hashrat-integrity-mark: 2014/10/29 21:05:19 md5:nTnlHmvVowFowmxXtm0uNw==
if (strncmp(Tempstr, "hashrat-integrity-mark: ",24)==0)
{
tmpHash=Hash->Clone(Hash);
HashFinish(tmpHash,ENCODE_BASE64,&HashStr);
HashratOutputSigningCheck(Ctx, HashStr, Tempstr, LineCount);
}
Hash->Update(Hash ,Tempstr, StrLen(Tempstr));
Tempstr=STREAMReadLine(Tempstr, S);
}
DestroyString(Tempstr);
DestroyString(HashStr);
return(TRUE);
}
void
LefTechInit()
{
HashSearch hs;
HashEntry *he;
lefLayer *lefl;
if (LefInfo.ht_table != (HashEntry **) NULL)
{
HashStartSearch(&hs);
while (he = HashNext(&LefInfo, &hs))
{
lefl = (lefLayer *)HashGetValue(he);
if (!lefl) continue;
lefl->refCnt--;
if (lefl->refCnt <= 0)
{
/* Via detailed information, if it exists, */
/* needs to have its allocated memory free'd. */
if (lefl->lefClass == CLASS_VIA)
if (lefl->info.via.lr != NULL)
freeMagic(lefl->info.via.lr);
freeMagic(lefl);
}
}
HashKill(&LefInfo);
}
HashInit(&LefInfo, 32, HT_STRINGKEYS);
}
Scope *ScopeNew(const char *name)
{
Scope *ptr;
CfDebug("Adding scope data %s\n", name);
if (!ThreadLock(cft_vscope))
{
CfOut(OUTPUT_LEVEL_ERROR, "", "!! Could not lock VSCOPE");
return NULL;
}
for (ptr = VSCOPE; ptr != NULL; ptr = ptr->next)
{
if (strcmp(ptr->scope, name) == 0)
{
ThreadUnlock(cft_vscope);
CfDebug("SCOPE Object %s already exists\n", name);
return NULL;
}
}
ptr = xcalloc(1, sizeof(Scope));
ptr->next = VSCOPE;
ptr->scope = xstrdup(name);
ptr->hashtable = HashInit();
VSCOPE = ptr;
ThreadUnlock(cft_vscope);
return ptr;
}
int HashBytes(char **Return, char *Type, char *text, int len, int Encoding)
{
THash *Hash;
Hash=HashInit(Type);
Hash->Update(Hash, text, len);
return(Hash->Finish(Hash, Encoding, Return));
}
static StackFrame *StackFrameNewPromise(const Promise *owner)
{
StackFrame *frame = StackFrameNew(STACK_FRAME_TYPE_PROMISE, true);
frame->data.promise.owner = owner;
frame->data.promise.variables = HashInit();
return frame;
}
extern void InitGlobalVarList( void )
/***********************************/
/* must be called before any other reference to GlobalVarList is made */
{
GlobalVarArray.num = 0;
GlobalVarArray.alloc = 20;
GlobalVarArray.increment = 20;
InitArray( (void **)&GlobalVarList, sizeof( a_variable ), &GlobalVarArray );
GlobalVarHash = HashInit( HASH_SIZE, &stricmp );
}
Hash * HashCreateAlloc(char copyKey, void *(*xMalloc)(size_t), void (*xFree)(void *)) {
Hash * pHash = (Hash*)xMalloc(sizeof(Hash));
if (pHash != NULL) {
HashInit(pHash, copyKey, xMalloc, xFree);
return pHash;
}
else {
return 0;
}
}
int HashBytes(char **Return, const char *Type, const char *text, int len, int Encoding)
{
HASH *Hash;
int result;
Hash=HashInit(Type);
if (! Hash) return(0);
Hash->Update(Hash, text, len);
result=HashFinish(Hash, Encoding, Return);
return(result);
}
extern void FreeGlobalVarList( bool including_real_globals )
/**********************************************************/
{
int i, j;
if( GlobalVarList == NULL )
return;
if( including_real_globals ) {
for( i = 0; i < GlobalVarArray.num; i++ ) {
GUIMemFree( GlobalVarList[i].name );
GUIMemFree( GlobalVarList[i].strval );
GUIMemFree( GlobalVarList[i].autoset );
}
GlobalVarArray.num = 0;
GUIMemFree( GlobalVarList );
if( GlobalVarHash ) {
HashFini( GlobalVarHash );
GlobalVarHash = NULL;
}
} else {
for( i = 0; i < GlobalVarArray.num; ) {
if( GlobalVarList[i].name[0] != '$' ) {
GUIMemFree( GlobalVarList[i].name );
GUIMemFree( GlobalVarList[i].strval );
GUIMemFree( GlobalVarList[i].autoset );
for( j = i; j < GlobalVarArray.num - 1; j++ ) {
memcpy( &GlobalVarList[j], &GlobalVarList[j + 1],
sizeof( a_variable ) );
GlobalVarList[j].id = j;
// This destroys the concept that a handle to a variable
// will always point to the same variable. Between
// script launches, variable ids will change.
}
GlobalVarArray.num -= 1;
BumpDownArray( &GlobalVarArray );
} else {
i++;
}
}
// We have to rebuild the hash table
if( GlobalVarHash ) {
HashFini( GlobalVarHash );
GlobalVarHash = HashInit( HASH_SIZE, &stricmp );
for( i = 0; i < GlobalVarArray.num; i++ ) {
HashInsert( GlobalVarHash, GlobalVarList[i].name, i );
}
}
}
}
void
DBTechInitType()
{
DefaultType *dtp;
char *cp;
/* Clear out any old information */
if (dbTypeNameLists.sn_next != NULL)
{
NameList *tbl;
for (tbl = dbTypeNameLists.sn_next; tbl != &dbTypeNameLists;
tbl = tbl->sn_next)
{
freeMagic(tbl->sn_name);
freeMagic(tbl);
}
}
/* Tables of short names */
dbTypeNameLists.sn_next = &dbTypeNameLists;
dbTypeNameLists.sn_prev = &dbTypeNameLists;
/*
* Add the type names to the list of known names, and set
* the default plane for each type.
*/
for (dtp = dbTechDefaultTypes; dtp->dt_names; dtp++)
{
cp = dbTechNameAdd(dtp->dt_names, (ClientData) dtp->dt_type,
&dbTypeNameLists);
if (cp == NULL)
{
TxError("DBTechInit: can't add type names %s\n", dtp->dt_names);
niceabort();
}
DBTypeLongNameTbl[dtp->dt_type] = cp;
DBPlane(dtp->dt_type) = dtp->dt_plane;
TTMaskSetOnlyType(&DBLayerTypeMaskTbl[dtp->dt_type], dtp->dt_type);
}
/* Zero the active layers (this mask is inverted later) */
TTMaskZero(&DBActiveLayerBits);
/* Hash table of layer aliases, free'ing the allocated type masks */
HashFreeKill(&DBTypeAliasTable);
HashInit(&DBTypeAliasTable, 8, HT_STRINGKEYS);
DBNumTypes = TT_TECHDEPBASE;
}
int main(int argc, char **argv) {
int i;
long long diff;
int *res = NULL;
int times = 10;
int clean_avc = 0;
struct timespec start, end;
if (argc > 1)
times = atoi(argv[1]);
if (argc > 2)
clean_avc = atoi(argv[2]);
Hash hmap;
HashInit(&hmap, HASH_STRING, 0);
char *scon = "unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023";
char *tcon = "unconfined_u:object_r:sesqlite_public:s0";
char *clas = "db_column";
char *perm = "select";
char *key = "unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 unconfined_u:object_r:sesqlite_public:s0 db_column select";
res = malloc(sizeof(int));
*res = selinux_check_access(scon, tcon, clas, perm, NULL);
HashInsert(&hmap, strdup(key), strlen(key), res);
for (i = 0; i < times; ++i) {
if ( clean_avc != 0 ){
cleanavc();
HashClear(&hmap);
}
GETTIME(start)
res = HashFind(&hmap, key, strlen(key));
if (res == NULL) {
res = malloc(sizeof(int));
*res = selinux_check_access(scon, tcon, clas, perm, NULL);
HashInsert(&hmap, strdup(key), strlen(key), res);
}
GETTIME(end)
diff = TIMESPEC_DIFF(start, end);
printf("%lld\n", diff);
}
return 0;
}
/* Build a hash table containing all terms in zText. */
static int build_terms(Hash *terms, sqlite3_tokenizer *pTokenizer,
const char *zText, sqlite_int64 iDocid){
sqlite3_tokenizer_cursor *pCursor;
const char *pToken;
int nTokenBytes;
int iStartOffset, iEndOffset, iPosition;
int rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
if( rc!=SQLITE_OK ) return rc;
pCursor->pTokenizer = pTokenizer;
HashInit(terms, HASH_STRING, 1);
while( SQLITE_OK==pTokenizer->pModule->xNext(pCursor,
&pToken, &nTokenBytes,
&iStartOffset, &iEndOffset,
&iPosition) ){
DocList *p;
/* Positions can't be negative; we use -1 as a terminator internally. */
if( iPosition<0 ) {
rc = SQLITE_ERROR;
goto err;
}
p = HashFind(terms, pToken, nTokenBytes);
if( p==NULL ){
p = docListNew(DL_POSITIONS_OFFSETS);
docListAddDocid(p, iDocid);
HashInsert(terms, pToken, nTokenBytes, p);
}
docListAddPosOffset(p, iPosition, iStartOffset, iEndOffset);
}
err:
/* TODO(shess) Check return? Should this be able to cause errors at
** this point? Actually, same question about sqlite3_finalize(),
** though one could argue that failure there means that the data is
** not durable. *ponder*
*/
pTokenizer->pModule->xClose(pCursor);
return rc;
}
void ScopeClear(const char *name)
{
if (!ThreadLock(cft_vscope))
{
Log(LOG_LEVEL_ERR, "Could not lock VSCOPE");
return;
}
Scope *scope = ScopeGet(name);
if (!scope)
{
Log(LOG_LEVEL_DEBUG, "No such scope to clear");
ThreadUnlock(cft_vscope);
return;
}
HashFree(scope->hashtable);
scope->hashtable = HashInit();
ThreadUnlock(cft_vscope);
}
int main(int argc, char *argv[])
{
#if HAVE_SETBUF
setbuf(stdin, NULL);
#endif
OpenLogFile("Amy.log");
InitMoves();
InitAll();
HashInit();
/*
* Process rc file first, then command line options. This way command
* line options can override rc file settings.
*/
ProcessRCFile();
ProcessOptions(argc, argv);
ShowVersion();
AllocateHT();
InitEGTB(EGTBPath);
RecogInit();
DoBookLearning();
Print(0, "\n");
strcpy(AutoSaveFileName, GetTmpFileName());
/* Ensure true random behavior. */
InitRandom(GetTime());
StateMachine();
return 0;
}
Scope *ScopeNew(const char *ns, const char *scope)
{
assert(scope);
if (!ns)
{
ns = "default";
}
if (!ThreadLock(cft_vscope))
{
Log(LOG_LEVEL_ERR, "Could not lock VSCOPE");
return NULL;
}
for (Scope *ptr = VSCOPE; ptr != NULL; ptr = ptr->next)
{
if (strcmp(ptr->ns, ns) == 0 && strcmp(ptr->scope, scope) == 0)
{
ThreadUnlock(cft_vscope);
return NULL;
}
}
Scope *ptr = xcalloc(1, sizeof(Scope));
ptr->hashtable = HashInit();
ptr->ns = xstrdup(ns);
ptr->scope = xstrdup(scope);
assert(ptr->scope);
ptr->next = VSCOPE;
VSCOPE = ptr;
assert(VSCOPE->scope);
ThreadUnlock(cft_vscope);
return ptr;
}
void ScopeClearSpecial(SpecialScope scope)
{
if (!ThreadLock(cft_vscope))
{
Log(LOG_LEVEL_ERR, "Could not lock VSCOPE");
return;
}
Scope *ptr = ScopeGet(NULL, SpecialScopeToString(scope));
if (!ptr)
{
Log(LOG_LEVEL_DEBUG, "No special scope '%s' to clear", SpecialScopeToString(scope));
ThreadUnlock(cft_vscope);
return;
}
HashFree(ptr->hashtable);
ptr->hashtable = HashInit();
Log(LOG_LEVEL_DEBUG, "Special scope '%s' cleared", SpecialScopeToString(scope));
ThreadUnlock(cft_vscope);
}
void ScopeClear(const char *name)
{
CfDebug("Clearing scope %s\n", name);
if (!ThreadLock(cft_vscope))
{
CfOut(OUTPUT_LEVEL_ERROR, "", "!! Could not lock VSCOPE");
return;
}
Scope *scope = ScopeGet(name);
if (!scope)
{
CfDebug("No such scope to clear\n");
ThreadUnlock(cft_vscope);
return;
}
HashFree(scope->hashtable);
scope->hashtable = HashInit();
ThreadUnlock(cft_vscope);
}
static int build_terms(Hash *terms, sqlite3_tokenizer *pTokenizer,
const char *zText, sqlite_int64 iDocid){
sqlite3_tokenizer_cursor *pCursor;
const char *pToken;
int nTokenBytes;
int iStartOffset, iEndOffset, iPosition;
int rc = pTokenizer->pModule->xOpen(pTokenizer, zText, -1, &pCursor);
if( rc!=SQLITE_OK ) return rc;
pCursor->pTokenizer = pTokenizer;
HashInit(terms, HASH_STRING, 1);
while( SQLITE_OK==pTokenizer->pModule->xNext(pCursor,
&pToken, &nTokenBytes,
&iStartOffset, &iEndOffset,
&iPosition) ){
DocList *p;
if( iPosition<0 ) {
rc = SQLITE_ERROR;
goto err;
}
p = HashFind(terms, pToken, nTokenBytes);
if( p==NULL ){
p = docListNew(DL_POSITIONS_OFFSETS);
docListAddDocid(p, iDocid);
HashInsert(terms, pToken, nTokenBytes, p);
}
docListAddPosOffset(p, iPosition, iStartOffset, iEndOffset);
}
err:
pTokenizer->pModule->xClose(pCursor);
return rc;
}
/* Simple version of #define and #undef processor. */
int main() {
char word[kMaxWord];
char *name;
char defn[kMaxWord];
LinkNode *p;
int len = 0, i = 0;
enum ParserState state = kStart;
HashTable hash_table[kHashSize];
HashInit(hash_table, kHashSize);
memset(word, 0, kMaxWord);
memset(defn, 0, kMaxWord);
while (GetWord(word, kMaxWord) != EOF) {
switch (state) {
case kStart:
if (strcmp(word, "#define") == 0) {
state = kDefine;
} else if (strcmp(word, "#undef") == 0) {
state = kUnDef;
} else if (!isalpha(word[0])) {
printf("%s", word);
} else if ((p = HashSearch(hash_table, word)) == NULL) {
printf("%s", word);
} else {
ungets(p->defn);
}
break;
case kDefine:
if (isalpha(word[0])) {
name = strdup(word);
state = kName;
} else {
printf("Error: non-alpha name");
exit(1);
}
break;
case kName:
if (word[0] == '\n') {
printf("Error: incomplate define");
exit(1);
} else {
strcpy(defn, word);
len += strlen(word);
state = kDefn;
}
break;
case kDefn:
if (word[0] != '\n' && len < kMaxWord) {
strcat(defn, word);
len += strlen(word);
} else {
HashInsert(hash_table, name, defn);
state = kStart;
}
break;
case kUnDef:
if (isalpha(word[0])) {
HashDelete(hash_table, name);
state = kStart;
} else {
printf("Error: non-alpha name");
exit(1);
}
break;
}
}
return 0;
}
void ap_open_diag_raw(int diagFile)
{
diag_file = diagFile;
diag_levels = (THash*)malloc(sizeof(THash));
HashInit(diag_levels);
}
void
DBTypeInit()
{
HashInit(&DBTypeAliasTable, 8, HT_STRINGKEYS);
}
void Kyokumen::Init(int suji, int dan, int promote, int teNum, KomaInf ban[MAX_DAN][MAX_SUJI], int hand[EHI+1])
{
HashInit();
m_KyokumenHashVal = 0;
m_HandHashVal = 0;
m_HashVal = 0;
memset(m_BanPadding1, WALL, sizeof(m_BanPadding1));
memset(m_Ban, WALL, sizeof(m_Ban));
memset(m_BanPadding2, WALL, sizeof(m_BanPadding2));
m_TeNum = teNum;
m_LastTe = Te(0, 0, EMPTY, EMPTY);
m_KingS = 0;
m_KingE = 0;
m_Suji = suji;
m_Dan = dan;
m_Promote = promote;
m_Value = 0;
int idxD;
int idxS;
for (idxD=0; idxD < m_Dan; idxD++) {
for (idxS=0; idxS < m_Suji; idxS++) {
KomaPos pos = COLROW2KOMAPOS(idxS+1, m_Suji, idxD+1, m_Dan);
m_Ban[pos] = ban[idxD][idxS];
m_KyokumenHashVal ^= m_HashSeed[m_Ban[pos]][pos];
if (m_Ban[pos] == SOU) {
m_KingS = pos;
}
else if (m_Ban[pos] == EOU) {
m_KingE = pos;
}
m_Value += KomaValue[m_Ban[pos]];
}
}
KomaInf inf;
int num;
for (inf=EMPTY; inf < EHI+1; inf++) {
m_Hand[inf] = hand[inf];
m_Value += HandValue[inf] * m_Hand[inf];
for (num=1; num <= m_Hand[inf]; num++) {
m_HandHashVal ^= m_HandHashSeed[inf][num];
}
}
InitControl();
m_HashVal = m_KyokumenHashVal ^ m_HandHashVal;
int i;
for (i=0; i <= MAX_TE_HISTORY; i++) {
m_HashHistory[i] = 0;
m_OuteHistory[i] = 0;
}
m_HashHistory[m_TeNum] = m_HashVal;
if (GetTeban() == SELF) {
// 現在の手番が先手ということは、現在の局面に成った指し手は後手ということになる.
// 後手が王手をしている状態かどうかを履歴に取っておく.
m_OuteHistory[m_TeNum] = m_ControlE[m_KingS];
}
else {
m_OuteHistory[m_TeNum] = m_ControlS[m_KingE];
}
}
