/**
* Print a char in a certain console.
*
* @param con The console to which the char is printed.
* @param ch The char to print.
*****************************************************************************/
PUBLIC void out_char(CONSOLE* con, char ch)
{
disable_int();
u8* pch = (u8*)(V_MEM_BASE + con->cursor * 2);
assert(con->cursor - con->orig < con->con_size);
/*
* calculate the coordinate of cursor in current console (not in
* current screen)
*/
int cursor_x = (con->cursor - con->orig) % SCR_WIDTH;
int cursor_y = (con->cursor - con->orig) / SCR_WIDTH;
switch(ch) {
case '\n':
con->cursor = con->orig + SCR_WIDTH * (cursor_y + 1);
break;
case '\b':
if (con->cursor > con->orig) {
con->cursor--;
*(pch - 2) = ' ';
*(pch - 1) = DEFAULT_CHAR_COLOR;
}
break;
default:
*pch++ = ch;
*pch++ = DEFAULT_CHAR_COLOR;
con->cursor++;
break;
}
if (con->cursor - con->orig >= con->con_size) {
cursor_x = (con->cursor - con->orig) % SCR_WIDTH;
cursor_y = (con->cursor - con->orig) / SCR_WIDTH;
int cp_orig = con->orig + (cursor_y + 1) * SCR_WIDTH - SCR_SIZE;
w_copy(con->orig, cp_orig, SCR_SIZE - SCR_WIDTH);
con->crtc_start = con->orig;
con->cursor = con->orig + (SCR_SIZE - SCR_WIDTH) + cursor_x;
clear_screen(con->cursor, SCR_WIDTH);
if (!con->is_full)
con->is_full = 1;
}
assert(con->cursor - con->orig < con->con_size);
while (con->cursor >= con->crtc_start + SCR_SIZE ||
con->cursor < con->crtc_start) {
scroll_screen(con, SCR_UP);
clear_screen(con->cursor, SCR_WIDTH);
}
flush(con);
enable_int();
}
void le_soa_step_x(le_task *t)
{
assert(t->stype == ST_SOA);
int i, j;
const real k1 = t->dt * t->mat.c1 / t->h.x;
const real k2 = t->dt * t->mat.c2 / t->h.x;
#define soa_omega_x(i, j, k) \
{ \
const real nv = soa_vx(i, j); \
const real N00T = soa_sxx(i, j) * t->mat.irhoc1; \
const real n1v = soa_vy(i, j); \
const real N01T = soa_sxy(i, j) * t->mat.irhoc2; \
\
w1[k + 2] = nv - N00T; \
w2[k + 2] = nv + N00T; \
w3[k + 2] = n1v - N01T; \
w4[k + 2] = n1v + N01T; \
}
for (j = 0; j < t->n.y; j++) {
real w1[5], w2[5], w3[5], w4[5];
soa_omega_x(0, j, 0);
soa_omega_x(1, j, 1);
soa_omega_x(2, j, 2);
#define w_init(w) w[0] = w[1] = w[2];
w_init(w1);
w_init(w2);
w_init(w3);
w_init(w4);
#undef w_init
for (i = 0; i < t->n.x; i++) {
real d1 = tvd2(k1, w1[0], w1[1], w1[2], w1[3]) - w1[2];
real d2 = tvd2(k1, w2[4], w2[3], w2[2], w2[1]) - w2[2];
real d3 = tvd2(k2, w3[0], w3[1], w3[2], w3[3]) - w3[2];
real d4 = tvd2(k2, w4[4], w4[3], w4[2], w4[1]) - w4[2];
d1 *= 0.5;
d2 *= 0.5;
d3 *= 0.5;
d4 *= 0.5;
soa_vx(i, j) += d1 + d2;
soa_vy(i, j) += d3 + d4;
soa_sxx(i, j) += (d2 - d1) * t->mat.rhoc1;
soa_syy(i, j) += (d2 - d1) * t->mat.rhoc3;
soa_sxy(i, j) += t->mat.rhoc2 * (d4 - d3);
//reconstruct(w_2, w_1, w, w1, w2, k1, k2, &d);
//inc_x(&t->mat, &gind(i, j), &d);
#define w_copy(w) \
w[0] = w[1];\
w[1] = w[2];\
w[2] = w[3];\
w[3] = w[4];
w_copy(w1);
w_copy(w2);
w_copy(w3);
w_copy(w4);
#undef w_copy
if (i < t->n.x - 3) soa_omega_x(i + 3, j, 2);
}
}
}
/*****************************************************************************
* do_escape
*****************************************************************************/
PRIVATE void do_escape(CONSOLE * con, char c)
{
int value, m, n;
unsigned src, dst, count;
//int *paramp;
int cursor_x = (con->cursor - con->orig) % SCR_WIDTH;
int cursor_y = (con->cursor - con->orig) / SCR_WIDTH;
flush(con);
if (con->c_esc_intro == '\0') {
switch (c) {
case 'M': /* Reverse Index */
if (cursor_y == 0) {
scroll_screen(con, SCR_DN);
} else {
con->cursor = con->orig + SCR_WIDTH * (cursor_y - 1);
}
flush(con);
break;
default: break;
}
} else
if (con->c_esc_intro == '[') {
value = con->c_esc_params[0];
switch (c) {
case 'A': /* ESC [nA moves up n lines */
n = (value == 0 ? 1 : value);
con->cursor = con->orig + SCR_WIDTH * (cursor_y - n);
flush(con);
break;
case 'B': /* ESC [nB moves down n lines */
n = (value == 0 ? 1 : value);
con->cursor = con->orig + SCR_WIDTH * (cursor_y + n);
flush(con);
break;
case 'C': /* ESC [nC moves right n spaces */
n = (value == 0 ? 1 : value);
con->cursor = con->orig + SCR_WIDTH * cursor_y + cursor_x + n;
flush(con);
break;
case 'D': /* ESC [nD moves left n spaces */
n = (value == 0 ? 1 : value);
con->cursor = con->orig + SCR_WIDTH * cursor_y + cursor_x - n;
flush(con);
break;
case 'H': /* ESC [m;nH" moves cursor to (m,n) */
m = con->c_esc_params[0] - 1;
n = con->c_esc_params[1] - 1;
con->cursor = con->orig + SCR_WIDTH * m + n;
flush(con);
break;
case 'J': /* ESC [sJ clears in display */
switch (value) {
case 0: /* Clear from cursor to end of screen */
count = SCR_SIZE - (con->cursor - con->orig);
dst = con->cursor;
break;
case 1: /* Clear from start of screen to cursor */
count = con->cursor - con->orig;
dst = con->orig;
break;
case 2: /* Clear entire screen */
count = SCR_SIZE;
dst = con->orig;
break;
default: /* Do nothing */
count = 0;
dst = con->orig;
}
clear_screen(dst, count);
break;
case 'K': /* ESC [sK clears line from cursor */
switch (value) {
case 0: /* Clear from cursor to end of line */
count = SCR_WIDTH - cursor_x;
dst = con->cursor;
break;
case 1: /* Clear from beginning of line to cursor */
count = cursor_x;
dst = con->cursor - cursor_x;
break;
case 2: /* Clear entire line */
count = SCR_WIDTH;
dst = con->cursor - cursor_x;
break;
default: /* Do nothing */
count = 0;
dst = con->cursor;
}
clear_screen(dst, count);
break;
case 'L': /* ESC [nL inserts n lines at cursor */
n = value;
if (n < 1) n = 1;
if (n > (25 - cursor_y))
n = 25 - cursor_y;
src = con->orig + cursor_y * SCR_WIDTH;
dst = src + n * SCR_WIDTH;
count = n * SCR_WIDTH;
w_copy(dst, src, count);
clear_screen(src, count);
break;
case 'M': /* ESC [nM deletes n lines at cursor */
n = value;
if (n < 1) n = 1;
if (n > (25 - cursor_y))
n = 25 - cursor_y;
dst = con->orig + cursor_y * SCR_WIDTH;
src = dst + n * SCR_WIDTH;
count = (25 - cursor_y - n) * SCR_WIDTH;
w_copy(dst, src, count);
clear_screen(dst + count, n * SCR_WIDTH);
break;
case '@': /* ESC [n@ inserts n chars at cursor */
n = value;
if (n < 1) n = 1;
if (n > (SCR_WIDTH - cursor_x))
n = SCR_WIDTH - cursor_x;
src = con->cursor;
dst = src + n;
count = SCR_WIDTH - cursor_x - n;
w_copy(dst, src, count);
clear_screen(src, n);
break;
case 'P': /* ESC [nP deletes n chars at cursor */
n = value;
if (n < 1) n = 1;
if (n > (SCR_WIDTH - cursor_x))
n = SCR_WIDTH - cursor_x;
dst = con->cursor;
src = dst + n;
count = SCR_WIDTH - cursor_x - n;
w_copy(dst, src, count);
clear_screen(dst + count, n);
break;
}
}
con->c_esc_state = 0;
}
void le_soa_step_y(le_task *t)
{
assert(t->stype == ST_SOA);
int i, j;
const real k1 = t->dt * t->mat.c1 / t->h.y;
const real k2 = t->dt * t->mat.c2 / t->h.y;
real *w1[5], *w2[5], *w3[5], *w4[5];
#define w_malloc(w)\
w[0] = (real*)malloc(sizeof(real) * t->n.x);\
w[1] = (real*)malloc(sizeof(real) * t->n.x);\
w[2] = (real*)malloc(sizeof(real) * t->n.x);\
w[3] = (real*)malloc(sizeof(real) * t->n.x);\
w[4] = (real*)malloc(sizeof(real) * t->n.x);
w_malloc(w1);
w_malloc(w2);
w_malloc(w3);
w_malloc(w4);
#undef w_malloc
#define soa_omega_y(i, j, k) \
{ \
const real nv = soa_vy(i, j); \
const real N00T = soa_syy(i, j) * t->mat.irhoc1; \
const real n1v = soa_vx(i, j); \
const real N01T = soa_sxy(i, j) * t->mat.irhoc2; \
\
w1[k + 2][i] = nv - N00T; \
w2[k + 2][i] = nv + N00T; \
w3[k + 2][i] = n1v - N01T; \
w4[k + 2][i] = n1v + N01T; \
}
for (i = 0; i < t->n.x; i++) {
soa_omega_y(i, 0, 0);
soa_omega_y(i, 1, 1);
soa_omega_y(i, 2, 2);
}
#define w_init(w)\
for (i = 0; i < t->n.x; i++) {\
w[0][i] = w[1][i] = w[2][i];\
}
w_init(w1);
w_init(w2);
w_init(w3);
w_init(w4);
#undef w_init
for (j = 0; j < t->n.y; j++) {
for (i = 0; i < t->n.x; i++) {
real d1 = tvd2(k1, w1[0][i], w1[1][i], w1[2][i], w1[3][i]) - w1[2][i];
real d2 = tvd2(k1, w2[4][i], w2[3][i], w2[2][i], w2[1][i]) - w2[2][i];
real d3 = tvd2(k2, w3[0][i], w3[1][i], w3[2][i], w3[3][i]) - w3[2][i];
real d4 = tvd2(k2, w4[4][i], w4[3][i], w4[2][i], w4[1][i]) - w4[2][i];
d1 *= 0.5;
d2 *= 0.5;
d3 *= 0.5;
d4 *= 0.5;
soa_vy(i, j) += d1 + d2;
soa_vx(i, j) += d3 + d4;
soa_syy(i, j) += (d2 - d1) * t->mat.rhoc1;
soa_sxx(i, j) += (d2 - d1) * t->mat.rhoc3;
soa_sxy(i, j) += t->mat.rhoc2 * (d4 - d3);
}
#define w_copy(w)\
{\
real *t = w[0];\
w[0] = w[1];\
w[1] = w[2];\
w[2] = w[3];\
w[3] = w[4];\
w[4] = t;\
}
w_copy(w1);
w_copy(w2);
w_copy(w3);
w_copy(w4);
#undef w_copy
if (j < t->n.y - 3) {
for (i = 0; i < t->n.x; i++) {
soa_omega_y(i, j + 3, 2);
}
}
}
#define w_free(w)\
free(w[0]);\
free(w[1]);\
free(w[2]);\
free(w[3]);\
free(w[4]);
w_free(w1);
w_free(w2);
w_free(w3);
w_free(w4);
#undef w_free
}
/**
* Print a char in a certain console.
*
* @param con The console to which the char is printed.
* @param ch The char to print.
*****************************************************************************/
PUBLIC void out_char(TTY* tty, char ch)
{
CONSOLE * con = tty->tty_dev;
u8* pch = (u8*)(V_MEM_BASE + con->cursor * 2);
assert(con->cursor - con->orig < con->con_size);
/*
* calculate the coordinate of cursor in current console (not in
* current screen)
*/
int cursor_x = (con->cursor - con->orig) % SCR_WIDTH;
int cursor_y = (con->cursor - con->orig) / SCR_WIDTH;
if (con->c_esc_state > 0) { /* check for escape sequences */
parse_escape(con, ch);
return;
}
switch(ch) {
case 000:
return;
case 007: /* beep */
//beep();
break;
case '\b': /* backspace */
if (con->cursor > con->orig) {
con->cursor--;
*(pch - 2) = ' ';
*(pch - 1) = DEFAULT_CHAR_COLOR;
}
break;
case '\n': /* line feed */
if ((con->con_tty->tty_termios.c_oflag & (OPOST|ONLCR))
== (OPOST|ONLCR)) {
con->cursor = con->orig + SCR_WIDTH * cursor_y;
}
case 013: /* CTRL-K */
case 014: /* CTRL-L */
con->cursor = con->cursor + SCR_WIDTH;
break;
case '\r': /* carriage return */
con->cursor = con->orig + SCR_WIDTH * cursor_y;
break;
case '\t': /* tab */
con->cursor = con->orig + SCR_WIDTH * cursor_y + ((cursor_x + TAB_SIZE) & ~TAB_MASK);
break;
case 033: /* ESC - start of an escape sequence */
con->c_esc_state = 1;
return;
default:
*pch++ = ch;
*pch++ = DEFAULT_CHAR_COLOR;
con->cursor++;
break;
}
if (con->cursor - con->orig >= con->con_size) {
cursor_x = (con->cursor - con->orig) % SCR_WIDTH;
cursor_y = (con->cursor - con->orig) / SCR_WIDTH;
int cp_orig = con->orig + (cursor_y + 1) * SCR_WIDTH - SCR_SIZE;
w_copy(con->orig, cp_orig, SCR_SIZE - SCR_WIDTH);
con->crtc_start = con->orig;
con->cursor = con->orig + (SCR_SIZE - SCR_WIDTH) + cursor_x;
clear_screen(con->cursor, SCR_WIDTH);
if (!con->is_full)
con->is_full = 1;
}
assert(con->cursor - con->orig < con->con_size);
while (con->cursor >= con->crtc_start + SCR_SIZE ||
con->cursor < con->crtc_start) {
scroll_screen(con, SCR_UP);
clear_screen(con->cursor, SCR_WIDTH);
}
flush(con);
}
