EXPORT_C const TDbCell* RDbRow::ColCell(TDbColNo aColNo) const
{
__ASSERT(aColNo>0);
const TDbCell* cell=Column(aColNo-1);
return cell && cell->Length() ? cell : NullCell();
}
int
spl_debug_msg(void *arg, int subsys, int mask, const char *file,
const char *fn, const int line, const char *format, ...)
{
spl_debug_limit_state_t *cdls = arg;
struct trace_cpu_data *tcd = NULL;
struct spl_debug_header header = { 0, };
struct trace_page *tage;
/* string_buf is used only if tcd != NULL, and is always set then */
char *string_buf = NULL;
char *debug_buf;
int known_size;
int needed = 85; /* average message length */
int max_nob;
va_list ap;
int i;
if (subsys == 0)
subsys = SS_DEBUG_SUBSYS;
if (mask == 0)
mask = SD_EMERG;
if (strchr(file, '/'))
file = strrchr(file, '/') + 1;
trace_set_debug_header(&header, subsys, mask, line, 0);
tcd = trace_get_tcd();
if (tcd == NULL)
goto console;
if (tcd->tcd_shutting_down) {
trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
known_size = strlen(file) + 1;
if (fn)
known_size += strlen(fn) + 1;
if (spl_debug_binary)
known_size += sizeof(header);
/* '2' used because vsnprintf returns real size required for output
* _without_ terminating NULL. */
for (i = 0; i < 2; i++) {
tage = trace_get_tage(tcd, needed + known_size + 1);
if (tage == NULL) {
if (needed + known_size > PAGE_SIZE)
mask |= SD_ERROR;
trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
string_buf = (char *)page_address(tage->page) +
tage->used + known_size;
max_nob = PAGE_SIZE - tage->used - known_size;
if (max_nob <= 0) {
printk(KERN_EMERG "negative max_nob: %i\n", max_nob);
mask |= SD_ERROR;
trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
needed = 0;
if (format) {
va_start(ap, format);
needed += vsnprintf(string_buf, max_nob, format, ap);
va_end(ap);
}
if (needed < max_nob)
break;
}
header.ph_len = known_size + needed;
debug_buf = (char *)page_address(tage->page) + tage->used;
if (spl_debug_binary) {
memcpy(debug_buf, &header, sizeof(header));
tage->used += sizeof(header);
debug_buf += sizeof(header);
}
strcpy(debug_buf, file);
tage->used += strlen(file) + 1;
debug_buf += strlen(file) + 1;
if (fn) {
strcpy(debug_buf, fn);
tage->used += strlen(fn) + 1;
debug_buf += strlen(fn) + 1;
}
__ASSERT(debug_buf == string_buf);
tage->used += needed;
__ASSERT (tage->used <= PAGE_SIZE);
console:
if ((mask & spl_debug_printk) == 0) {
/* no console output requested */
if (tcd != NULL)
trace_put_tcd(tcd);
return 1;
}
if (cdls != NULL) {
if (spl_console_ratelimit && cdls->cdls_next != 0 &&
!time_before(cdls->cdls_next, jiffies)) {
/* skipping a console message */
cdls->cdls_count++;
if (tcd != NULL)
trace_put_tcd(tcd);
return 1;
}
if (time_before(cdls->cdls_next + spl_console_max_delay +
(10 * HZ), jiffies)) {
/* last timeout was a long time ago */
cdls->cdls_delay /= spl_console_backoff * 4;
} else {
cdls->cdls_delay *= spl_console_backoff;
if (cdls->cdls_delay < spl_console_min_delay)
cdls->cdls_delay = spl_console_min_delay;
else if (cdls->cdls_delay > spl_console_max_delay)
cdls->cdls_delay = spl_console_max_delay;
}
/* ensure cdls_next is never zero after it's been seen */
cdls->cdls_next = (jiffies + cdls->cdls_delay) | 1;
}
if (tcd != NULL) {
trace_print_to_console(&header, mask, string_buf, needed, file, fn);
trace_put_tcd(tcd);
} else {
string_buf = trace_get_console_buffer();
needed = 0;
if (format != NULL) {
va_start(ap, format);
needed += vsnprintf(string_buf,
TRACE_CONSOLE_BUFFER_SIZE, format, ap);
va_end(ap);
}
trace_print_to_console(&header, mask,
string_buf, needed, file, fn);
trace_put_console_buffer(string_buf);
}
if (cdls != NULL && cdls->cdls_count != 0) {
string_buf = trace_get_console_buffer();
needed = snprintf(string_buf, TRACE_CONSOLE_BUFFER_SIZE,
"Skipped %d previous similar message%s\n",
cdls->cdls_count, (cdls->cdls_count > 1) ? "s" : "");
trace_print_to_console(&header, mask,
string_buf, needed, file, fn);
trace_put_console_buffer(string_buf);
cdls->cdls_count = 0;
}
return 0;
}
void CPUCALL
exception(int num, int error_code)
{
#if defined(DEBUG)
extern int cpu_debug_rep_cont;
extern CPU_REGS cpu_debug_rep_regs;
#endif
int errorp = 0;
__ASSERT((unsigned int)num < EXCEPTION_NUM);
#if 0
iptrace_out();
debugwriteseg("execption.bin", &CPU_CS_DESC, CPU_PREV_EIP & 0xffff0000, 0x10000);
#endif
VERBOSE(("exception: -------------------------------------------------------------- start"));
VERBOSE(("exception: %s, error_code = %x at %04x:%08x", exception_str[num], error_code, CPU_CS, CPU_PREV_EIP));
VERBOSE(("%s", cpu_reg2str()));
VERBOSE(("code: %dbit(%dbit), address: %dbit(%dbit)", CPU_INST_OP32 ? 32 : 16, CPU_STATSAVE.cpu_inst_default.op_32 ? 32 : 16, CPU_INST_AS32 ? 32 : 16, CPU_STATSAVE.cpu_inst_default.as_32 ? 32 : 16));
#if defined(DEBUG)
if (cpu_debug_rep_cont) {
VERBOSE(("rep: original regs: ecx=%08x, esi=%08x, edi=%08x", cpu_debug_rep_regs.reg[CPU_ECX_INDEX].d, cpu_debug_rep_regs.reg[CPU_ESI_INDEX].d, cpu_debug_rep_regs.reg[CPU_EDI_INDEX].d));
}
VERBOSE(("%s", cpu_disasm2str(CPU_PREV_EIP)));
#endif
CPU_STAT_EXCEPTION_COUNTER_INC();
if ((CPU_STAT_EXCEPTION_COUNTER >= 3)
|| (CPU_STAT_EXCEPTION_COUNTER == 2 && CPU_STAT_PREV_EXCEPTION == DF_EXCEPTION)) {
/* Triple fault */
ia32_panic("exception: catch triple fault!");
}
switch (num) {
case DE_EXCEPTION: /* (F) 除算エラー */
case DB_EXCEPTION: /* (F/T) デバッグ */
case BR_EXCEPTION: /* (F) BOUND の範囲外 */
case UD_EXCEPTION: /* (F) 無効オペコード */
case NM_EXCEPTION: /* (F) デバイス使用不可 (FPU が無い) */
case MF_EXCEPTION: /* (F) 浮動小数点エラー */
CPU_EIP = CPU_PREV_EIP;
if (CPU_STATSAVE.cpu_stat.backout_sp)
CPU_ESP = CPU_PREV_ESP;
/*FALLTHROUGH*/
case NMI_EXCEPTION: /* (I) NMI 割り込み */
case BP_EXCEPTION: /* (T) ブレークポイント */
case OF_EXCEPTION: /* (T) オーバーフロー */
errorp = 0;
break;
case DF_EXCEPTION: /* (A) ダブルフォルト (errcode: 0) */
errorp = 1;
error_code = 0;
break;
case AC_EXCEPTION: /* (F) アラインメントチェック (errcode: 0) */
error_code = 0;
/*FALLTHROUGH*/
case TS_EXCEPTION: /* (F) 無効 TSS (errcode) */
case NP_EXCEPTION: /* (F) セグメント不在 (errcode) */
case SS_EXCEPTION: /* (F) スタックセグメントフォルト (errcode) */
case GP_EXCEPTION: /* (F) 一般保護例外 (errcode) */
case PF_EXCEPTION: /* (F) ページフォルト (errcode) */
CPU_EIP = CPU_PREV_EIP;
if (CPU_STATSAVE.cpu_stat.backout_sp)
CPU_ESP = CPU_PREV_ESP;
errorp = 1;
break;
default:
ia32_panic("exception: unknown exception (%d)", num);
break;
}
if (CPU_STAT_EXCEPTION_COUNTER >= 2) {
if (dftable[exctype[CPU_STAT_PREV_EXCEPTION]][exctype[num]]) {
num = DF_EXCEPTION;
errorp = 1;
error_code = 0;
}
}
CPU_STAT_PREV_EXCEPTION = num;
VERBOSE(("exception: ---------------------------------------------------------------- end"));
interrupt(num, INTR_TYPE_EXCEPTION, errorp, error_code);
CPU_STAT_EXCEPTION_COUNTER_CLEAR();
siglongjmp(exec_1step_jmpbuf, 1);
}
EXPORT_C void RDbRow::CreateL(TInt aMaxSize)
{
__ASSERT(!iFirst && Owned());
GrowL(aMaxSize);
}
bool CUILogIn::Load(HANDLE hFile)
{
if(CN3UIBase::Load(hFile)==false) return false;
m_pGroup_LogIn = GetChildByID("Group_LogIn"); __ASSERT(m_pGroup_LogIn, "NULL UI Component!!");
if(m_pGroup_LogIn)
{
m_pBtn_LogIn = (CN3UIButton*)m_pGroup_LogIn->GetChildByID("Btn_Login"); __ASSERT(m_pBtn_LogIn, "NULL UI Component!!");
m_pBtn_Cancel = (CN3UIButton*)m_pGroup_LogIn->GetChildByID("Btn_Cancel"); __ASSERT(m_pBtn_Cancel, "NULL UI Component!!");
m_pBtn_Option = (CN3UIButton*)m_pGroup_LogIn->GetChildByID("Btn_Option"); __ASSERT(m_pBtn_Option, "NULL UI Component!!");
m_pEdit_id = (CN3UIEdit*)m_pGroup_LogIn->GetChildByID("Edit_ID"); __ASSERT(m_pEdit_id, "NULL UI Component!!");
m_pEdit_pw = (CN3UIEdit*)m_pGroup_LogIn->GetChildByID("Edit_PW"); __ASSERT(m_pEdit_pw, "NULL UI Component!!");
m_pImg_GradeLogo = m_pGroup_LogIn->GetChildByID("Img_Grade"); __ASSERT(m_pImg_GradeLogo, "NULL UI Component!!");
}
m_pText_Rights = GetChildByID("Text_Rights"); __ASSERT(m_pText_Rights, "NULL UI Component!!");
m_pImg_MGameLogo = GetChildByID("Img_MGame"); __ASSERT(m_pImg_MGameLogo, "NULL UI Component!!");
m_pImg_DaumLogo = GetChildByID("Img_Daum"); __ASSERT(m_pImg_DaumLogo, "NULL UI Component!!");
if(m_pText_Rights) m_pText_Rights->SetVisible(false);
if(m_pImg_MGameLogo) m_pImg_MGameLogo->SetVisible(false);
if(m_pImg_DaumLogo) m_pImg_DaumLogo->SetVisible(false);
m_pGroup_ServerList = GetChildByID("Group_ServerList"); __ASSERT(m_pGroup_ServerList, "NULL UI Component!!");
if(m_pGroup_ServerList)
{
m_pList_Server = (CN3UIList*)(m_pGroup_ServerList->GetChildByID("List_Server")); __ASSERT(m_pList_Server, "NULL UI Component!!");
m_pBtn_Connect = (CN3UIButton*)m_pGroup_ServerList->GetChildByID("Btn_Connect"); __ASSERT(m_pBtn_Connect, "NULL UI Component!!");
m_pGroup_ServerList->SetVisible(false);
}
return true;
}
WORD FAR CJpegFile::SaveDIB(HDIB hDib, LPSTR lpFileName)
{
BITMAPFILEHEADER bmfHdr; // Header for Bitmap file
LPBITMAPINFOHEADER lpBI; // Pointer to DIB info structure
HANDLE fh; // file handle for opened file
DWORD dwDIBSize;
// DWORD dwError; // Error return from MyWrite
DWORD nWritten;
if (!hDib)
return ERR_INVALIDHANDLE;
fh = CreateFile(lpFileName, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (fh == INVALID_HANDLE_VALUE)
return ERR_OPEN;
/*
* Get a pointer to the DIB memory, the first of which contains
* a BITMAPINFO structure
*/
lpBI = (LPBITMAPINFOHEADER)GlobalLock(hDib);
if (!lpBI)
return ERR_LOCK;
// Check to see if we're dealing with an OS/2 DIB. If so, don't
// save it because our functions aren't written to deal with these
// DIBs.
if (lpBI->biSize != sizeof(BITMAPINFOHEADER))
{
GlobalUnlock(hDib);
return ERR_NOT_DIB;
}
/*
* Fill in the fields of the file header
*/
/* Fill in file type (first 2 bytes must be "BM" for a bitmap) */
bmfHdr.bfType = DIB_HEADER_MARKER; // "BM"
// Calculating the size of the DIB is a bit tricky (if we want to
// do it right). The easiest way to do this is to call GlobalSize()
// on our global handle, but since the size of our global memory may have
// been padded a few bytes, we may end up writing out a few too
// many bytes to the file (which may cause problems with some apps,
// like HC 3.0).
//
// So, instead let's calculate the size manually.
//
// To do this, find size of header plus size of color table. Since the
// first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains
// the size of the structure, let's use this.
dwDIBSize = *(LPDWORD)lpBI + PaletteSize((LPSTR)lpBI); // Partial Calculation
// Now calculate the size of the image
if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4)) {
// It's an RLE bitmap, we can't calculate size, so trust the
// biSizeImage field
dwDIBSize += lpBI->biSizeImage;
}
else {
DWORD dwBmBitsSize; // Size of Bitmap Bits only
// It's not RLE, so size is Width (DWORD aligned) * Height
dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) * lpBI->biHeight;
dwDIBSize += dwBmBitsSize;
// Now, since we have calculated the correct size, why don't we
// fill in the biSizeImage field (this will fix any .BMP files which
// have this field incorrect).
lpBI->biSizeImage = dwBmBitsSize;
}
// Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)
bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
bmfHdr.bfReserved1 = 0;
bmfHdr.bfReserved2 = 0;
/*
* Now, calculate the offset the actual bitmap bits will be in
* the file -- It's the Bitmap file header plus the DIB header,
* plus the size of the color table.
*/
bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize +
PaletteSize((LPSTR)lpBI);
// Encrypt Data
BYTE *encrypt_data;
DWORD encrypt_len, i, j;
BYTE random_byte[4];
// Generate Random Byte.
srand((unsigned)time( NULL ));
for(i = 0; i < 4; i++) random_byte[i] = rand() % 0x100;
encrypt_len = sizeof(BITMAPFILEHEADER)+dwDIBSize+4;
encrypt_data = new BYTE[encrypt_len];
for(i = 0, j = 0; i < 4; i++, j++)
{
encrypt_data[j] = Encrypt(random_byte[i]);
}
for(i = 0; i < sizeof(BITMAPFILEHEADER); i++, j++)
{
encrypt_data[j] = Encrypt(*((BYTE *)(&bmfHdr)+i));
}
for(i = 0; i < dwDIBSize; i++, j++)
{
encrypt_data[j] = Encrypt(*((BYTE *)lpBI + i));
}
__ASSERT(j == encrypt_len, "Size Different");
WriteFile(fh, (LPCVOID)encrypt_data, encrypt_len, &nWritten, NULL);
/* Write the file header */
// WriteFile(fh, (LPCVOID)&bmfHdr, sizeof(BITMAPFILEHEADER), &nWritten, NULL);
/*
* Write the DIB header and the bits -- use local version of
* MyWrite, so we can write more than 32767 bytes of data
*/
// dwError = MyWrite(fh, (LPSTR)lpBI, dwDIBSize);
// WriteFile(fh, (LPCVOID)lpBI, dwDIBSize, &nWritten, NULL);
GlobalUnlock(hDib);
CloseHandle(fh);
delete[] encrypt_data;
return 0;
// if (dwError == 0)
// return ERR_OPEN; // oops, something happened in the write
// else
// return 0; // Success code
}
void sync_dir_changed_event(stEventDetails * pstevent)
{
__ASSERT(NULL != pstevent);
snprintf((char *)pstevent->szKeyDirectory,sizeof(pstevent->szKeyDirectory), \
"%s",stfsprivdata.stfsrpt.event_name);
}
void sync_nand_block_bad_info(stMonitorReport *pstmonitorrpt)
{
__ASSERT(NULL != pstmonitorrpt);
pstmonitorrpt->inandbadblocknum = stnandblockcheck.bad_block_num;
}
void WINAPI PreEvaluate(PositionStruct *lppos, PreEvalStruct *lpPreEval) {
int i, sq, nMidgameValue, nWhiteAttacks, nBlackAttacks, nWhiteSimpleValue, nBlackSimpleValue;
uint8_t ucvlPawnPiecesAttacking[256], ucvlPawnPiecesAttackless[256];
if (!bInit) {
bInit = true;
// 初始化"PreEvalEx.cPopCnt16"数组，只需要初始化一次
for (i = 0; i < 65536; i ++) {
PreEvalEx.cPopCnt16[i] = PopCnt16(i);
}
// 注意：引擎和局面评价API函数拥有两个不同的PreGen实例！
PreGenInit();
}
PreEval.bPromotion = lpPreEval->bPromotion;
// 首先判断局势处于开中局还是残局阶段，方法是计算各种棋子的数量，按照车=6、马炮=3、其它=1相加。
nMidgameValue = PopCnt32(lppos->dwBitPiece & BOTH_BITPIECE(ADVISOR_BITPIECE | BISHOP_BITPIECE | PAWN_BITPIECE)) * OTHER_MIDGAME_VALUE;
nMidgameValue += PopCnt32(lppos->dwBitPiece & BOTH_BITPIECE(KNIGHT_BITPIECE | CANNON_BITPIECE)) * KNIGHT_CANNON_MIDGAME_VALUE;
nMidgameValue += PopCnt32(lppos->dwBitPiece & BOTH_BITPIECE(ROOK_BITPIECE)) * ROOK_MIDGAME_VALUE;
// 使用二次函数，子力很少时才认为接近残局
nMidgameValue = (2 * TOTAL_MIDGAME_VALUE - nMidgameValue) * nMidgameValue / TOTAL_MIDGAME_VALUE;
__ASSERT_BOUND(0, nMidgameValue, TOTAL_MIDGAME_VALUE);
PreEval.vlAdvanced = (TOTAL_ADVANCED_VALUE * nMidgameValue + TOTAL_ADVANCED_VALUE / 2) / TOTAL_MIDGAME_VALUE;
__ASSERT_BOUND(0, PreEval.vlAdvanced, TOTAL_ADVANCED_VALUE);
for (sq = 0; sq < 256; sq ++) {
if (IN_BOARD(sq)) {
PreEval.ucvlWhitePieces[0][sq] = PreEval.ucvlBlackPieces[0][SQUARE_FLIP(sq)] = (uint8_t)
((cucvlKingPawnMidgameAttacking[sq] * nMidgameValue + cucvlKingPawnEndgameAttacking[sq] * (TOTAL_MIDGAME_VALUE - nMidgameValue)) / TOTAL_MIDGAME_VALUE);
PreEval.ucvlWhitePieces[3][sq] = PreEval.ucvlBlackPieces[3][SQUARE_FLIP(sq)] = (uint8_t)
((cucvlKnightMidgame[sq] * nMidgameValue + cucvlKnightEndgame[sq] * (TOTAL_MIDGAME_VALUE - nMidgameValue)) / TOTAL_MIDGAME_VALUE);
PreEval.ucvlWhitePieces[4][sq] = PreEval.ucvlBlackPieces[4][SQUARE_FLIP(sq)] = (uint8_t)
((cucvlRookMidgame[sq] * nMidgameValue + cucvlRookEndgame[sq] * (TOTAL_MIDGAME_VALUE - nMidgameValue)) / TOTAL_MIDGAME_VALUE);
PreEval.ucvlWhitePieces[5][sq] = PreEval.ucvlBlackPieces[5][SQUARE_FLIP(sq)] = (uint8_t)
((cucvlCannonMidgame[sq] * nMidgameValue + cucvlCannonEndgame[sq] * (TOTAL_MIDGAME_VALUE - nMidgameValue)) / TOTAL_MIDGAME_VALUE);
ucvlPawnPiecesAttacking[sq] = PreEval.ucvlWhitePieces[0][sq];
ucvlPawnPiecesAttackless[sq] = (uint8_t)
((cucvlKingPawnMidgameAttackless[sq] * nMidgameValue + cucvlKingPawnEndgameAttackless[sq] * (TOTAL_MIDGAME_VALUE - nMidgameValue)) / TOTAL_MIDGAME_VALUE);
}
}
for (i = 0; i < 16; i ++) {
PreEvalEx.vlHollowThreat[i] = cvlHollowThreat[i] * (nMidgameValue + TOTAL_MIDGAME_VALUE) / (TOTAL_MIDGAME_VALUE * 2);
__ASSERT_BOUND(0, PreEvalEx.vlHollowThreat[i], cvlHollowThreat[i]);
PreEvalEx.vlCentralThreat[i] = cvlCentralThreat[i];
}
// 然后判断各方是否处于进攻状态，方法是计算各种过河棋子的数量，按照车马2炮兵1相加。
nWhiteAttacks = nBlackAttacks = 0;
for (i = SIDE_TAG(0) + KNIGHT_FROM; i <= SIDE_TAG(0) + ROOK_TO; i ++) {
if (lppos->ucsqPieces[i] != 0 && BLACK_HALF(lppos->ucsqPieces[i])) {
nWhiteAttacks += 2;
}
}
for (i = SIDE_TAG(0) + CANNON_FROM; i <= SIDE_TAG(0) + PAWN_TO; i ++) {
if (lppos->ucsqPieces[i] != 0 && BLACK_HALF(lppos->ucsqPieces[i])) {
nWhiteAttacks ++;
}
}
for (i = SIDE_TAG(1) + KNIGHT_FROM; i <= SIDE_TAG(1) + ROOK_TO; i ++) {
if (lppos->ucsqPieces[i] != 0 && WHITE_HALF(lppos->ucsqPieces[i])) {
nBlackAttacks += 2;
}
}
for (i = SIDE_TAG(1) + CANNON_FROM; i <= SIDE_TAG(1) + PAWN_TO; i ++) {
if (lppos->ucsqPieces[i] != 0 && WHITE_HALF(lppos->ucsqPieces[i])) {
nBlackAttacks ++;
}
}
// 如果本方轻子数比对方多，那么每多一个轻子(车算2个轻子)威胁值加2。威胁值最多不超过8。
nWhiteSimpleValue = PopCnt16(lppos->wBitPiece[0] & ROOK_BITPIECE) * 2 + PopCnt16(lppos->wBitPiece[0] & (KNIGHT_BITPIECE | CANNON_BITPIECE));
nBlackSimpleValue = PopCnt16(lppos->wBitPiece[1] & ROOK_BITPIECE) * 2 + PopCnt16(lppos->wBitPiece[1] & (KNIGHT_BITPIECE | CANNON_BITPIECE));
if (nWhiteSimpleValue > nBlackSimpleValue) {
nWhiteAttacks += (nWhiteSimpleValue - nBlackSimpleValue) * 2;
} else {
nBlackAttacks += (nBlackSimpleValue - nWhiteSimpleValue) * 2;
}
nWhiteAttacks = MIN(nWhiteAttacks, TOTAL_ATTACK_VALUE);
nBlackAttacks = MIN(nBlackAttacks, TOTAL_ATTACK_VALUE);
PreEvalEx.vlBlackAdvisorLeakage = TOTAL_ADVISOR_LEAKAGE * nWhiteAttacks / TOTAL_ATTACK_VALUE;
PreEvalEx.vlWhiteAdvisorLeakage = TOTAL_ADVISOR_LEAKAGE * nBlackAttacks / TOTAL_ATTACK_VALUE;
__ASSERT_BOUND(0, nWhiteAttacks, TOTAL_ATTACK_VALUE);
__ASSERT_BOUND(0, nBlackAttacks, TOTAL_ATTACK_VALUE);
__ASSERT_BOUND(0, PreEvalEx.vlBlackAdvisorLeakage, TOTAL_ADVISOR_LEAKAGE);
__ASSERT_BOUND(0, PreEvalEx.vlBlackAdvisorLeakage, TOTAL_ADVISOR_LEAKAGE);
for (sq = 0; sq < 256; sq ++) {
if (IN_BOARD(sq)) {
PreEval.ucvlWhitePieces[1][sq] = PreEval.ucvlWhitePieces[2][sq] = (uint8_t) ((cucvlAdvisorBishopThreatened[sq] * nBlackAttacks +
(PreEval.bPromotion ? cucvlAdvisorBishopPromotionThreatless[sq] : cucvlAdvisorBishopThreatless[sq]) * (TOTAL_ATTACK_VALUE - nBlackAttacks)) / TOTAL_ATTACK_VALUE);
PreEval.ucvlBlackPieces[1][sq] = PreEval.ucvlBlackPieces[2][sq] = (uint8_t) ((cucvlAdvisorBishopThreatened[SQUARE_FLIP(sq)] * nWhiteAttacks +
(PreEval.bPromotion ? cucvlAdvisorBishopPromotionThreatless[SQUARE_FLIP(sq)] : cucvlAdvisorBishopThreatless[SQUARE_FLIP(sq)]) * (TOTAL_ATTACK_VALUE - nWhiteAttacks)) / TOTAL_ATTACK_VALUE);
PreEval.ucvlWhitePieces[6][sq] = (uint8_t) ((ucvlPawnPiecesAttacking[sq] * nWhiteAttacks +
ucvlPawnPiecesAttackless[sq] * (TOTAL_ATTACK_VALUE - nWhiteAttacks)) / TOTAL_ATTACK_VALUE);
PreEval.ucvlBlackPieces[6][sq] = (uint8_t) ((ucvlPawnPiecesAttacking[SQUARE_FLIP(sq)] * nBlackAttacks +
ucvlPawnPiecesAttackless[SQUARE_FLIP(sq)] * (TOTAL_ATTACK_VALUE - nBlackAttacks)) / TOTAL_ATTACK_VALUE);
}
}
for (i = 0; i < 16; i ++) {
PreEvalEx.vlWhiteBottomThreat[i] = cvlBottomThreat[i] * nBlackAttacks / TOTAL_ATTACK_VALUE;
PreEvalEx.vlBlackBottomThreat[i] = cvlBottomThreat[i] * nWhiteAttacks / TOTAL_ATTACK_VALUE;
}
// 检查预评价是否对称
#ifndef NDEBUG
for (sq = 0; sq < 256; sq ++) {
if (IN_BOARD(sq)) {
for (i = 0; i < 7; i ++) {
__ASSERT(PreEval.ucvlWhitePieces[i][sq] == PreEval.ucvlWhitePieces[i][SQUARE_MIRROR(sq)]);
__ASSERT(PreEval.ucvlBlackPieces[i][sq] == PreEval.ucvlBlackPieces[i][SQUARE_MIRROR(sq)]);
}
}
}
for (i = FILE_LEFT; i <= FILE_RIGHT; i ++) {
__ASSERT(PreEvalEx.vlWhiteBottomThreat[i] == PreEvalEx.vlWhiteBottomThreat[FILE_FLIP(i)]);
__ASSERT(PreEvalEx.vlBlackBottomThreat[i] == PreEvalEx.vlBlackBottomThreat[FILE_FLIP(i)]);
}
#endif
// 调整不受威胁方少掉的仕(士)相(象)分值
lppos->vlWhite = ADVISOR_BISHOP_ATTACKLESS_VALUE * (TOTAL_ATTACK_VALUE - nBlackAttacks) / TOTAL_ATTACK_VALUE;
lppos->vlBlack = ADVISOR_BISHOP_ATTACKLESS_VALUE * (TOTAL_ATTACK_VALUE - nWhiteAttacks) / TOTAL_ATTACK_VALUE;
// 如果允许升变，那么不受威胁的仕(士)相(象)分值就少了一半
if (PreEval.bPromotion) {
lppos->vlWhite /= 2;
lppos->vlBlack /= 2;
}
// 最后重新计算子力位置分
for (i = 16; i < 32; i ++) {
sq = lppos->ucsqPieces[i];
if (sq != 0) {
__ASSERT_SQUARE(sq);
lppos->vlWhite += PreEval.ucvlWhitePieces[PIECE_TYPE(i)][sq];
}
}
for (i = 32; i < 48; i ++) {
sq = lppos->ucsqPieces[i];
if (sq != 0) {
__ASSERT_SQUARE(sq);
lppos->vlBlack += PreEval.ucvlBlackPieces[PIECE_TYPE(i)][sq];
}
}
// 注意：引擎和局面评价API函数拥有两个不同的PreEval实例！
*lpPreEval = PreEval;
}
int k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read,
size_t *bytes_read, size_t min_xfer, s32_t timeout)
{
struct k_thread *writer;
struct k_pipe_desc *desc;
sys_dlist_t xfer_list;
unsigned int key;
size_t num_bytes_read = 0;
size_t bytes_copied;
__ASSERT(min_xfer <= bytes_to_read, "");
__ASSERT(bytes_read != NULL, "");
key = irq_lock();
/*
* Create a list of "working readers" into which the data will be
* directly copied.
*/
if (!_pipe_xfer_prepare(&xfer_list, &writer, &pipe->wait_q.writers,
pipe->bytes_used, bytes_to_read,
min_xfer, timeout)) {
irq_unlock(key);
*bytes_read = 0;
return -EIO;
}
_sched_lock();
irq_unlock(key);
num_bytes_read = _pipe_buffer_get(pipe, data, bytes_to_read);
/*
* 1. 'xfer_list' currently contains a list of writer threads that can
* have their write requests fulfilled by the current call.
* 2. 'writer' if not NULL points to a thread on the writer wait_q
* that can post some of its requested data.
* 3. Data will be copied from each writer's buffer to either the
* reader's buffer and/or to the pipe's circular buffer.
* 4. Interrupts are unlocked but the scheduler is locked to allow
* ticks to be delivered but no scheduling to occur
* 5. If 'writer' times out while we are copying data, not only do we
* still have a pointer to it, but it can not execute until this
* call is complete so it is still safe to copy data from it.
*/
struct k_thread *thread = (struct k_thread *)
sys_dlist_get(&xfer_list);
while (thread && (num_bytes_read < bytes_to_read)) {
desc = (struct k_pipe_desc *)thread->base.swap_data;
bytes_copied = _pipe_xfer(data + num_bytes_read,
bytes_to_read - num_bytes_read,
desc->buffer, desc->bytes_to_xfer);
num_bytes_read += bytes_copied;
desc->buffer += bytes_copied;
desc->bytes_to_xfer -= bytes_copied;
/*
* It is expected that the write request will be satisfied.
* However, if the read request was satisfied before the
* write request was satisfied, then the write request must
* finish later when writing to the pipe's circular buffer.
*/
if (num_bytes_read == bytes_to_read) {
break;
}
_pipe_thread_ready(thread);
thread = (struct k_thread *)sys_dlist_get(&xfer_list);
}
if (writer && (num_bytes_read < bytes_to_read)) {
desc = (struct k_pipe_desc *)writer->base.swap_data;
bytes_copied = _pipe_xfer(data + num_bytes_read,
bytes_to_read - num_bytes_read,
desc->buffer, desc->bytes_to_xfer);
num_bytes_read += bytes_copied;
desc->buffer += bytes_copied;
desc->bytes_to_xfer -= bytes_copied;
}
/*
* Copy as much data as possible from the writers (if any)
* into the pipe's circular buffer.
*/
while (thread) {
desc = (struct k_pipe_desc *)thread->base.swap_data;
bytes_copied = _pipe_buffer_put(pipe, desc->buffer,
desc->bytes_to_xfer);
desc->buffer += bytes_copied;
desc->bytes_to_xfer -= bytes_copied;
/* Write request has been satsified */
_pipe_thread_ready(thread);
thread = (struct k_thread *)sys_dlist_get(&xfer_list);
}
if (writer) {
desc = (struct k_pipe_desc *)writer->base.swap_data;
bytes_copied = _pipe_buffer_put(pipe, desc->buffer,
desc->bytes_to_xfer);
desc->buffer += bytes_copied;
desc->bytes_to_xfer -= bytes_copied;
}
if (num_bytes_read == bytes_to_read) {
k_sched_unlock();
*bytes_read = num_bytes_read;
return 0;
}
/* Not all data was read. */
struct k_pipe_desc pipe_desc;
pipe_desc.buffer = data + num_bytes_read;
pipe_desc.bytes_to_xfer = bytes_to_read - num_bytes_read;
if (timeout != K_NO_WAIT) {
_current->base.swap_data = &pipe_desc;
key = irq_lock();
_sched_unlock_no_reschedule();
_pend_current_thread(&pipe->wait_q.readers, timeout);
_Swap(key);
} else {
k_sched_unlock();
}
*bytes_read = bytes_to_read - pipe_desc.bytes_to_xfer;
return _pipe_return_code(min_xfer, pipe_desc.bytes_to_xfer,
bytes_to_read);
}
void Edge::IterImplEdge::Set(const IterImplBase& aImpl)
{
const IterImplEdge* src = static_cast<const IterImplEdge*>(aImpl.DoGetObj(Type()));
__ASSERT(src != NULL);
iPIter = src->iPIter;
}
void Edge::SetPoint2(MVert* aPoint)
{
__ASSERT(iPoint2 == NULL && aPoint != NULL);
iPoint2 = aPoint;
}
void Edge::SetPoints(MVert* aPoint1, MVert* aPoint2)
{
__ASSERT(iPoint1 == NULL && iPoint2 == NULL && aPoint1 != NULL && aPoint2 != NULL);
iPoint1 = aPoint1;
iPoint2 = aPoint2;
}
bool CUITradeSellBBS::Load(HANDLE hFile)
{
if(CN3UIBase::Load(hFile)==false) return false;
// m_pList_Infos = (CN3UIList*)(this->GetChildByID("List_Friends")); __ASSERT(m_pList_Infos, "NULL UI Component!!!");
m_pBtn_PageUp = (CN3UIButton*)(this->GetChildByID("btn_page_up")); __ASSERT(m_pBtn_PageUp, "NULL UI Component!!!");
m_pBtn_PageDown = (CN3UIButton*)(this->GetChildByID("btn_page_down")); __ASSERT(m_pBtn_PageDown, "NULL UI Component!!!");
m_pBtn_Refresh = (CN3UIButton*)(this->GetChildByID("btn_refresh")); __ASSERT(m_pBtn_Refresh, "NULL UI Component!!!");
m_pBtn_Close = (CN3UIButton*)(this->GetChildByID("btn_exit")); __ASSERT(m_pBtn_Close, "NULL UI Component!!!");
m_pBtn_Register = (CN3UIButton*)(this->GetChildByID("btn_add")); __ASSERT(m_pBtn_Register, "NULL UI Component!!!");
m_pBtn_Whisper = (CN3UIButton*)(this->GetChildByID("btn_whisper")); __ASSERT(m_pBtn_Whisper, "NULL UI Component!!!");
m_pBtn_Trade = (CN3UIButton*)(this->GetChildByID("btn_sale")); __ASSERT(m_pBtn_Trade, "NULL UI Component!!!");
m_pBtn_RegisterCancel = (CN3UIButton*)(this->GetChildByID("btn_delete")); __ASSERT(m_pBtn_RegisterCancel, "NULL UI Component!!!");
m_pImage_Sell = (CN3UIImage*)(this->GetChildByID("img_sell gold")); __ASSERT(m_pImage_Sell, "NULL UI Component!!!");
m_pImage_Buy = (CN3UIImage*)(this->GetChildByID("img_buy gold")); __ASSERT(m_pImage_Buy, "NULL UI Component!!!");
m_pImage_Sell_Title = (CN3UIImage*)(this->GetChildByID("img_sell")); __ASSERT(m_pImage_Sell_Title, "NULL UI Component!!!");
m_pImage_Buy_Title = (CN3UIImage*)(this->GetChildByID("img_buy")); __ASSERT(m_pImage_Buy_Title, "NULL UI Component!!!");
m_pString_Page = (CN3UIString*)(this->GetChildByID("string_page")); __ASSERT(m_pString_Page, "NULL UI Component!!!");
char szBuf[64];
for(int i = 0 ; i < TRADE_BBS_MAXSTRING ; i++)
{
sprintf(szBuf,"text_%.2d",i);
m_pText[i] = (CN3UIString*)(this->GetChildByID(szBuf));
}
m_iCurPage = 0; // 현재 페이지..
__TABLE_UI_RESRC* pTblUI = NULL;
pTblUI = CGameBase::s_pTbl_UI->Find(NATION_ELMORAD);
m_MsgBox.LoadFromFile(pTblUI->szMessageBox);
RECT rt = m_MsgBox.GetRegion();
POINT pt;
pt.x = (CN3Base::s_CameraData.vp.Width - (rt.right - rt.left)) / 2;
pt.y = (CN3Base::s_CameraData.vp.Height - (rt.bottom - rt.top)) / 2;
m_MsgBox.SetPos(pt.x, pt.y);
m_UIExplanation.LoadFromFile(pTblUI->szTradeMemolist);
rt = m_UIExplanation.GetRegion();
pt.x = (CN3Base::s_CameraData.vp.Width - (rt.right - rt.left)) / 2;
pt.y = (CN3Base::s_CameraData.vp.Height - (rt.bottom - rt.top)) / 2;
m_UIExplanation.SetPos(pt.x, pt.y);
return true;
}
void sync_fs_event(stMonitorReport *pstmonitorrpt)
{
__ASSERT(NULL != pstmonitorrpt);
memcpy(&pstmonitorrpt->stfsrpt,&(stfsprivdata.stfsrpt),sizeof(stFilsSystemReport));
}
bool CUIChat::Load(HANDLE hFile)
{
if (false == CN3UIBase::Load(hFile)) return false;
m_pChatOut = (CN3UIString*)GetChildByID("text0"); __ASSERT(m_pChatOut, "NULL UI Component!!");
m_pScrollbar = (CN3UIScrollBar*)GetChildByID("scroll"); __ASSERT(m_pScrollbar, "NULL UI Component!!");
m_pNoticeTitle = (CN3UIString*)GetChildByID("text_notice_title"); __ASSERT(m_pNoticeTitle, "NULL UI Component!!");
m_rcChatOutRegion = m_pChatOut->GetRegion();
CreateLines();
__ASSERT(0<m_iChatLineCount,"채팅창이 너무 작아요");
//son, chat_in
m_pEdit = (CN3UIEdit*)GetChildByID("edit0"); __ASSERT(m_pEdit, "NULL UI Component!!");
m_pEdit->SetMaxString(256); // 채팅 문자열 길이 제한..
//son, chat_in
m_pBtn_Normal = GetChildByID("btn_normal"); __ASSERT(m_pBtn_Normal, "NULL UI Component!!");
m_pBtn_Private = GetChildByID("btn_private"); __ASSERT(m_pBtn_Private, "NULL UI Component!!");
m_pBtn_PartyOrForce = GetChildByID("btn_party_force"); __ASSERT(m_pBtn_PartyOrForce, "NULL UI Component!!");
//m_pBtn_KnightsOrGuild = GetChildByID("btn_knights_guild"); __ASSERT(m_pBtn_KnightsOrGuild, "NULL UI Component!!");
m_pBtn_KnightsOrGuild = GetChildByID("btn_clan"); __ASSERT(m_pBtn_KnightsOrGuild, "NULL UI Component!!");
m_pBtn_Shout = GetChildByID("btn_shout"); __ASSERT(m_pBtn_Shout, "NULL UI Component!!");
m_pBtn_Check = GetChildByID("btn_check_normal"); __ASSERT(m_pBtn_Check, "NULL UI Component!!");
this->ChangeChattingMode(N3_CHAT_NORMAL); // 보통 채팅 모드이다..
return true;
}
int irq_connect_dynamic(unsigned int irq, unsigned int priority,
void (*routine)(void *parameter), void *parameter,
uint32_t flags)
{
int vector;
int stub_idx;
/*
* Check if the same IRQ was already connected before, in such as case,
* simply re-connect the existing stub.
*/
int i;
for (i=0; i<next_irq_stub; ++i)
{
if (dyn_irq_list[i].irq == irq)
{
__ASSERT(dyn_irq_list[i].priority == priority, "Non consistent priority");
dyn_irq_list[i].handler = routine;
dyn_irq_list[i].param = parameter;
_SysIntVecProgram(dyn_irq_list[i].vector, irq, flags);
_IntVecSet(dyn_irq_list[i].vector, _get_dynamic_stub(i, &_DynIntStubsBegin), 0);
return dyn_irq_list[i].vector;
}
}
/*
* Invoke the interrupt controller routine _SysIntVecAlloc() which will:
* a) allocate a vector satisfying the requested priority,
* b) create a new entry in the dynamic stub array
* c) program the underlying interrupt controller device such that
* when <irq> is asserted, the allocated interrupt vector will be
* presented to the CPU.
*
* The _SysIntVecAlloc() routine will use the "utility" routine
* _IntVecAlloc() provided in this module to scan the
* _interrupt_vectors_allocated[] array for a suitable vector.
*/
vector = _SysIntVecAlloc(irq, priority, flags);
#if defined(DEBUG)
/*
* The return value from _SysIntVecAlloc() will be -1 if an invalid
* <irq> or <priority> was specified, or if a vector could not be
* allocated to honour the requested priority (for the boards that can
* support programming the interrupt vector for each IRQ).
*/
if (vector == -1)
return (-1);
#endif /* DEBUG */
stub_idx = _stub_alloc(&next_irq_stub, ALL_DYN_IRQ_STUBS);
__ASSERT(stub_idx != -1, "No available interrupt stubs found");
dyn_irq_list[stub_idx].handler = routine;
dyn_irq_list[stub_idx].param = parameter;
dyn_irq_list[stub_idx].vector = vector;
dyn_irq_list[stub_idx].irq = irq;
dyn_irq_list[stub_idx].priority = priority;
_IntVecSet(vector, _get_dynamic_stub(stub_idx, &_DynIntStubsBegin), 0);
return vector;
}
