// データ並び替えのルーチン兼、データ順序の定義
// Fortran配列の行列aaを配列bb[id]へ移動する。
void convert_to_tile(int n, double* aa, int lda, double** bb, int id, int nth)
{
double* b = bb[id];
for(int i=id*BL; i<n; i+=nth*BL){
double* a = aa + i * lda;
int j = 0;
int isz = n -i;
if(isz >= BL){
// simd copy
for(; j+RJ < i; j+= RJ){
BOOST_PP_REPEAT(BL, CNV_MOVE_A2B, ignore);
b += RJ*BL;
a += RJ;
}
// serial copy
for(; j<i+BL; j+=RJ){
BOOST_PP_REPEAT(BL, CNV_MOVE_A2B_SERIAL, ignore);
b += RJ*BL;
}
}
else {
// simd copy with bounds-check
for(; j+RJ < i; j+= RJ){
BOOST_PP_REPEAT(BL, CNV_MOVE_A2B_CHECK, ignore);
b += RJ*BL;
a += RJ;
}
// naiive copy
for(; j<i+BL; j+=RJ){
int jjsz = (RJ<n-j?RJ:n-j);
for(int ii=0; ii<isz; ++ii)
for(int jj=0; jj<jjsz; ++jj)
b[ii*RJ+jj] = aa[SAFE_INDEX(i+ii,j+jj,lda)];
b += RJ*BL;
}
}
}
}
static fz_error
evalpostscriptfunc(pdf_function *func, psstack *st, int codeptr)
{
fz_error error;
int i1, i2;
float r1, r2;
int b1, b2;
while (1)
{
switch (func->u.p.code[codeptr].type)
{
case PSINT:
SAFE_PUSHINT(st, func->u.p.code[codeptr++].u.i);
break;
case PSREAL:
SAFE_PUSHREAL(st, func->u.p.code[codeptr++].u.f);
break;
case PSOPERATOR:
switch (func->u.p.code[codeptr++].u.op)
{
case PSOABS:
if (pstopisint(st)) {
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, abs(i1));
}
else {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, fabs(r1));
}
break;
case PSOADD:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 + i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, r1 + r2);
}
break;
case PSOAND:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 & i2);
}
else {
SAFE_POPBOOL(st, &b2);
SAFE_POPBOOL(st, &b1);
SAFE_PUSHBOOL(st, b1 && b2);
}
break;
case PSOATAN:
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, atan2(r1, r2)*RADIAN);
break;
case PSOBITSHIFT:
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
if (i2 > 0) {
SAFE_PUSHINT(st, i1 << i2);
}
else if (i2 < 0) {
SAFE_PUSHINT(st, (int)((unsigned int)i1 >> i2));
}
else {
SAFE_PUSHINT(st, i1);
}
break;
case PSOCEILING:
if (!pstopisint(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, ceil(r1));
}
break;
case PSOCOPY:
SAFE_POPINT(st, &i1);
SAFE_COPY(st, i1);
break;
case PSOCOS:
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, cos(r1/RADIAN));
break;
case PSOCVI:
if (!pstopisint(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHINT(st, (int)r1);
}
break;
case PSOCVR:
if (!pstopisreal(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, r1);
}
break;
case PSODIV:
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, r1 / r2);
break;
case PSODUP:
SAFE_COPY(st, 1);
break;
case PSOEQ:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 == i2);
}
else if (pstoptwoarenums(st)) {
SAFE_POPNUM(st, &r1);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 == r2);
}
else {
SAFE_POPBOOL(st, &b2);
SAFE_POPBOOL(st, &b2);
SAFE_PUSHBOOL(st, b1 == b2);
}
break;
case PSOEXCH:
psroll(st, 2, 1);
break;
case PSOEXP:
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, pow(r1, r2));
break;
case PSOFALSE:
SAFE_PUSHBOOL(st, 0);
break;
case PSOFLOOR:
if (!pstopisint(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, floor(r1));
}
break;
case PSOGE:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 >= i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 >= r2);
}
break;
case PSOGT:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 > i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 > r2);
}
break;
case PSOIDIV:
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 / i2);
break;
case PSOINDEX:
SAFE_POPINT(st, &i1);
SAFE_INDEX(st, i1);
break;
case PSOLE:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 <= i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 <= r2);
}
break;
case PSOLN:
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, log(r1));
break;
case PSOLOG:
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, log10(r1));
break;
case PSOLT:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 < i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 < r2);
}
break;
case PSOMOD:
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 % i2);
break;
case PSOMUL:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
/* FIXME should check for out-of-range, and push a real instead */
SAFE_PUSHINT(st, i1 * i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, r1 * r2);
}
break;
case PSONE:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHBOOL(st, i1 != i2);
}
else if (pstoptwoarenums(st)) {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHBOOL(st, r1 != r2);
}
else {
SAFE_POPBOOL(st, &b2);
SAFE_POPBOOL(st, &b1);
SAFE_PUSHBOOL(st, b1 != b2);
}
break;
case PSONEG:
if (pstopisint(st)) {
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, -i1);
}
else {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, -r1);
}
break;
case PSONOT:
if (pstopisint(st)) {
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, ~i1);
}
else {
SAFE_POPBOOL(st, &b1);
SAFE_PUSHBOOL(st, !b1);
}
break;
case PSOOR:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 | i2);
}
else {
SAFE_POPBOOL(st, &b2);
SAFE_POPBOOL(st, &b1);
SAFE_PUSHBOOL(st, b1 || b2);
}
break;
case PSOPOP:
SAFE_POP(st);
break;
case PSOROLL:
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
psroll(st, i1, i2);
break;
case PSOROUND:
if (!pstopisint(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, (r1 >= 0) ? floor(r1 + 0.5) : ceil(r1 - 0.5));
}
break;
case PSOSIN:
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, sin(r1/RADIAN));
break;
case PSOSQRT:
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, sqrt(r1));
break;
case PSOSUB:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 - i2);
}
else {
SAFE_POPNUM(st, &r2);
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, r1 - r2);
}
break;
case PSOTRUE:
SAFE_PUSHBOOL(st, 1);
break;
case PSOTRUNCATE:
if (!pstopisint(st)) {
SAFE_POPNUM(st, &r1);
SAFE_PUSHREAL(st, (r1 >= 0) ? floor(r1) : ceil(r1));
}
break;
case PSOXOR:
if (pstoptwoareints(st)) {
SAFE_POPINT(st, &i2);
SAFE_POPINT(st, &i1);
SAFE_PUSHINT(st, i1 ^ i2);
}
else {
SAFE_POPBOOL(st, &b2);
SAFE_POPBOOL(st, &b1);
SAFE_PUSHBOOL(st, b1 ^ b2);
}
break;
case PSOIF:
SAFE_POPBOOL(st, &b1);
if (b1) {
error = evalpostscriptfunc(func, st, codeptr + 2);
if (error)
return fz_rethrow(error, "runtime error in if-branch");
}
codeptr = func->u.p.code[codeptr + 1].u.block;
break;
case PSOIFELSE:
SAFE_POPBOOL(st, &b1);
if (b1) {
error = evalpostscriptfunc(func, st, codeptr + 2);
if (error)
return fz_rethrow(error, "runtime error in if-branch");
}
else {
error = evalpostscriptfunc(func, st, func->u.p.code[codeptr].u.block);
if (error)
return fz_rethrow(error, "runtime error in else-branch");
}
codeptr = func->u.p.code[codeptr + 1].u.block;
break;
case PSORETURN:
return fz_okay;
default:
return fz_throw("foreign operator in calculator function");
}
break;
default:
return fz_throw("foreign object in calculator function");
}
// SMBIOS Table Type 16 Physical Memory Array
PNODE EnumMemorySockets()
{
PNODE parentNode = NULL;
PNODE node = NULL;
PNODE devicesNode = NULL;
PNODE deviceNode = NULL;
PRAW_SMBIOS_DATA smbios = GetSmbiosData();
PSMBIOS_STRUCT_HEADER header = NULL;
PSMBIOS_STRUCT_HEADER memHeader = NULL;
PBYTE cursor = NULL;
PBYTE memCursor = NULL;
LPTSTR unicode = NULL;
TCHAR buffer[MAX_PATH + 1];
DWORD i;
WORD wbuffer = 0;
DWORD dwBuffer = 0;
QWORD totalArrayMb = 0;
QWORD totalSystemMb = 0;
BOOL isVirt = IsVirtualized();
// v2.1+ (Use Table Type 5 Memory Controller for < v2.1)
if (smbios->SMBIOSMajorVersion < 2 || (smbios->SMBIOSMajorVersion == 2 && smbios->SMBIOSMinorVersion < 1))
return parentNode;
parentNode = node_alloc(_T("Memory"), NFLG_TABLE);
while (NULL != (header = GetNextStructureOfType(header, SMB_TABLE_MEM_ARRAY))) {
cursor = (PBYTE)header;
node = node_append_new(parentNode, _T("Array"), NFLG_TABLE_ROW);
// 0x04 Location
node_att_set(node, _T("Location"), SAFE_INDEX(MEM_ARRAY_LOCATION, BYTE_AT_OFFSET(header, 0x04)), 0);
// 0x05 Use
node_att_set(node, _T("Use"), SAFE_INDEX(MEM_ARRAY_USE, BYTE_AT_OFFSET(header, 0x05)), 0);
// 0x06 Error Checking
node_att_set(node, _T("ErrorChecking"), SAFE_INDEX(MEM_ARRAY_EC_TYPE, BYTE_AT_OFFSET(header, 0x06)), 0);
// 0x07 Maximum Capacity (KB)
dwBuffer = DWORD_AT_OFFSET(header, 0x07);
if (dwBuffer != 0x80000000) {
swprintf(buffer, _T("%u"), dwBuffer);
node_att_set(node, _T("MaxCapacityKb"), buffer, NAFLG_FMT_KBYTES);
swprintf(buffer, _T("%u"), dwBuffer / 1024);
node_att_set(node, _T("MaxCapacityMb"), buffer, NAFLG_FMT_MBYTES);
swprintf(buffer, _T("%u"), dwBuffer / 1048576);
node_att_set(node, _T("MaxCapacityGb"), buffer, NAFLG_FMT_GBYTES);
}
// 0x0D Number of memory devices
swprintf(buffer, _T("%u"), BYTE_AT_OFFSET(header, 0x0D));
node_att_set(node, _T("SocketCount"), buffer, NAFLG_FMT_NUMERIC);
// 7.18 Memory Devices (Type 17)
devicesNode = node_append_new(node, _T("Modules"), NFLG_TABLE);
while (NULL != (memHeader = GetNextStructureOfType(memHeader, SMB_TABLE_MEM_DEVICE))) {
memCursor = (PBYTE)memHeader;
// 0x04 Memory Array Handle
// Ensure array handle matches the parent handle
if (header->Handle != WORD_AT_OFFSET(memHeader, 0x04))
continue;
// Skip empty slots
if (isVirt && 0 == WORD_AT_OFFSET(memHeader, 0x0C))
continue;
deviceNode = node_append_new(devicesNode, _T("Module"), NFLG_TABLE_ROW);
// 0x08 Total Width
wbuffer = WORD_AT_OFFSET(memHeader, 0x08);
if (0xFFFF != wbuffer) {
swprintf(buffer, _T("%u"), wbuffer);
node_att_set(deviceNode, _T("TotalWidth"), buffer, NAFLG_FMT_NUMERIC);
}
// 0x0A Data Width
wbuffer = WORD_AT_OFFSET(memHeader, 0x0A);
if (0xFFFF != wbuffer) {
swprintf(buffer, _T("%u"), wbuffer);
node_att_set(deviceNode, _T("DataWidth"), buffer, NAFLG_FMT_NUMERIC);
}
// 0x0C Size
wbuffer = WORD_AT_OFFSET(memHeader, 0x0C);
if (wbuffer & 0x8000) {
// Size is in KB
wbuffer &= ~0x8000;
swprintf(buffer, _T("%u"), wbuffer);
node_att_set(deviceNode, _T("Size"), buffer, NAFLG_FMT_KBYTES);
}
else
{
// Size is in MB. Scale down to bytes
swprintf(buffer, _T("%llu"), (QWORD)wbuffer * 1048576LL);
node_att_set(deviceNode, _T("SizeBytes"), buffer, NAFLG_FMT_BYTES);
swprintf(buffer, _T("%u"), wbuffer);
node_att_set(deviceNode, _T("SizeMb"), buffer, NAFLG_FMT_MBYTES);
totalArrayMb += wbuffer;
if (wbuffer > 1024) {
swprintf(buffer, _T("%u"), wbuffer / 1024);
node_att_set(deviceNode, _T("SizeGb"), buffer, NAFLG_FMT_GBYTES);
}
}
// 0x0E Form Factor
node_att_set(deviceNode, _T("FormFactor"), SAFE_INDEX(MEM_FORM_FACTOR, BYTE_AT_OFFSET(memHeader, 0x0E)), 0);
// 0x0F Device Set
wbuffer = BYTE_AT_OFFSET(memHeader, 0x0F);
if (0xFF != wbuffer && 0x00 != wbuffer) {
swprintf(buffer, _T("0x%X"), wbuffer);
node_att_set(deviceNode, _T("DeviceSet"), buffer, NAFLG_FMT_HEX);
}
// 0x10 Device Locator
node_att_set(deviceNode, _T("DeviceLocator"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x10)), 0);
// 0x11 Device Locator
node_att_set(deviceNode, _T("BankLocator"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x11)), 0);
// 0x12 Memory Type
node_att_set(deviceNode, _T("Type"), SAFE_INDEX(MEM_TYPE, BYTE_AT_OFFSET(memHeader, 0x012)), 0);
// 0x13 Type Detail
unicode = NULL;
for (i = 0; i < ARRAYSIZE(MEM_TYPE_DETAIL); i++) {
if (CHECK_BIT(WORD_AT_OFFSET(memHeader, 0x13), i)) {
AppendMultiString(&unicode, MEM_TYPE_DETAIL[i]);
}
}
node_att_set_multi(deviceNode, _T("TypeDetails"), unicode, 0);
LocalFree(unicode);
//v 2.3+
if (2 < smbios->SMBIOSMajorVersion || (2 == smbios->SMBIOSMajorVersion && 3 <= smbios->SMBIOSMinorVersion)) {
// 0x15 Speed Mhz
swprintf(buffer, _T("%u"), WORD_AT_OFFSET(memHeader, 0x15));
node_att_set(deviceNode, _T("SpeedMhz"), buffer, NAFLG_FMT_NUMERIC);
// 0x17 Manufacturer
node_att_set(deviceNode, _T("Manufacturer"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x17)), 0);
// 0x18 Serial Number
node_att_set(deviceNode, _T("SerialNumber"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x18)), 0);
// 0x19 Asset Tag
node_att_set(deviceNode, _T("AssetTag"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x19)), 0);
// 0x1A Part Number
node_att_set(deviceNode, _T("PartNumber"), GetSmbiosString(memHeader, BYTE_AT_OFFSET(memHeader, 0x1A)), 0);
}
}
// Total array size
totalSystemMb += totalArrayMb;
swprintf(buffer, _T("%llu"), totalArrayMb);
node_att_set(node, _T("TotalInstalledMb"), buffer, NAFLG_FMT_MBYTES);
}
// Total system size
swprintf(buffer, _T("%llu"), totalSystemMb);
node_att_set(parentNode, _T("TotalInstalledMb"), buffer, NAFLG_FMT_MBYTES);
return parentNode;
}
