FbDev::FbDev()
{
mWidth = vinfo.xres;
mHeight = vinfo.yres;
mBitsPerPixel = vinfo.bits_per_pixel;
mBytesPerLine = finfo.line_length;
mVMemBase = (u8 *)mmap(0, finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fbdev_fd, 0);
if (mRotateType == Rotate0 || mRotateType == Rotate180) {
bool ypan = (vinfo.yres_virtual > vinfo.yres && finfo.ypanstep && !(FH(1) % finfo.ypanstep));
bool ywrap = (finfo.ywrapstep && !(FH(1) % finfo.ywrapstep));
if (ywrap && !(vinfo.vmode & FB_VMODE_YWRAP)) {
vinfo.vmode |= FB_VMODE_YWRAP;
ioctl(fbdev_fd, FBIOPUT_VSCREENINFO, &vinfo);
ywrap = (vinfo.vmode & FB_VMODE_YWRAP);
}
if ((ypan || ywrap) && !ioctl(fbdev_fd, FBIOPAN_DISPLAY, &vinfo)) {
if (ywrap) {
mScrollType = YWrap;
mOffsetMax = vinfo.yres_virtual - 1;
} else {
mScrollType = YPan;
mOffsetMax = vinfo.yres_virtual - vinfo.yres;
}
}
}
}
static
LONG
CDECL
comm_open(FILEPTR * f)
{
char deb[100];
NOT_USED(f);
/* Create and initialize internal file handle */
FH(f) = (LONG)KMALLOC(sizeof(FileHandle));
FH(f)->bytes_out = 0;
FH(f)->selected = 0;
FH(f)->queued = 0;
SPRINTF(deb,
"srv_comm_device: open: devinfo = 0x%lx, f = 0x%lx",
f->devinfo,
f);
TRACE(deb);
return 0;
}
int obj_delete(DAL_Context* ctx) {
// return stream_del(OS(ctx));
return stream_del_components(OS(ctx),
FH(ctx)->info.pre.host,
FH(ctx)->info.pre.bucket,
FH(ctx)->info.pre.objid);
}
Screen *Screen::createInstance()
{
if (!Font::instance() || !FW(1) || !FH(1)) {
fprintf(stderr, "init font error!\n");
return 0;
}
Screen *pScreen = 0;
s8 shm_info[2];
Config::instance()->getOption("shared-mem", shm_info, sizeof(shm_info));
#ifdef ENABLE_VESA
s8 buf[16];
Config::instance()->getOption("vesa-mode", buf, sizeof(buf));
if (!strcmp(buf, "list")) {
VesaDev::printModes();
return 0;
}
u32 mode = 0;
Config::instance()->getOption("vesa-mode", mode);
if (!mode) {
if (strlen(shm_info))
pScreen = FbShm::initFbShm();
else
pScreen = FbDev::initFbDev();
}
if (!pScreen) pScreen = VesaDev::initVesaDev(mode);
#else
if (strlen(shm_info))
pScreen = FbShm::initFbShm();
else
pScreen = FbDev::initFbDev();
#endif
if (!pScreen) return 0;
if (pScreen->mRotateType == Rotate90 || pScreen->mRotateType == Rotate270) {
u32 tmp = pScreen->mWidth;
pScreen->mWidth = pScreen->mHeight;
pScreen->mHeight = tmp;
}
if (!pScreen->mCols) pScreen->mCols = pScreen->mWidth / FW(1);
if (!pScreen->mRows) pScreen->mRows = pScreen->mHeight / FH(1);
if (!pScreen->mCols || !pScreen->mRows) {
fprintf(stderr, "font size is too huge!\n");
delete pScreen;
return 0;
}
pScreen->initFillDraw();
return pScreen;
}
void Screen::eraseMargin(bool top, u16 h)
{
if (mWidth % FW(1)) {
fillRect(FW(mCols), top ? 0 : FH(mRows - h), mWidth % FW(1), FH(h), 0);
}
if (mHeight % FH(1)) {
fillRect(0, FH(mRows), mWidth, mHeight % FH(1), 0);
}
}
static void draw_lookup_table()
{
set_im_window(LookupTableWin, lookup_table_win);
if (!lookup_table_win.w) return;
draw_margin(lookup_table_win, COLOR_BG);
unsigned i, x = lookup_table_win.x + MARGIN, y = lookup_table_win.y + MARGIN;
for (i = 0; ; i++) {
IBusText *text = ibus_lookup_table_get_candidate(lookup_table, i);
if (!text) break;
char buf[8];
snprintf(buf, sizeof(buf), "%d.", i + 1);
draw_text(x, y, COLOR_FG, COLOR_BG, buf, strlen(buf));
x += FW(2);
draw_text(x, y, i == lookup_table->cursor_pos ? COLOR_ACTIVE_CANDIDATE : COLOR_FG, COLOR_BG, text->text, strlen(text->text));
x += FW(text_width(text->text));
char space = ' ';
draw_text(x, y, COLOR_FG, COLOR_BG, &space, 1);
x += FW(1);
}
unsigned endx = lookup_table_win.x + lookup_table_win.w - MARGIN;
if (x < endx) {
Rectangle rect = { x, y, endx - x, FH(1) };
fill_rect(rect, COLOR_BG);
}
}
/*
** Description
** Reply to a client that has sent a message to the server
*/
void
Srv_reply(COMM_HANDLE handle,
void * out,
WORD bytes_out)
{
memcpy(FH(handle)->buf_out, out, bytes_out);
FH(handle)->bytes_out = bytes_out;
/* Wake waiting process */
if(FH(handle)->queued)
{
WAKE(IO_Q, (LONG)handle);
}
else if(FH(handle)->selected)
{
WAKESELECT(FH(handle)->selecting_proc);
}
}
bool Screen::move(u16 scol, u16 srow, u16 dcol, u16 drow, u16 w, u16 h)
{
if (!mScrollEnable || mScrollType == Redraw || scol != dcol) return false;
u16 top = MIN(srow, drow), bot = MAX(srow, drow) + h;
u16 left = scol, right = scol + w;
u32 noaccel_redraw_area = w * (bot - top - 1);
u32 accel_redraw_area = mCols * mRows - w * h;
if (noaccel_redraw_area <= accel_redraw_area) return false;
if (mRotateType == Rotate0 || mRotateType == Rotate270) mOffsetCur += FH((s32)srow - drow);
else mOffsetCur -= FH((s32)srow - drow);
bool redraw_all = false;
if (mScrollType == YPan || mScrollType == XPan) {
redraw_all = true;
if (mOffsetCur < 0) mOffsetCur = mOffsetMax;
else if ((u32)mOffsetCur > mOffsetMax) mOffsetCur = 0;
else redraw_all = false;
} else {
if (mOffsetCur < 0) mOffsetCur += mOffsetMax + 1;
else if ((u32)mOffsetCur > mOffsetMax) mOffsetCur -= mOffsetMax + 1;
}
setupOffset();
if (top) redraw(0, 0, mCols, top);
if (bot < mRows) redraw(0, bot, mCols, mRows - bot);
if (left > 0) redraw(0, top, left, bot - top - 1);
if (right < mCols) redraw(right, top, mCols - right, bot - top - 1);
if (redraw_all) {
eraseMargin(true, mRows);
} else {
eraseMargin(drow > srow, drow > srow ? (drow - srow) : (srow - drow));
}
return !redraw_all;
}
void Screen::drawText(u32 x, u32 y, u8 fc, u8 bc, u16 num, u16 *text, bool *dw)
{
u32 startx, fw = FW(1);
u16 startnum, *starttext;
bool *startdw, draw_space = false, draw_text = false;
for (; num; num--, text++, dw++, x += fw) {
if (*text == 0x20) {
if (draw_text) {
draw_text = false;
drawGlyphs(startx, y, fc, bc, startnum - num, starttext, startdw);
}
if (!draw_space) {
draw_space = true;
startx = x;
}
} else {
if (draw_space) {
draw_space = false;
fillRect(startx, y, x - startx, FH(1), bc);
}
if (!draw_text) {
draw_text = true;
starttext = text;
startdw = dw;
startnum = num;
startx = x;
}
if (*dw) x += fw;
}
}
if (draw_text) {
drawGlyphs(startx, y, fc, bc, startnum - num, starttext, startdw);
} else if (draw_space) {
fillRect(startx, y, x - startx, FH(1), bc);
}
}
void ImProxy::sendInfo()
{
Message msg;
msg.type = FbTermInfo;
msg.len = sizeof(msg);
msg.info.fontHeight = FH(1);
msg.info.fontWidth = FW(1);
msg.info.screenHeight = sh;
msg.info.screenWidth = sw;
write((s8 *)&msg, sizeof(msg));
}
void ImProxy::changeCursorPos(u16 col, u16 row)
{
if (!mConnected || !mActive) return;
Message msg;
msg.type = CursorPosition;
msg.len = sizeof(msg);
msg.cursor.x = FW(col);
msg.cursor.y = FH(row + 1);
write((s8 *)&msg, sizeof(msg));
}
static
LONG
CDECL
comm_close(FILEPTR * f,
WORD pid)
{
char deb[100];
NOT_USED(pid);
SPRINTF(deb, "srv_comm_device: close: devinfo = 0x%lx", f->devinfo);
TRACE(deb);
if((f->links <= 0) && (FH(f) != 0))
{
KFREE(FH(f));
FH(f) = 0;
}
return 0;
}
void ImProxy::setImWin(u32 id, Rectangle &rect)
{
if (id >= NR_IM_WINS) return;
if (!rect.w || !rect.h || rect.x >= sw || rect.y >= sh)
memset(&rect, 0, sizeof(rect));
if (rect.x + rect.w >= sw) rect.w = sw - rect.x;
if (rect.y + rect.h >= sh) rect.h = sh - rect.y;
bool active = (FbShellManager::instance()->activeShell() == mShell);
if (active && intersectRectangles(mWins[id], rect) != Inside) {
Rectangle oldrect = mWins[id];
memset(&mWins[id], 0, sizeof(rect));
mValidWinNum--;
u32 endx = oldrect.x + oldrect.w, endy = oldrect.y + oldrect.h;
u16 col = oldrect.x / FW(1);
u16 row = oldrect.y / FH(1);
u16 endcol = endx / FW(1);
u16 endrow = endy / FH(1);
mShell->expose(col, row, endcol - col + 1, endrow - row + 1);
}
if (!mWins[id].w && rect.w) mValidWinNum++;
mWins[id] = rect;
if (active) {
Screen::instance()->enableScroll(!mValidWinNum);
}
for (MsgList::iterator it = mWinMsgs[id].begin(); it != mWinMsgs[id].end(); it++) {
delete[] (s8 *)(*it);
}
mWinMsgs[id].clear();
}
double Newton::solucao(double x) {
float ff, dff;
int n; //contador
ff = 1; //auxiliares
n = 0;
while ((std::abs(ff) > e) && (n < 1000)) {
ff = FH(x);
dff = dF(x);
x = x - ff / dff;
n++;
}
return x;
}
static
LONG
CDECL
comm_read(FILEPTR * f,
BYTE * buf,
LONG nbytes)
{
int actual_bytes;
TRACE("srv_comm_device: read");
if(FH(f)->bytes_out == 0)
{
TRACE("Put in IO_Q");
FH(f)->queued = 1;
do
{
SLEEP(IO_Q, (LONG)f);
} while(FH(f)->bytes_out == 0);
FH(f)->queued = 0;
}
TRACE("srv_comm_device: read: 2");
actual_bytes = (FH(f)->bytes_out < nbytes) ? FH(f)->bytes_out : nbytes;
TRACE("srv_comm_device: read: 3");
memcpy(buf, FH(f)->buf_out, actual_bytes);
TRACE("srv_comm_device: read: 4");
/* Truncate data that wouldn't fit */
FH(f)->bytes_out = 0;
return actual_bytes;
}
void PROFILE::RodSection199( int QuantityDbl, TYPE_DATA_SF *f, BYTE & Control )
{
if ( QuantityDbl != 13 ) { Control = 1; return; }
FullInfo.E = FH(1);
FullInfo.nu = FH(2);
EF = FH(3); EIY = FH(4); EIZ = FH(5);
GKR = FH(6); GFY = FH(7); GFZ = FH(8);
YI1 = FH(9); YI2 = FH(10); ZI1 = FH(11); ZI2 = FH(12);
FullInfo.Alfa = FH(13);
}
inline double Newton::dF(double x) {
return ((FH(x + dx / 2) - FH(x - dx / 2)) / dx);
}
/* Hash a single block, 64 bytes long and 4-byte aligned. */
static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
{
uint32_t correct_words[16];
const uint32_t *words = buffer;
# if MD5_SIZE_VS_SPEED > 0
static const uint32_t C_array[] = {
/* round 1 */
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
/* round 2 */
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
/* round 3 */
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
/* round 4 */
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
};
static const char P_array[] ALIGN1 = {
# if MD5_SIZE_VS_SPEED > 1
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
# endif /* MD5_SIZE_VS_SPEED > 1 */
1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
};
# if MD5_SIZE_VS_SPEED > 1
static const char S_array[] ALIGN1 = {
7, 12, 17, 22,
5, 9, 14, 20,
4, 11, 16, 23,
6, 10, 15, 21
};
# endif /* MD5_SIZE_VS_SPEED > 1 */
# endif
uint32_t A = ctx->A;
uint32_t B = ctx->B;
uint32_t C = ctx->C;
uint32_t D = ctx->D;
/* Process all bytes in the buffer with 64 bytes in each round of
the loop. */
uint32_t *cwp = correct_words;
uint32_t A_save = A;
uint32_t B_save = B;
uint32_t C_save = C;
uint32_t D_save = D;
# if MD5_SIZE_VS_SPEED > 1
# define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
const uint32_t *pc;
const char *pp;
const char *ps;
int i;
uint32_t temp;
for (i = 0; i < 16; i++) {
cwp[i] = SWAP_LE32(words[i]);
}
words += 16;
# if MD5_SIZE_VS_SPEED > 2
pc = C_array;
pp = P_array;
ps = S_array - 4;
for (i = 0; i < 64; i++) {
if ((i & 0x0f) == 0)
ps += 4;
temp = A;
switch (i >> 4) {
case 0:
temp += FF(B, C, D);
break;
case 1:
temp += FG(B, C, D);
break;
case 2:
temp += FH(B, C, D);
break;
case 3:
temp += FI(B, C, D);
}
temp += cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
# else
pc = C_array;
pp = P_array;
ps = S_array;
for (i = 0; i < 16; i++) {
temp = A + FF(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FG(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FH(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FI(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
# endif /* MD5_SIZE_VS_SPEED > 2 */
# else
/* First round: using the given function, the context and a constant
the next context is computed. Because the algorithms processing
unit is a 32-bit word and it is determined to work on words in
little endian byte order we perhaps have to change the byte order
before the computation. To reduce the work for the next steps
we store the swapped words in the array CORRECT_WORDS. */
# define OP(a, b, c, d, s, T) \
do { \
a += FF (b, c, d) + (*cwp++ = SWAP_LE32(*words)) + T; \
++words; \
CYCLIC (a, s); \
a += b; \
} while (0)
/* It is unfortunate that C does not provide an operator for
cyclic rotation. Hope the C compiler is smart enough. */
/* gcc 2.95.4 seems to be --aaronl */
# define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
/* Before we start, one word to the strange constants.
They are defined in RFC 1321 as
T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
*/
# if MD5_SIZE_VS_SPEED == 1
const uint32_t *pc;
const char *pp;
int i;
# endif /* MD5_SIZE_VS_SPEED */
/* Round 1. */
# if MD5_SIZE_VS_SPEED == 1
pc = C_array;
for (i = 0; i < 4; i++) {
OP(A, B, C, D, 7, *pc++);
OP(D, A, B, C, 12, *pc++);
OP(C, D, A, B, 17, *pc++);
OP(B, C, D, A, 22, *pc++);
}
# else
OP(A, B, C, D, 7, 0xd76aa478);
OP(D, A, B, C, 12, 0xe8c7b756);
OP(C, D, A, B, 17, 0x242070db);
OP(B, C, D, A, 22, 0xc1bdceee);
OP(A, B, C, D, 7, 0xf57c0faf);
OP(D, A, B, C, 12, 0x4787c62a);
OP(C, D, A, B, 17, 0xa8304613);
OP(B, C, D, A, 22, 0xfd469501);
OP(A, B, C, D, 7, 0x698098d8);
OP(D, A, B, C, 12, 0x8b44f7af);
OP(C, D, A, B, 17, 0xffff5bb1);
OP(B, C, D, A, 22, 0x895cd7be);
OP(A, B, C, D, 7, 0x6b901122);
OP(D, A, B, C, 12, 0xfd987193);
OP(C, D, A, B, 17, 0xa679438e);
OP(B, C, D, A, 22, 0x49b40821);
# endif /* MD5_SIZE_VS_SPEED == 1 */
/* For the second to fourth round we have the possibly swapped words
in CORRECT_WORDS. Redefine the macro to take an additional first
argument specifying the function to use. */
# undef OP
# define OP(f, a, b, c, d, k, s, T) \
do { \
a += f (b, c, d) + correct_words[k] + T; \
CYCLIC (a, s); \
a += b; \
} while (0)
/* Round 2. */
# if MD5_SIZE_VS_SPEED == 1
pp = P_array;
for (i = 0; i < 4; i++) {
OP(FG, A, B, C, D, (int) (*pp++), 5, *pc++);
OP(FG, D, A, B, C, (int) (*pp++), 9, *pc++);
OP(FG, C, D, A, B, (int) (*pp++), 14, *pc++);
OP(FG, B, C, D, A, (int) (*pp++), 20, *pc++);
}
# else
OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
OP(FG, D, A, B, C, 6, 9, 0xc040b340);
OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
OP(FG, D, A, B, C, 10, 9, 0x02441453);
OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
# endif /* MD5_SIZE_VS_SPEED == 1 */
/* Round 3. */
# if MD5_SIZE_VS_SPEED == 1
for (i = 0; i < 4; i++) {
OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++);
OP(FH, D, A, B, C, (int) (*pp++), 11, *pc++);
OP(FH, C, D, A, B, (int) (*pp++), 16, *pc++);
OP(FH, B, C, D, A, (int) (*pp++), 23, *pc++);
}
# else
OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
OP(FH, D, A, B, C, 8, 11, 0x8771f681);
OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
OP(FH, B, C, D, A, 6, 23, 0x04881d05);
OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
# endif /* MD5_SIZE_VS_SPEED == 1 */
/* Round 4. */
# if MD5_SIZE_VS_SPEED == 1
for (i = 0; i < 4; i++) {
OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++);
OP(FI, D, A, B, C, (int) (*pp++), 10, *pc++);
OP(FI, C, D, A, B, (int) (*pp++), 15, *pc++);
OP(FI, B, C, D, A, (int) (*pp++), 21, *pc++);
}
# else
OP(FI, A, B, C, D, 0, 6, 0xf4292244);
OP(FI, D, A, B, C, 7, 10, 0x432aff97);
OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
OP(FI, C, D, A, B, 6, 15, 0xa3014314);
OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
# endif /* MD5_SIZE_VS_SPEED == 1 */
# endif /* MD5_SIZE_VS_SPEED > 1 */
/* Add the starting values of the context. */
A += A_save;
B += B_save;
C += C_save;
D += D_save;
/* Put checksum in context given as argument. */
ctx->A = A;
ctx->B = B;
ctx->C = C;
ctx->D = D;
}
int ReadVarFromCDF(int cdfid, int vid, VarDesc *v, size_t **d, size_t *coords, BOOL bigdim)
{
int lnx, lny, offs, startloop;
int startoff = ((v->option & STARTING_WITH_ZERO) != 0);
double tmp;
nc_type vartype;
nc_inq_vartype(cdfid, vid, &vartype);
lnx = nxm + bigdim + startoff; lny = nym + bigdim + startoff;
offs = !startoff && !bigdim;
startloop = !startoff && bigdim;
switch (v->storetype) {
case GRID_VAL :
if (!g[v->v.et]) g[v->v.et] = (double *)calloc(mesh, sizeof(double));
for (*d[2] = 0; *d[2] < nz; (*d[2])++)
for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
for (*d[1] = startloop; *d[1] < lny; (*d[1])++)
NCGET(g[v->v.et][F(*d[2],*d[0]+offs,*d[1]+offs)]);
break;
case DOUBLE_PTR :
switch (v->dims) {
case (ALL_DIM) :
for (*d[2] = 0; *d[2] < nz; (*d[2])++)
for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
for (*d[1] = startloop; *d[1] < lny; (*d[1])++)
NCGET(v->v.d[F(*d[2],*d[0]+offs,*d[1]+offs)]);
break;
case (X_DIM | Y_DIM) :
for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
for (*d[1] = 0; *d[1] < lny; (*d[1])++)
NCGET(v->v.d[FH(*d[0]+offs,*d[1]+offs)]);
break;
case (Y_DIM | Z_DIM) :
for (*d[2] = 0; *d[2] < nz; (*d[2])++)
for (*d[1] = startloop; *d[1] < lny; (*d[1])++)
NCGET(v->v.d[FH(*d[2],*d[1]+offs)]);
break;
case (X_DIM | Z_DIM) :
for (*d[2] = 0; *d[2] < nz; (*d[2])++)
for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
NCGET(v->v.d[*d[2] * xrow + *d[0]+offs]);
break;
case X_DIM : for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
NCGET(v->v.d[*d[0]+offs]);
break;
case Y_DIM : for (*d[1] = startloop; *d[1] < lny; (*d[1])++)
NCGET(v->v.d[*d[1]+offs]);
break;
case Z_DIM : for (*d[2] = 0; *d[2] < nz; (*d[2])++)
NCGET(v->v.d[*d[2]]);
break;
case COUNT_DIM :
for (*d[4] = 0; *d[4] < v->ncoord; (*d[4])++)
NCGET(v->v.d[*d[4]]);
break;
case 0 : NCGET(*v->v.d); break;
default : InputError(ERROR, "Internal implementation error (2)");
break;
}
break;
case GROUND_PARAM :
for (*d[0] = startloop; *d[0] < lnx; (*d[0])++)
for (*d[1] = startloop; *d[1] < lny; (*d[1])++)
NCGET(v->v.g[(*d[0]+offs)*row+*d[1]+offs].Tg[0]);
break;
default :
InputError(ERROR, "Variable %s cannot be set via CDF-File. (Wrong-Type)", v->name);
return (1);
}
return (0);
}
int obj_init(DAL_Context* ctx, DAL* dal, void* fh) {
default_dal_ctx_init(ctx, dal, fh);
return stream_init(OS(ctx), NULL, FH(ctx));
}
int obj_update_object_location(DAL_Context* ctx) {
return update_url(OS(ctx), &FH(ctx)->info);
}
static void md5_process_block64(md5_ctx_t *ctx)
{
/* Before we start, one word to the strange constants.
They are defined in RFC 1321 as
T[i] = (int)(4294967296.0 * fabs(sin(i))), i=1..64
*/
static const uint32_t C_array[] = {
/* round 1 */
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
/* round 2 */
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
/* round 3 */
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
/* round 4 */
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
};
static const char P_array[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
};
uint32_t *words = (void*) ctx->wbuffer;
uint32_t A = ctx->hash[0];
uint32_t B = ctx->hash[1];
uint32_t C = ctx->hash[2];
uint32_t D = ctx->hash[3];
/* 2 or 3 */
static const char S_array[] = {
7, 12, 17, 22,
5, 9, 14, 20,
4, 11, 16, 23,
6, 10, 15, 21
};
const uint32_t *pc;
const char *pp;
const char *ps;
int i;
uint32_t temp;
/* MD5_SIZE_VS_SPEED == 2 */
pc = C_array;
pp = P_array;
ps = S_array;
for (i = 0; i < 16; i++) {
temp = A + FF(B, C, D) + words[(int) (*pp++)] + *pc++;
temp = rotl32(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FG(B, C, D) + words[(int) (*pp++)] + *pc++;
temp = rotl32(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FH(B, C, D) + words[(int) (*pp++)] + *pc++;
temp = rotl32(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FI(B, C, D) + words[(int) (*pp++)] + *pc++;
temp = rotl32(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
/* Add checksum to the starting values */
ctx->hash[0] += A;
ctx->hash[1] += B;
ctx->hash[2] += C;
ctx->hash[3] += D;
}
/* Hash a single block, 64 bytes long and 4-byte aligned. */
static void md5_hash_block(const void *buffer, md5_ctx_t *ctx)
{
uint32_t correct_words[16];
const uint32_t *words = buffer;
static const uint32_t C_array[] = {
/* round 1 */
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
/* round 2 */
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
/* round 3 */
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
/* round 4 */
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
};
static const char P_array[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
};
static const char S_array[] = {
7, 12, 17, 22,
5, 9, 14, 20,
4, 11, 16, 23,
6, 10, 15, 21
};
uint32_t A = ctx->A;
uint32_t B = ctx->B;
uint32_t C = ctx->C;
uint32_t D = ctx->D;
uint32_t *cwp = correct_words;
# define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
const uint32_t *pc;
const char *pp;
const char *ps;
int i;
uint32_t temp;
for (i = 0; i < 16; i++) {
cwp[i] = SWAP_LE32(words[i]);
}
words += 16;
pc = C_array;
pp = P_array;
ps = S_array;
for (i = 0; i < 16; i++) {
temp = A + FF(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FG(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FH(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ps += 4;
for (i = 0; i < 16; i++) {
temp = A + FI(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC(temp, ps[i & 3]);
temp += B;
A = D;
D = C;
C = B;
B = temp;
}
ctx->A += A;
ctx->B += B;
ctx->C += C;
ctx->D += D;
}
void Screen::drawGlyph(u32 x, u32 y, u8 fc, u8 bc, u16 code, bool dw)
{
if (x >= mWidth || y >= mHeight) return;
s32 w = (dw ? FW(2) : FW(1)), h = FH(1);
if (x + w > mWidth) w = mWidth - x;
if (y + h > mHeight) h = mHeight - y;
Font::Glyph *glyph = (Font::Glyph *)Font::instance()->getGlyph(code);
if (!glyph) {
fillRect(x, y, w, h, bc);
return;
}
s32 top = glyph->top;
if (top < 0) top = 0;
s32 left = glyph->left;
if ((s32)x + left < 0) left = -x;
s32 width = glyph->width;
if (width > w - left) width = w - left;
if ((s32)x + left + width > (s32)mWidth) width = mWidth - ((s32)x + left);
if (width < 0) width = 0;
s32 height = glyph->height;
if (height > h - top) height = h - top;
if (y + top + height > mHeight) height = mHeight - (y + top);
if (height < 0) height = 0;
if (top) fillRect(x, y, w, top, bc);
if (left > 0) fillRect(x, y + top, left, height, bc);
s32 right = width + left;
if (w > right) fillRect((s32)x + right, y + top, w - right, height, bc);
s32 bot = top + height;
if (h > bot) fillRect(x, y + bot, w, h - bot, bc);
x += left;
y += top;
if (x >= mWidth || y >= mHeight || !width || !height) return;
u32 nwidth = width, nheight = height;
rotateRect(x, y, nwidth, nheight);
u8 *pixmap = glyph->pixmap;
u32 wdiff = glyph->width - width, hdiff = glyph->height - height;
if (wdiff) {
if (mRotateType == Rotate180) pixmap += wdiff;
else if (mRotateType == Rotate270) pixmap += wdiff * glyph->pitch;
}
if (hdiff) {
if (mRotateType == Rotate90) pixmap += hdiff;
else if (mRotateType == Rotate180) pixmap += hdiff * glyph->pitch;
}
adjustOffset(x, y);
for (; nheight--; y++, pixmap += glyph->pitch) {
if ((mScrollType == YWrap) && y > mOffsetMax) y -= mOffsetMax + 1;
(this->*draw)(x, y, nwidth, fc, bc, pixmap);
}
}