void shift_screen() {
int x, y;
for (y = 0; y < HEIGHT - 1; y++) {
for (x = 0; x < WIDTH; x++) {
set_char(x, y, get_char(x, y + 1));
}
}
for (x = 0; x < WIDTH; x++) {
set_char(x, HEIGHT - 1, ' ');
}
}
void draw_frame(struct terminal *t, int x, int y, int xw, int yw, unsigned c, int w)
{
int *p = w > 1 ? p2 : p1;
c |= ATTR_FRAME;
set_char(t, x, y, c+p[0]);
set_char(t, x+xw-1, y, c+p[1]);
set_char(t, x, y+yw-1, c+p[2]);
set_char(t, x+xw-1, y+yw-1, c+p[3]);
fill_area(t, x, y+1, 1, yw-2, c+p[4]);
fill_area(t, x+xw-1, y+1, 1, yw-2, c+p[4]);
fill_area(t, x+1, y, xw-2, 1, c+p[5]);
fill_area(t, x+1, y+yw-1, xw-2, 1, c+p[5]);
}
JSON *string_type_parse(){
char *op = str_addr();
op++;
next_char();
while (str_value() != '"'){
assert(is_end()==0);
next_char();
}
set_char(0);
JSON *obj = CreateString(op);
set_char('"');
next_char();
//puts(s);
return obj;
}
int mostFrequentCharOpt2(char str[], int size) //Char to Int
{
int result[RESULT_SIZE] = {0};
int frequent_char = 0;
int current_char_frequency = 0;
int char_frequency = 0;
for(int i = 0; i<size; i++)
{
set_char(str[i], result);
}
for(int i = 0; i<RESULT_SIZE; i++)
{
current_char_frequency = result[i];
if(current_char_frequency >= char_frequency)
{
char_frequency = current_char_frequency;
frequent_char = i;
}
}
return frequent_char;
}
value& value::operator=(const value& aOther) {
switch (aOther.mType)
{
case CHAR_T:
set_char(aOther.mChar);
break;
case BOOL_T:
set_bool(aOther.mBool);
break;
case UNSIGNED_T:
set_unsigned(aOther.mUnsigned);
break;
case SIGNED_T:
set_signed(aOther.mSigned);
break;
case FLOAT_T:
set_float(aOther.mFloat);
break;
case POINTER_T:
set_pointer(aOther.mPointer);
break;
case STRING_T:
set_string(*static_cast<const c_string*>(aOther.mPointer));
break;
case ARRAY_T:
set_array(*static_cast<const container<value>*>(aOther.mPointer));
break;
case OBJECT_T:
set_object(*static_cast<const std::map<c_string, value>*>(aOther.mPointer));
break;
default:
break;
}
return *this;
}
char mostFrequentCharOpt1(char str[], int size)
{
int result[RESULT_SIZE] = {0};
char frequent_char = '\0';
int current_char_frequency = 256;
int char_frequency = 0;
for(int i = 0; i<size; i++)
{
set_char(str[i], result);
}
for(int i = 0; i<RESULT_SIZE; i++)
{
current_char_frequency = result[i];
if(current_char_frequency >= char_frequency)
{
char_frequency = current_char_frequency;
frequent_char = i;
}
}
return frequent_char;
}
// respawn character tmp at tmpx,tmpy
// if that place is occupied, try again in one second
static void respawn_callback(int tmp,int tmpx,int tmpy,int tmpa,int dum)
{
int cn;
cn=create_char_nr(tmp,tmpa);
ch[cn].tmpx=tmpx;
ch[cn].tmpy=tmpy;
if (char_driver(ch[cn].driver,CDT_RESPAWN,cn,0,0)==1 && set_char(cn,tmpx,tmpy,0)) {
update_char(cn);
ch[cn].hp=ch[cn].value[0][V_HP]*POWERSCALE;
ch[cn].endurance=ch[cn].value[0][V_ENDURANCE]*POWERSCALE;
ch[cn].mana=ch[cn].value[0][V_MANA]*POWERSCALE;
if (ch[cn].lifeshield<0) {
elog("respawn_callback(): lifeshield=%d (%X) for char %d (%s). fixed.",ch[cn].lifeshield,ch[cn].lifeshield,cn,ch[cn].name);
ch[cn].lifeshield=0;
}
ch[cn].dir=DX_RIGHTDOWN;
register_respawn_respawn(cn);
//charlog(cn,"created by respawn");
return;
}
destroy_char(cn);
set_timer(ticker+TICKS*10,respawn_callback,tmp,tmpx,tmpy,tmpa,0);
}
int mostFrequentCharOpt3(char str[], int size) //Loop optimization
{
int result[RESULT_SIZE] = {0};
int frequent_char = 0;
int current_char_frequency = 0;
int char_frequency = 0;
for(int i = size; i--; )
{
set_char(str[i], result);
}
for(int i = RESULT_SIZE; i--; )
{
current_char_frequency = result[i];
if(current_char_frequency >= char_frequency)
{
char_frequency = current_char_frequency;
frequent_char = i;
}
}
return frequent_char;
}
int char_swap(int cn)
{
int co,x,y,m,xt,yt,m2;
struct misc_ppd *ppd;
if (!dx2offset(ch[cn].dir,&x,&y,NULL)) { error=ERR_ILLEGAL_DIR; return 0; }
x+=ch[cn].x;
y+=ch[cn].y;
if (x<1 || x>MAXMAP-2 || y<1 || y>MAXMAP-2) { error=ERR_ILLEGAL_COORDS; return 0; }
m=x+y*MAXMAP;
if (!(co=map[m].ch)) { error=ERR_NO_CHAR; return 0; }
if (!(ch[co].flags&(CF_PLAYER|CF_PLAYERLIKE|CF_ALLOWSWAP))) { error=ERR_NOT_PLAYER; return 0; }
if (ch[co].flags&CF_INVISIBLE) { error=ERR_NOT_PLAYER; return 0; }
if (ch[cn].action!=AC_IDLE) { error=ERR_NOT_IDLE; return 0; }
if (ch[co].action!=AC_IDLE) { error=ERR_NOT_IDLE; return 0; }
m2=ch[cn].x+ch[cn].y*MAXMAP;
if ((map[m].flags&MF_PEACE) && !(map[m2].flags&MF_PEACE)) { error=ERR_ACCESS_DENIED; return 0; }
if (!(map[m].flags&MF_PEACE) && (map[m2].flags&MF_PEACE)) { error=ERR_ACCESS_DENIED; return 0; }
if ((map[m].flags&MF_UNDERWATER) && !(map[m2].flags&MF_UNDERWATER)) { error=ERR_ACCESS_DENIED; return 0; }
if (!(map[m].flags&MF_UNDERWATER) && (map[m2].flags&MF_UNDERWATER)) { error=ERR_ACCESS_DENIED; return 0; }
xt=ch[cn].x;
yt=ch[cn].y;
remove_char(cn);
remove_char(co);
set_char(cn,x,y,0);
set_char(co,xt,yt,0);
dlog(co,0,"was swapped by %s",ch[cn].name);
if ((ch[cn].flags&CF_PLAYER) && (ppd=set_data(cn,DRD_MISC_PPD,sizeof(struct misc_ppd)))) ppd->swapped=realtime;
return 1;
}
int sepol_module_package_set_seusers(sepol_module_package_t * p,
char *data, size_t len)
{
if (set_char(&p->seusers, data, len))
return -1;
p->seusers_len = len;
return 0;
}
int sepol_module_package_set_netfilter_contexts(sepol_module_package_t * p,
char *data, size_t len)
{
if (set_char(&p->netfilter_contexts, data, len))
return -1;
p->netfilter_contexts_len = len;
return 0;
}
int sepol_module_package_set_user_extra(sepol_module_package_t * p,
char *data, size_t len)
{
if (set_char(&p->user_extra, data, len))
return -1;
p->user_extra_len = len;
return 0;
}
static uint16 z18comm_send_data(COMM_TYPE_T *comm,uint16 len)
{
uint16 i;
//debug_string("send data[%d]\n",comm->buflen);
if(comm->use_ext)
{
for(i = 0; i < comm->buflen; ++i)
set_char(comm->buffer[i]);
for(i = 0; i < comm->ext_buf_len; ++i)
set_char(comm->ext_buffer[i]);
}
else
{
// 发送成功
for(i = 0;i < len;++i)
set_char(comm->buffer[comm->buf_begin+(uint8)i]);
}
return i;
}
void print_line(char* line) {
char c;
int x;
int len = strlen(line);
if (line_number >= HEIGHT) {
shift_screen();
line_number--;
}
for (x = 0; x < len; x++) {
set_char(x, line_number, line[x]);
}
line_number++;
}
void _mostFrequentChar(void *arg)
{
struct thread_info *tinfo = arg;
int current_char = 0;
int endIdx = tinfo->str_size;
int offset = tinfo->startIndex;
for(int i = endIdx; i--; )
{
current_char = tinfo->str[offset + i];
set_char(current_char, tinfo->resultArray);
}
}
/* return a pointer to the character AFTER the last byte written */
static char *
hex2mem (char *buf, vm_offset_t mem, int count)
{
int i;
int ch;
int rv;
for (i=0;i<count;i++) {
ch = hex(*buf++) << 4;
ch = ch + hex(*buf++);
rv = set_char (mem++, ch);
if (rv == -1)
return NULL;
}
return(buf);
}
int main (int argc, char const *argv[])
{
// Continue to the breakpoint in set_char()
set_char(); //// continue; var i; val -set 99 1
set_uchar(); //// continue; var i; val -set 99 2
set_short(); //// continue; var i; val -set -42 3
set_ushort(); //// continue; var i; val -set 42 4
set_int(); //// continue; var i; val -set -42 5
set_uint(); //// continue; var i; val -set 42 6
set_long(); //// continue; var i; val -set -42 7
set_ulong(); //// continue; var i; val -set 42 8
set_float(); //// continue; var i; val -set 123.456 9
set_double(); //// continue; var i; val -set 123.456 10
set_long_double(); //// continue; var i; val -set 123.456 11
set_point (); //// continue
return 0;
}
int unicode_entity(CHAR *s)
{
int number;
if (!convert_characters) { return(0); }
number = extract_entity_number(s);
switch (number) {
case 8208: /* 0x2010 HYPHEN */
case 8209: /* 0x2011 NON-BREAKING HYPHEN */
set_char(s, '-'); break;
default:
return(0);
}
return(1); /* found a transcription for entity */
} /* end unicode_entity */
/* return a pointer to the character AFTER the last byte written */
char* hex2mem(char *buf, char *mem, int count, int may_fault)
{
int i;
unsigned char ch;
if (may_fault)
mem_fault_routine = set_mem_err;
for (i=0;i<count;i++) {
ch = hex(*buf++) << 4;
ch = ch + hex(*buf++);
set_char (mem++, ch);
if (may_fault && mem_err)
return (mem);
}
if (may_fault)
mem_fault_routine = NULL;
return(mem);
}
char mostFrequentChar(char str[], int size)
{
int result[RESULT_SIZE] = {0};
char current_char;
char frequent_char = '\0';
int current_char_frequency = 0;
int char_frequency = 0;
for(int i = 0; i<size; i++)
{
current_char = str[i];
current_char_frequency = set_char(current_char, result);
if(current_char_frequency >= char_frequency)
{
char_frequency = current_char_frequency;
frequent_char = current_char;
}
}
return frequent_char;
}
static void set_length(struct RotorStack *stk, unsigned int len)
{
SSE_CTX *ctx = stk->eng->priv;
set_char(stk, len, 0x80);
ctx->buf[14].words[stk->id] = len * 8;
}
void set (char *command_line)
{
unsigned short *int_ptr;
unsigned char *char_ptr;
unsigned long *long_ptr,offset=0;
int i,len, found=0;
char *ptr,buffer [80],variable [80],value [80];
if (device_handle==NULL) {
wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
return;
}
if (current_type==NULL) {
hex_set (command_line);
return;
}
ptr=parse_word (command_line,buffer);
if (ptr==NULL || *ptr==0) {
wprintw (command_win,"Error - Missing arguments\n");refresh_command_win ();
return;
}
parse_word (ptr,buffer);
ptr=strchr (buffer,'=');
if (ptr==NULL) {
wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return;
}
strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0;
strcpy (value,++ptr);
if (current_type==NULL) {
wprintw (command_win,"Sorry, not yet supported\n");refresh_command_win ();return;
}
for (i=0;i<current_type->fields_num && !found;i++) {
if (strcmp (current_type->field_names [i],variable)==0) {
found=1;
ptr=type_data.u.buffer+offset;
len = current_type->field_lengths [i];
switch (current_type->field_types [i]) {
case FIELD_TYPE_INT:
set_int(len, ptr, variable, value);
break;
case FIELD_TYPE_UINT:
set_uint(len, ptr, variable, value);
break;
case FIELD_TYPE_CHAR:
set_char(len, ptr, variable, value);
break;
default:
wprintw (command_win,
"set: unhandled type %d\n",
current_type->field_types [i]);
break;
}
refresh_command_win ();
}
offset+=current_type->field_lengths [i];
}
if (found)
dispatch ("show");
else {
wprintw (command_win,"Error - Variable %s not found\n",variable);
refresh_command_win ();
}
}
static uint8 z18comm_recv_request(COMM_TYPE_T *comm)
{
uint8 data b;
uint8 data i;
uint16 pack_len,recv_len;
comm->buf_begin=0;
// recv STX
do
{
if(get_char(&(comm->buffer[0]))==0)
{
return 0;
}
}while(comm->buffer[0] != STX1);
comm->buf_begin++;
comm->ext_buf_len = 61;
recv_len = 1;
i = 0;
set_char(0x47);
while(1)
{
if(get_char(&b)==0)
{
if(get_char(&b)==0)
{
if(get_char(&b)==0)
{
//debug_string("i[%d][%d]\n",(uint16)i,recv_len);
//debug_hex(comm->buffer,recv_len);
break;
}
}
}
recv_len++;
// 等待一下
if(recv_len <= MAIN_PACK_LEN)
{
comm->buffer[comm->buf_begin++] = b;
}
else
{
/*
if(recv_len-comm->buf_begin+61 > comm->ext_buf_len)
return 0;
*/
comm->ext_buffer[comm->ext_buf_len] = b;
comm->ext_buf_len++;
}
if(++i == 22)
{
set_char(0x47);
i = 0;
}
if(recv_len == 3)
{
pack_len = get_2byte_int(comm->buffer+1);
}
else if(recv_len > 3)
{
if(recv_len -3 >= pack_len )
break;
}
}
if(recv_len < 6)
{
debug_string("pack len err,[%d]\n",recv_len);
return 0;
}
pack_len = get_2byte_int(comm->buffer+1);
if(pack_len < recv_len - 3)
{
debug_string("recv err,[%d][%d]\n",pack_len,recv_len);
return 0;
}
if(recv_len <= MAIN_PACK_LEN)
{
if(comm->buffer[recv_len-1] != ETX1)
{
debug_string("recv buf ext1![%d]\n",recv_len);
return 0;
}
comm->ext_buf_len = 0;
}
else
{
if(comm->ext_buffer[comm->ext_buf_len-1] != ETX1)
{
debug_string("recv buf ext1![%d]\n",recv_len);
return 0;
}
// 将包体拷贝到 ext_buffer
memcpy(comm->ext_buffer,comm->buffer+3,61);
comm->use_ext = 1;
}
return 1;
}
// you may want to have a look into /usr/src/linux/drivers/char/console.c
void parse_character(termstate_t * term, l4_uint8_t c)
{
int i;
// these must be handled independetly of state
switch (c)
{
case 0: // ignore
return;
case 7: // bell
// todo: impl. me
return;
case 8: // backspace
if (term->cur_x > 0)
term->cur_x--;
return;
case 9: // tab
cursor_tab(term);
return;
case 10: // newline (lf)
case 11: // ?
case 12: // ?
cursor_nl(term);
return;
case 13: // do a cr here, maybe a smart one (+ lf)
cursor_cr(term);
return;
case 27: // ESC
term->esc_state = ESesc;
return;
}
// now check for the state-dependant characters
switch (term->esc_state)
{
case ESnormal:
// normal character
if ((c >= 0x20 && c <= 0x7e) || (c >= 0xa1 && c <= 0xfe))
{
if (term->insert_mode == VT100_INSMODE_REPLACE)
{
set_char(term, c);
//vt100_redraw_xy(term, term->cur_x, term->cur_y);
cursor_next(term);
}
else // VT100_INSMODE_INSERT
{
insert_char(term, c);
//vt100_redraw(term);
}
return;
}
// switch (c)
// {
// }
break;
case ESesc: // normal ESC found
term->esc_state = ESnormal;
switch (c)
{
case '[':
term->esc_state = ESsquare;
return;
case 'D': // lf
cursor_lf(term);
//vt100_redraw(term);
return;
case 'E': // cr + lf
cursor_nl(term);
//vt100_redraw(term);
return;
case 'H': // set tab at current position
set_tab( term, term->cur_x );
return;
case 'M':
rev_scroll(term);
//vt100_redraw(term);
return;
case '7': // save cursor position and attributes
term->cur_stored_x = term->cur_x;
term->cur_stored_y = term->cur_y;
term->cur_stored_attr = term->attrib_mode;
return;
case '8': // restore saved cursor position and attributes
term->cur_x = term->cur_stored_x;
term->cur_y = term->cur_stored_y;
term->attrib_mode = term->cur_stored_attr;
return;
case '#':
term->esc_state = EShash;
return;
case 'c': // reset vt to default settings
init_termstate(term, term->w, term->phys_h, term->virt_h);
return;
}
case ESsquare:
for(i = 0; i < NUM_PAR; i++)
term->par[i] = 0;
term->used_par = 0;
term->esc_state = ESgetpars;
term->ques = (c=='?');
if (term->ques)
return;
// fall-through
case ESgetpars:
if (c == ';' && term->used_par < NUM_PAR - 1)
{
term->used_par++;
return;
}
else if (c >= '0' && c <= '9')
{
term->par[term->used_par] *= 10;
term->par[term->used_par] += c - '0';
return;
} else term->esc_state = ESgotpars;
// fall-through
case ESgotpars:
term->esc_state = ESnormal;
switch (c)
{
case 'h':
if (term->ques)
{
// handle question commands ending with h
for (i = 0; i <= term->used_par; i++)
{
switch( term->par[i] )
{
case 5: // activate inverse screen
if (set_mode(term, 1))
//vt100_redraw(term);
break;
case 6: // origin mode = scroll region
term->origin_mode = VT100_ORIGIN_SCROLL;
break;
case 7: // autowrap mode on
term->autowrap = 1;
break;
case 8: // autorepeat on
term->autorepeat = 1;
break;
case 25: // activate cursor
term->cursor_vis = 1; return;
default:
break;
}
}
return;
}
else // handle commands without question mark
{
for(i = 0; i <= term->used_par; i++)
{
switch( term->par[i] )
{
case 4: // insert mode on
term->insert_mode = VT100_INSMODE_INSERT;
break;
case 12: // echo on
term->echo = 1;
break;
case 20: // line feed mode
term->newline = 1;
break;
default: break;
}
}
return;
}
case 'l':
if (term->ques)
{
for(i = 0; i <= term->used_par; i++)
{
// handle question commands ending with l
switch( term->par[i] )
{
case 3: // set 80 column mode, clear screen
// todo: impl. resize and use it here
break;
case 5: // deactivate inverse screen
if(set_mode(term, 0))
//vt100_redraw(term);
break;
case 6: // origin mode = whole screen
term->origin_mode = VT100_ORIGIN_GLOBAL;
case 7: // autowrap mode off
term->autowrap = 0;
break;
case 8: // autorepeat off
term->autorepeat = 0;
break;
case 25: // deactivate cursor
term->cursor_vis = 0; return;
default: break;
}
return;
}
}
else // handle commands without question mark
{
for( i=0; i <= term->used_par; i++ )
{
switch( term->par[i] )
{
case 4: // insert mode off
term->insert_mode = VT100_INSMODE_REPLACE;
break;
case 12: // echo off
term->echo = 0;
break;
case 20: // carriage return mode
term->newline = 0;
break;
default:
break;
}
return;
}
}
}
if (term->ques)
{
term->ques = 0;
return;
}
switch (c)
{
case 'F': // CR + up
term->cur_x = 0;
// fall through
case 'A': // up
if (! term->par[0])
term->par[0]++;
cursor_up(term);
return;
case 'E': // CR + down
term->cur_x = 0;
// fall through
case 'B': // down
if (! term->par[0])
term->par[0]++;
cursor_down(term);
return;
case 'C': // right
// no parameter -> set parameter to default (=1)
if (! term->par[0])
term->par[0]++;
cursor_right(term);
return;
case 'D': // left
if (! term->par[0])
term->par[0]++;
cursor_left(term);
return;
case 'G': // cursor position horizontal absolute
if ( (term->par[0] > 0) &&
(term->par[0] < term->w) )
term->cur_x = term->par[0];
return;
case 'H': // absolute position (x,y)
case 'f': // f is the same as H (correct me, if I'm wrong)
// well it is the same in the Linux kernel, in theorie the
// 'f' commands depend on the PUM (Position unit mode),
// which can be characters (seems to be default) or inch
if (term->par[0] > 0) // convert to (0, 0) based coords
term->par[0]--;
if (term->par[1] > 0)
term->par[1]--;
cursor_move_abs(term, term->par[1], term->par[0]);
return;
case 'I': // insert tabs ('\t', term->par[0] times)
if (!term->par[0])
term->par[0]++;
for (i=0;i<term->par[0];i++)
cursor_tab(term);
return;
case 'J':
switch(term->par[0])
{
case 0: // kill to end of screen
clean_to_eos(term);
//vt100_redraw(term);
return;
case 1: // kill from start of screen
clean_from_sos(term);
//vt100_redraw(term);
return;
case 2: // kill whole screen
clean_screen(term, ' ');
//vt100_redraw(term);
return;
}
case 'K': // kill to end of line
switch(term->par[0])
{
case 0: // clean to end of line
clean_to_eol(term);
//vt100_redraw(term);
return;
case 1: // clean from start of line
clean_from_sol(term);
return;
case 2: // erase whole line
clean_line(term, term->cur_y);
return;
}
case 'L': // insert lines
if (!term->par[0])
term->par[0] = 1;
for (i=0; i<term->par[0]; i++)
insert_line(term);
//vt100_redraw(term);
return;
case 'M': // erase lines
if (!term->par[0])
term->par[0] = 1;
for (i=0; i<term->par[0]; i++)
erase_line(term);
//vt100_redraw(term);
return;
case 'c': // we were asked to identify the terminal type
identify(term);
return;
case 'g': // erase tab(s)
switch(term->par[0])
{
case 0: remove_tab( term, term->cur_x );
break;
case 3: clear_tabs( term );
break;
default: break;
}
return;
case 'm':
csi_m(term);
return;
case 'r': // set scrolling region
if (term->par[0] == 0)
term->par[0]++;
if (term->par[1] == 0)
term->par[1] = term->phys_h;
/* Minimum allowed region is 2 lines */
if (term->par[0] < term->par[1] &&
term->par[1] <= term->phys_h)
{
term->scroll_top = term->par[0] - 1;
term->scroll_bottom = term->par[1]; // this line is excluded
// if in origin mode, make sure that the cursor is placed
// inside the scrolling region immediately
if (term->origin_mode == VT100_ORIGIN_SCROLL)
{
term->cur_x = 0;
term->cur_y = term->scroll_top;
}
}
return;
}
case EShash:
term->esc_state = ESnormal;
switch(c)
{
case '8': // fill the screen with 'E'
clean_screen(term, 'E');
//vt100_redraw(term);
break;
}
break;
}
}
void print_text(struct terminal *t, int x, int y, int l, unsigned char *text, unsigned c)
{
for (; l-- && *text; text++, x++) set_char(t, x, y, *text + c);
}
value::value(bool aValue) :
mPointer(nullptr),
mType(VOID_T)
{
set_char(aValue);
}
