static void
newdata(void)
{
u16_t len;
u8_t c;
char *dataptr;
len = uip_datalen();
dataptr = (char *)uip_appdata;
while (len > 0 && s.bufptr < sizeof(s.buf)) {
c = *dataptr;
++dataptr;
--len;
switch (s.state) {
case STATE_IAC:
if (c == TELNET_IAC) {
get_char(c);
s.state = STATE_NORMAL;
} else {
switch (c) {
case TELNET_WILL:
s.state = STATE_WILL;
break;
case TELNET_WONT:
s.state = STATE_WONT;
break;
case TELNET_DO:
s.state = STATE_DO;
break;
case TELNET_DONT:
s.state = STATE_DONT;
break;
default:
s.state = STATE_NORMAL;
break;
}
}
break;
case STATE_WILL:
/* Reply with a DONT */
sendopt(TELNET_DONT, c);
s.state = STATE_NORMAL;
break;
case STATE_WONT:
/* Reply with a DONT */
sendopt(TELNET_DONT, c);
s.state = STATE_NORMAL;
break;
case STATE_DO:
/* Reply with a WONT */
sendopt(TELNET_WONT, c);
s.state = STATE_NORMAL;
break;
case STATE_DONT:
/* Reply with a WONT */
sendopt(TELNET_WONT, c);
s.state = STATE_NORMAL;
break;
case STATE_NORMAL:
if (c == TELNET_IAC)
s.state = STATE_IAC;
else
get_char(c);
break;
}
}
}
bool lex_stream_t::implementation_t::skip_space(char& c)
{
skip_white_space();
return get_char(c);
}
int main (int argc, char* args[]) {
//SDL Window setup
if (init(SCREEN_WIDTH, SCREEN_HEIGHT) == 1) {
return 0;
}
char msg[] = "this is a test string";
SDL_Rect src, dest;
int sleep = 0;
int quit = 0;
Uint32 next_game_tick = SDL_GetTicks();
int i = 0;
float sin_t[360];
for (i = 0; i < 360; i++) {
sin_t[i] = sin(i * M_PI / 180);
}
int c_offset = 0;
int d = 1;
//render loop
while(quit == 0) {
//check for new events every frame
SDL_PumpEvents();
const Uint8 *state = SDL_GetKeyboardState(NULL);
if (state[SDL_SCANCODE_ESCAPE]) {
quit = 1;
}
SDL_RenderClear(renderer);
for (i = 0; i < strlen(msg); i++) {
struct vector3d v = get_char(msg[i]);
if (msg[i] == ' ') {
c_offset += CHAR_WIDTH;
continue;
}
src.x = v.x;
src.y = v.y;
src.w = CHAR_WIDTH;
src.h = CHAR_WIDTH;
dest.x = c_offset;
dest.y = SCREEN_HEIGHT / 2 + sin_t[(int) fabs(c_offset) % 360] * 25;
dest.w = CHAR_WIDTH;
dest.h = CHAR_HEIGHT;
SDL_RenderCopy(renderer, c_map, &src, &dest);
c_offset += CHAR_WIDTH;
}
if (d > strlen(msg) * CHAR_WIDTH + SCREEN_WIDTH) {
d = 0;
}
c_offset = SCREEN_WIDTH - d;
d += 5;
//draw to the screen
SDL_RenderPresent(renderer);
//time it takes to render 1 frame in milliseconds
next_game_tick += 1000 / 60;
sleep = next_game_tick - SDL_GetTicks();
if( sleep >= 0 ) {
SDL_Delay(sleep);
}
}
//free the source image
SDL_FreeSurface(char_map);
//Destroy window
SDL_DestroyWindow(window);
//Quit SDL subsystems
SDL_Quit();
return 0;
}
int
get_token(void)
{
int type = TOKEN_TYPE_ERR;
int index = 0;
int status = SCAN_STATUS_START;
int save;
int c;
while (status != SCAN_STATUS_DONE) {
c = get_char();
save = BOOL_YES;
switch (status) {
case SCAN_STATUS_START:
if (' ' == c || '\t' == c) {
save = BOOL_NO;
}
else if ('\n' == c) {
save = BOOL_NO;
++g_line_numer;
}
else if (isdigit(c)) {
status = SCAN_STATUS_IN_CINT;
}
else if (isalpha(c) || '_' == c) {
status = SCAN_STATUS_IN_ID;
}
else if ('.' == c) {
status = SCAN_STATUS_IN_ACCESS;
}
else if ('#' == c) {
save = BOOL_NO;
status = SCAN_STATUE_IN_COMMENT;
}
else {
status = SCAN_STATUS_DONE;
switch (c) {
case EOF:
save = BOOL_NO;
type = TOKEN_TYPE_EOF;
break;
case '=':
type = TOKEN_TYPE_ASSIGN;
break;
case '<':
type = TOKEN_TYPE_INHERIT;
break;
case '[':
type = TOKEN_TYPE_LBRACKET;
break;
case ']':
type = TOKEN_TYPE_RBRACKET;
break;
case '{':
type = TOKEN_TYPE_LBRACE;
break;
case '}':
type = TOKEN_TYPE_RBRACE;
break;
default:
save = BOOL_NO;
type = TOKEN_TYPE_ERR;
break;
}
}
break;
case SCAN_STATUS_IN_ACCESS:
if (isalpha(c) || '_' == c) {
unget_char();
save = BOOL_NO;
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_ACCESS;
}
else {
fprintf(stderr, "Lexial error: [%d] after '.' ...\n", g_line_numer);
exit(1);
}
break;
case SCAN_STATUS_IN_ID:
if (!isalnum(c) && '_' != c) {
unget_char();
save = BOOL_NO;
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_ID;
}
break;
case SCAN_STATUS_IN_CINT:
if ('.' == c) {
status = SCAN_STATUS_IN_CREAL;
}
else {
if (!isdigit(c)) {
unget_char();
save = BOOL_NO;
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_CINT;
}
}
break;
case SCAN_STATUS_IN_CREAL:
if (!isdigit(c)) {
unget_char();
save = BOOL_NO;
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_CREAL;
}
break;
case SCAN_STATUE_IN_COMMENT:
save = BOOL_NO;
if (EOF == c) {
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_EOF;
}
else if ('\n' == c) {
++g_line_numer;
status = SCAN_STATUS_START;
}
break;
case SCAN_STATUS_DONE:
default:
fprintf(g_scan_stream, "Scanner bug: status = %d\n", status);
status = SCAN_STATUS_DONE;
type = TOKEN_TYPE_ERR;
break;
}
if (save && index < MAX_TOKEN)
g_token[index++] = (char)c;
if (SCAN_STATUS_DONE == status) {
g_token[index] = 0;
if (TOKEN_TYPE_ID == type)
type = lookup_reserved(g_token);
}
}
echo_scanner(g_scan_stream, g_line_numer, type, g_token);
return type;
}
void load_bin(void)
{
unsigned char c;
int ret;
u32union page_addr;
unsigned int crc, rcrc, i;
for (i = 0; i < PAGE_SIZE; i++)
page[i].b[3] = 0xff;
while (1) {
/* request page */
/* 3 bytes - msb first */
page_addr.b[3] = 0;
ret = get_char((char*) &page_addr.b[2]);
ret |= get_char((char*) &page_addr.b[1]);
ret |= get_char((char*) &page_addr.b[0]);
if (page_addr.l == 0x00ffffff) {
put_char('e');
break;
} else {
put_char('p');
}
page_addr.l &= ~((PAGE_SIZE << 1)-1);
if ( ((page_addr.l >= BOOT_FLASH_START_ADDR) && (page_addr.l < BOOT_FLASH_END_ADDR))
|| (page_addr.l == DEV_CONFIG_PAGE_ADDRESS) ) {
put_char('s');
continue;
} else {
put_char('d');
}
/* load page to sram */
ret = 0;
crc = 0;
for (i = 0; i < PAGE_SIZE; i++) {
ret |= get_char((char*) &c);
crc += c;
page[i].b[2] = c;
ret |= get_char((char*) &c);
crc += c;
page[i].b[1] = c;
ret |= get_char((char*) &c);
crc += c;
page[i].b[0] = c;
}
/* get crc */
put_char('c');
rcrc = 0;
ret |= get_char((char*) &c);
rcrc = c << 8;
ret |= get_char((char*) &c);
rcrc |= c;
if (rcrc != crc) {
ret = 100;
put_char('x');
}
if (ret)
break;
erase_page(page_addr.l);
put_char('e');
/* protect bootloader start addr */
if (page_addr.l == 0) {
page[0].l = 0x040800;
page[1].l = 0x000000;
}
for (i = 0; i < PAGE_SIZE/2; i++) {
write_dword(page_addr.l + i*4, page[i*2].l, page[i*2 + 1].l);
}
put_char('w');
}
if (ret) {
put_char('X');
while (1);
} else {
put_char('K');
goto_usercode();
}
}
int main(void)
{
char c;
unsigned char idx[4] = {0, 0, 0, 0};
unsigned char port, total_ports = 2, valid_ports = 0x3;
volatile unsigned long i, j;
int ret = 0;
u32union delay;
RCONbits.SWDTEN = 0;
/* 70 MIPS; 140MHz */
CLKDIVbits.PLLPRE = 0;
PLLFBDbits.PLLDIV = 74;
CLKDIVbits.PLLPOST = 0;
/* switch clock to FRC oscillator with PLL */
__builtin_write_OSCCONH(1);
__builtin_write_OSCCONL(OSCCON | 1);
/* wait for clock switch to complete */
while (OSCCONbits.OSWEN == 1);
/* wait for PLL lock */
while (OSCCONbits.LOCK != 1);
ANSELA = 0;
ANSELB = 0;
ANSELC = 0;
TRIS_LED = 0;
LED = 0;
/* detect hw revision */
/* set RB1 internal pull down */
_TRISB1 = 1;
_CNPDB1 = 1;
/* hw 0v5 has RB1 connected to RB4 */
_TRISB4 = 0;
_LATB4 = 0;
for (i = 0; i < 100000; i++);
j = (_RB1 & 1);
_LATB4 = 1;
for (i = 0; i < 100000; i++);
j |= ((_RB1 & 1) << 1);
if (j == 0b10) {
hw_rev = 0x05;
} else {
/* set RB9 internal pull down */
_TRISB9 = 1;
_CNPDB9 = 1;
/* set RA9 internal pull down */
_TRISA9 = 1;
_CNPDA9 = 1;
ANSELBbits.ANSB1 = 1;
AD1CON3bits.ADCS = 16;
AD1CON2bits.CHPS = 2;
AD1CON1bits.ADON = 1;
AD1CHS0bits.CH0SA = 3;
AD1CON1bits.SAMP = 1;
for (i = 0; i < 1000; i++);
AD1CON1bits.SAMP = 0;
for (i = 0; i < 10000; i++);
if (ADC1BUF0 > 400)
/* hw 0v4 has 1.25V vref on AN3 */
hw_rev = 0x04;
else if (_RB9 == 1)
/* hw 0v3 has external pull-up on RB9 */
hw_rev = 0x03;
else if (_RA9 == 1)
/* hw 0v2 has RB9 floating and RA9 pull-up */
hw_rev = 0x02;
else
/* hw 0v1 has RA9 and RB9 floating */
hw_rev = 0x01;
_CNPDB9 = 0;
_CNPDA9 = 0;
AD1CON1bits.ADON = 0;
}
_CNPDB1 = 0;
_TRISB4 = 1;
hw_rev = 0x05;
/* weak pull up on serial port rx pins */
if (hw_rev >= 0x05) {
_CNPUB12 = 1;
_CNPUB15 = 1;
_CNPUC7 = 1;
_CNPUB7 = 1;
} else if (hw_rev >= 0x03) {
_CNPUB11 = 1;
_CNPUB6 = 1;
_CNPUB2 = 1;
_CNPUB13 = 1;
} else {
_CNPUB6 = 1;
_CNPUA4 = 1;
}
if (hw_rev >= 0x03) {
total_ports = 4;
valid_ports = 0xf;
}
/* get devid */
read_flash(0xff0000, &devid);
delay.l = BOOT_DELAY;
if (delay.b[0] == 0)
goto_usercode();
/* Timer setup */
/* increments every instruction cycle */
T2CONbits.T32 = 1;
/* clear timer3 IF */
IFS0bits.T3IF = 0;
/* disable timer3 isr */
IEC0bits.T3IE = 0;
/* Convert seconds into timer count value */
delay.l = ((unsigned long) (FCY)) * ((unsigned long) (delay.b[0]));
PR3 = delay.w[1];
PR2 = delay.w[0];
TMR3HLD = 0x0000;
TMR2 = 0x0000;
T2CONbits.TON = 1;
uart_init();
while (1) {
for (port = 0; port < total_ports; port++) {
if (valid_ports & (1 << port)) {
used_port = port;
if (get_char(&c)) {
if (c != magic_word_bin[idx[port]])
valid_ports &= ~(1 << port);
else
idx[port]++;
if (idx[port] == (sizeof(magic_word_bin)-1)) {
ret = 1;
break;
}
}
}
}
if (valid_ports == 0)
ret = 0xff;
if (_T3IF == 1) {
ret = 0xff;
}
if (ret)
break;
}
T2CONbits.TON = 0;
LED = 1;
if (ret == 0xff) {
put_char('*');
goto_usercode();
}
put_str((char*) msg);
put_str((char*) msg_bin);
load_bin();
return 0;
}
/* ARGSUSED */
static int
isearch(int f GCC_UNUSED, int n)
{
static TBUFF *pat_save = 0; /* Saved copy of the old pattern str */
int status; /* Search status */
register int cpos; /* character number in search string */
register int c; /* current input character */
MARK curpos, curp; /* Current point on entry */
int init_direction; /* The initial search direction */
/* Initialize starting conditions */
cmd_reexecute = -1; /* We're not re-executing (yet?) */
itb_init(&cmd_buff, EOS); /* Init the command buffer */
/* Save the old pattern string */
(void) tb_copy(&pat_save, searchpat);
curpos = DOT; /* Save the current pointer */
init_direction = n; /* Save the initial search direction */
ignorecase = window_b_val(curwp, MDIGNCASE);
scanboundry(FALSE, DOT, FORWARD); /* keep scanner() finite */
/* This is a good place to start a re-execution: */
start_over:
/* ask the user for the text of a pattern */
promptpattern("ISearch: ");
status = TRUE; /* Assume everything's cool */
/*
* Get the first character in the pattern. If we get an initial
* Control-S or Control-R, re-use the old search string and find the
* first occurrence
*/
c = kcod2key(get_char()); /* Get the first character */
if ((c == IS_FORWARD) ||
(c == IS_REVERSE)) { /* Reuse old search string? */
for (cpos = 0; cpos < (int) tb_length(searchpat); ++cpos)
echochar(tb_values(searchpat)[cpos]); /* and re-echo the string */
curp = DOT;
if (c == IS_REVERSE) { /* forward search? */
n = -1; /* No, search in reverse */
last_srch_direc = REVERSE;
backchar(TRUE, 1); /* Be defensive about EOB */
} else {
n = 1; /* Yes, search forward */
last_srch_direc = FORWARD;
forwchar(TRUE, 1);
}
unget_char();
status = scanmore(searchpat, n); /* Do the search */
if (status != TRUE)
DOT = curp;
c = kcod2key(get_char()); /* Get another character */
} else {
tb_init(&searchpat, EOS);
}
/* Top of the per character loop */
for_ever { /* ISearch per character loop */
/* Check for special characters, since they might change the
* search to be done
*/
if (ABORTED(c) || c == '\r') /* search aborted? */
return (TRUE); /* end the search */
if (isbackspace(c))
c = '\b';
if (c == quotec) /* quote character? */
c = kcod2key(get_char()); /* Get the next char */
switch (c) { /* dispatch on the input char */
case IS_REVERSE: /* If backward search */
case IS_FORWARD: /* If forward search */
curp = DOT;
if (c == IS_REVERSE) { /* forward search? */
last_srch_direc = REVERSE;
n = -1; /* No, search in reverse */
backchar(TRUE, 1); /* Be defensive about
* EOB */
} else {
n = 1; /* Yes, search forward */
last_srch_direc = FORWARD;
forwchar(TRUE, 1);
}
status = scanmore(searchpat, n); /* Do the search */
if (status != TRUE)
DOT = curp;
c = kcod2key(get_char()); /* Get the next char */
continue; /* Go continue with the search */
case '\t': /* Generically allowed */
case '\n': /* controlled characters */
break; /* Make sure we use it */
case '\b': /* or if a Rubout: */
if (itb_length(cmd_buff) <= 1) /* Anything to delete? */
return (TRUE); /* No, just exit */
unget_char();
DOT = curpos; /* Reset the pointer */
n = init_direction; /* Reset the search direction */
(void) tb_copy(&searchpat, pat_save);
/* Restore the old search str */
cmd_reexecute = 0; /* Start the whole mess over */
goto start_over; /* Let it take care of itself */
/* Presumably a quasi-normal character comes here */
default: /* All other chars */
if (!isPrint(c)) { /* Is it printable? */
/* Nope. */
unkeystroke(c); /* Re-eat the char */
return (TRUE); /* And return the last status */
}
} /* Switch */
/* I guess we got something to search for, so search for it */
tb_append(&searchpat, c); /* put the char in the buffer */
echochar(c); /* Echo the character */
if (!status) { /* If we lost last time */
kbd_alarm(); /* Feep again */
} else /* Otherwise, we must have won */
status = scanmore(searchpat, n); /* or find the next
* match */
c = kcod2key(get_char()); /* Get the next char */
} /* for_ever */
}
int shell ( char *args[] )
{
char cmd[MAXCMDLEN + 1];
int i, key, rv;
timespec_t t;
int argnum;
char *argval[MAXARGS + 1];
pthread_t thr;
printf ( "\n*** Simple shell interpreter ***\n\n" );
help ();
t.tv_sec = 0;
t.tv_nsec = 100000000; /* 100 ms */
while (1)
{
new_cmd:
printf ( "\n> " );
i = 0;
memset ( cmd, 0, MAXCMDLEN );
/* get command - get chars until new line is received */
while ( i < MAXCMDLEN )
{
key = get_char ();
if ( !key )
{
nanosleep ( &t, NULL );
continue;
}
if ( key == '\n' || key == '\r')
{
if ( i > 0 )
break;
else
goto new_cmd;
}
switch ( key )
{
case '\b':
if ( i > 0 )
{
cmd[--i] = 0;
printf ( "%c", key );
}
break;
default:
printf ( "%c", key );
cmd[i++] = (char) key;
break;
}
}
printf ( "\n" );
/* parse command line */
argnum = 0;
for(i = 0; i < MAXCMDLEN && cmd[i]!=0 && argnum < MAXARGS; i++)
{
if ( cmd[i] == ' ' || cmd[i] == '\t')
continue;
argval[argnum++] = &cmd[i];
while ( cmd[i] && cmd[i] != ' ' && cmd[i] != '\t'
&& i < MAXCMDLEN )
i++;
cmd[i] = 0;
}
argval[argnum] = NULL;
/* match command to shell command */
for ( i = 0; sh_cmd[i].func != NULL; i++ )
{
if ( strcmp ( argval[0], sh_cmd[i].name ) == 0 )
{
if ( sh_cmd[i].func ( argval ) )
printf ( "\nProgram returned error!\n" );
goto new_cmd;
}
}
/* not shell command; start given program by calling kernel */
rv = posix_spawn ( &thr, argval[0], NULL, NULL, argval, NULL );
if ( !rv )
{
if ( argnum < 2 || argval[argnum-1][0] != '&' )
pthread_join ( thr, NULL );
goto new_cmd;
}
if ( strcmp ( argval[0], "quit" ) == 0 ||
strcmp ( argval[0], "exit" ) == 0 )
break;
/* not program kernel or shell knows about it - report error! */
printf ( "Invalid command!" );
}
printf ( "Exiting from shell\n" );
return 0;
}
// main function
extern void main(void) {
unsigned char flag, numb_pages;
unsigned i, write_size, read_size,
temp_six_vector, six_vector, errors, write_offset;
unsigned boot_args[AT45_PAGE_SIZE / 4];
// calculate temp six vector
numb_pages = 0;
i = AT45_PAGE_NUMB;
while(i >>= 1)
numb_pages++;
temp_six_vector = (numb_pages << 13) + (AT45_PAGE_SIZE << 17);
// setup SYS interrupt
aic_configure_irq(AT91C_ID_SYS, AT91C_AIC_PRIOR_LOWEST,
AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE, aic_asm_sys_handler);
// enable SYS interrupt
aic_enable_irq(AT91C_ID_SYS);
// setup rtt - 1Hz clock
AT91C_BASE_ST->ST_RTMR = 0x4000;
upoint_r = pt_mem_area, upoint_w = (pt_mem_area + AT45DB642D_SIZE);
put_string("Init AT45DB642D and get device information\n");
if (!at45_init())
put_string("Device inited and ready\n");
else
put_string("Error!\n");
put_string("Press any key to load boot menu\n: ");
// setup rtt interrupt flag
AT91C_BASE_ST->ST_IER = AT91C_ST_RTTINC;
// enable RXRDY interrupt in DBGU
AT91C_BASE_DBGU->DBGU_IER |= AT91C_US_RXRDY;
wait_status = 1;
get_char();
while (flag != 'q') {
put_string("\nload (l), write(w), run kernel(r), quit(q), erase(e): ");
flag = get_char();
switch(flag) {
// loading data to sdram
case 'l':
put_string("Please trasfer the boot file:\n");
transfer_size = 0;
// setup rtt interrupt flag
AT91C_BASE_ST->ST_IER = AT91C_ST_RTTINC;
// enable RXRDY interrupt in DBGU
AT91C_BASE_DBGU->DBGU_IER |= AT91C_US_RXRDY;
while(!transfer_size);
delay(100000);
if (transfer_size > 0) {
put_string("Transfer complete\n");
util_printf("Byte's sended: %x\n", transfer_size);
}
break;
// writing bytes from data flash
case 'w':
if (transfer_size == 0) {
put_string("Please transfer begin, write end\n");
break;
}
else if (transfer_size > (AT45DB642D_SIZE)) {
put_string("Trasfer is larger than flash size\n");
break;
}
else {
if ((unsigned)transfer_size % AT45_PAGE_SIZE)
write_size = ((unsigned)transfer_size / AT45_PAGE_SIZE + 1) * AT45_PAGE_SIZE;
else
write_size = transfer_size;
put_string("Write boot(b) or linux kernel(n): ");
flag = get_char();
util_printf("%c\n", flag);
if (flag == 'b') {
write_offset = BOOT_OFFSET;
put_string("\nModification of Arm Interrupt Vector #6\n");
six_vector = (write_size / 512) + 1 + temp_six_vector;
util_printf("Six vector is 0x%x\n", six_vector);
upoint_w[5] = six_vector;
}
else {
write_offset = LINUX_OFFSET;
put_string("Writing args\n");
boot_args[0] = write_size;
if (!at45_write(BOOT_2_ARGS_OFFSET, boot_args, AT45_PAGE_SIZE))
put_string("Write success\n");
else
put_string("Error!\n");
}
util_printf("Write 0x%x bytes\n", write_size);
if (!at45_write(write_offset, upoint_w, write_size))
put_string("Write success\n");
else
put_string("Error!\n");
if (!at45_read(write_offset, upoint_r, write_size)) {
put_string("Read success\nStart verification\n");
six_vector = upoint_r[5];
if (write_offset == BOOT_OFFSET) {
if ((six_vector & 0xfffff000) - temp_six_vector) {
util_printf("Six vector is damage, current 0x%x, original 0x%x\n",
six_vector, temp_six_vector);
break;
}
else {
put_string("Six vector is correct\nStart code verification\n");
}
}
errors = 0;
for (i = 0; i < write_size / 4; i++) {
if (upoint_r[i] != upoint_w[i]) {
errors++;
util_printf("Addr - %x, write - %x, read - %x\n", i, upoint_w[i], upoint_r[i]);
}
}
put_string("Stop code verification\n");
if (errors)
put_string("Verification failed!\n");
else
put_string("Verification success!\n");
}
}
break;
// erase first page
case 'e':
if (!at45_read(0x0, upoint_r, 0x20)) {
six_vector = upoint_r[5];
read_size = (six_vector & 0xff) * 512;
for (i = 0; i <= read_size; i += AT45_PAGE_SIZE) {
if (!at45_page_erase(i))
put_string("Erase success\n");
else
put_string("Error!\n");
}
}
break;
// run 2boot code
case 'r':
run_kernel();
break;
// exit of loop
case 'q':
put_string("\nQuit & Reset\n");
AT91C_BASE_ST->ST_WDMR = 256 | AT91C_ST_RSTEN;
AT91C_BASE_ST->ST_CR = AT91C_ST_WDRST;
break;
// undef
default:
put_string("\nUndefined command\n");
break;
}
}
// Infinity loop
while (1) {
// Disable pck for idle cpu mode
AT91C_BASE_PMC->PMC_SCDR = AT91C_PMC_PCK;
}
}
static int to_something(buffer *b, int (to_first)(int), int (to_rest)(int)) {
assert_buffer(b);
/* If we are after the end of the line, just return ERROR. */
if (b->cur_line == b->num_lines -1 && b->cur_pos >= b->cur_line_desc->line_len) return ERROR;
int64_t pos = b->cur_pos;
int c;
/* First of all, we search for the word start, if we're not over it. */
if (pos >= b->cur_line_desc->line_len || !ne_isword(c = get_char(&b->cur_line_desc->line[pos], b->encoding), b->encoding))
if (search_word(b, 1) != OK)
return ERROR;
bool changed = false;
int64_t new_len = 0;
pos = b->cur_pos;
const int64_t cur_char = b->cur_char;
const int cur_x = b->cur_x;
/* Then, we compute the word position extremes, length of the result (which
may change because of casing). */
while (pos < b->cur_line_desc->line_len && ne_isword(c = get_char(&b->cur_line_desc->line[pos], b->encoding), b->encoding)) {
const int new_c = new_len ? to_rest(c) : to_first(c);
changed |= (c != new_c);
if (b->encoding == ENC_UTF8) new_len += utf8seqlen(new_c);
else new_len++;
pos = next_pos(b->cur_line_desc->line, pos, b->encoding);
}
const int64_t len = pos - b->cur_pos;
if (!len) {
char_right(b);
return OK;
}
if (changed) {
/* We actually perform changes only if some character was case folded. */
char * word = malloc(new_len * sizeof *word);
if (!word) return OUT_OF_MEMORY;
pos = b->cur_pos;
new_len = 0;
/* Second pass: we actually build the transformed word. */
while (pos < b->cur_line_desc->line_len && ne_isword(c = get_char(&b->cur_line_desc->line[pos], b->encoding), b->encoding)) {
if (b->encoding == ENC_UTF8) new_len += utf8str(new_len ? to_rest(c) : to_first(c), word + new_len);
else {
word[new_len] = new_len ? to_rest(c) : to_first(c);
new_len++;
}
pos = next_pos(b->cur_line_desc->line, pos, b->encoding);
}
start_undo_chain(b);
delete_stream(b, b->cur_line_desc, b->cur_line, b->cur_pos, len);
if (new_len) insert_stream(b, b->cur_line_desc, b->cur_line, b->cur_pos, word, new_len);
free(word);
end_undo_chain(b);
if (cur_char < b->attr_len) b->attr_len = cur_char;
update_line(b, b->cur_line_desc, b->cur_y, cur_x, false);
need_attr_update = true;
}
return search_word(b, 1);
}
Token* get_token()
{
char ch; //This can be the current character you are examining during scanning.
static char token_string[MAX_TOKEN_STRING_LENGTH]; //Store your token here as you build it.
char *token_ptr = token_string; //write some code to point this to the beginning of token_string
int loop = FALSE;
int symbol_code;
Token* token = (Token*)malloc(sizeof(Token)); //allocate memory for struct
CharCode code;
//get_char will set global ptr src_ptr to the source_buffer line
//get_char will also set ch to the first character in source_buffer, if the end of line has been reached,
//otherwise will set ch to what GLOBAL src_ptr is currently looking at.
//other methods will set ch to the next char in the source_buffer after they have tokenized
token->next = NULL;
get_char(token_string);
ch = *src_ptr;
//if get_char shows us that we have a blank space or the beginning of a comment we need to skip over all spaces and comments
//until we come to a token
if(ch == ' ' || ch == '\n' || ch == '{' || ch == '\r' || ch == '\t')
{
loop = TRUE; // Execute the loop for skipping spaces, skipping comments, and getting a new line
}
while(loop)
{
//check to see what the current ch is
if(ch == ' ' || ch == '\t')
{
//call function skip_blanks which returns a pointer to the first non-blank character // if it reaches null terminator it will set ch to '\0' and come back here
skip_blanks(&ch);
//now call get_char again to get a new line if ch is a null terminator
if(ch == '\n' || ch == '\r')
{
//call get_char to get a new source line
get_char(token_string);
ch = *src_ptr;
}
//after this there may be more spaces or comments, need to continue to evaluae loop
loop = TRUE;
}
//now check to see if there is a comment and skip over this as well
else if(ch == '{')
{
loop = TRUE;
//skip_comment will return the character following the ending bracket
//src_ptr will also be pointing here
//ch will contin current value of src_ptr
skip_comment(&ch, token_string);
}
else if(ch == '\n' || ch == '\r')
{
get_char(token_string);
ch = *src_ptr;
loop = TRUE;
}
else
{
//if no matches then we are looking at a valid character
loop = FALSE;
//make sure to update ch to what src_ptr is looking at
ch = *src_ptr;
}
}
//position 'ch' in char_table will return a CharCode corresponding to Letter, Digit, Quote, etc...
code = char_table[ch];
//check to see if code for ch is a LETTER
if(code == LETTER)
{
//pass in the token_string array to point to, and the current Token struct.
//get_word will set the tokens values appropriately so it can be returned
//to main
get_word( token);
}
//check to see if it is a digit
else if(code == DIGIT)
{
get_number(token); //The parameter has to be same as get_word because we need to build a character array to be converted to integers or real numbers
}
//check to see if it is a quote
else if(code == QUOTE)
{
get_string(token);
}
else
{
//in the get_special function the token code will be set
symbol_code = get_special();
//set token code to the symbol code
token->code = (TokenCode)symbol_code;
//the literal type for the token will be a str_lit and the char ptr will point to the token_string array where
//the characters are stored
token->literal.str_lit = token_string;
//type of token will be set to string_lit
token->type = STRING_LIT;
}
//3. Call the appropriate function to deal with the cases in 2.
return token; //What should be returned here?
}
/*
* 'Wait for' this string to appear on this file descriptor.
*/
int
get_string(char *string)
{
char temp[STR_LEN];
int c, printed = 0;
size_t len, minlen;
char *s = temp, *end = s + STR_LEN;
char *logged = temp;
fail_reason = (char *)0;
if (strlen(string) > STR_LEN) {
chat_logf("expect string is too long");
exit_code = 1;
return 0;
}
string = clean(string, 0);
len = strlen(string);
minlen = (len > sizeof(fail_buffer)? len: sizeof(fail_buffer)) - 1;
if (verbose)
chat_logf("expect (%v)", string);
if (len == 0) {
if (verbose)
chat_logf("got it");
return (1);
}
alarm(timeout);
alarmed = 0;
while ( ! alarmed && (c = get_char()) >= 0) {
int n, abort_len, report_len;
if (echo)
echo_stderr(c);
if (verbose && c == '\n') {
if (s == logged)
chat_logf(""); /* blank line */
else
chat_logf("%0.*v", s - logged, logged);
logged = s + 1;
}
*s++ = c;
if (verbose && s >= logged + 80) {
chat_logf("%0.*v", s - logged, logged);
logged = s;
}
if (Verbose) {
if (c == '\n')
fputc( '\n', stderr );
else if (c != '\r')
fprintf( stderr, "%s", character(c) );
}
if (!report_gathering) {
for (n = 0; n < n_reports; ++n) {
if ((report_string[n] != (char*) NULL) &&
s - temp >= (report_len = strlen(report_string[n])) &&
strncmp(s - report_len, report_string[n], report_len) == 0) {
time_t time_now = time ((time_t*) NULL);
struct tm* tm_now = localtime (&time_now);
strftime (report_buffer, 20, "%b %d %H:%M:%S ", tm_now);
strcat (report_buffer, report_string[n]);
report_string[n] = (char *) NULL;
report_gathering = 1;
break;
}
}
}
else {
if (!iscntrl (c)) {
int rep_len = strlen (report_buffer);
report_buffer[rep_len] = c;
report_buffer[rep_len + 1] = '\0';
}
else {
report_gathering = 0;
fprintf (report_fp, "chat: %s\n", report_buffer);
}
}
if ((size_t)(s - temp) >= len &&
c == string[len - 1] &&
strncmp(s - len, string, len) == 0) {
if (verbose) {
if (s > logged)
chat_logf("%0.*v", s - logged, logged);
chat_logf(" -- got it\n");
}
alarm(0);
alarmed = 0;
return (1);
}
for (n = 0; n < n_aborts; ++n) {
if (s - temp >= (abort_len = strlen(abort_string[n])) &&
strncmp(s - abort_len, abort_string[n], abort_len) == 0) {
if (verbose) {
if (s > logged)
chat_logf("%0.*v", s - logged, logged);
chat_logf(" -- failed");
}
alarm(0);
alarmed = 0;
exit_code = n + 4;
strcpy(fail_reason = fail_buffer, abort_string[n]);
return (0);
}
}
if (s >= end) {
if (logged < s - minlen) {
chat_logf("%0.*v", s - logged, logged);
logged = s;
}
s -= minlen;
memmove(temp, s, minlen);
logged = temp + (logged - s);
s = temp + minlen;
}
if (alarmed && verbose)
chat_logf("warning: alarm synchronization problem");
}
alarm(0);
if (verbose && printed) {
if (alarmed)
chat_logf(" -- read timed out");
else
chat_logf(" -- read failed: %m");
}
exit_code = 3;
alarmed = 0;
return (0);
}
void main(void) {
unsigned long delay;
char exit = 'o';
/* Initialization code */
clock_init(BUS_CLK);
sci_init(9600, BUS_CLK, SCI0);
LIN_PHY_ENABLE;
sci_init(9600, BUS_CLK, SCI1);
gpio_init();
LS_Module_Init();
HS_Module_Init();
HS0_On();
PWM_init();
ADC_init(BUS_CLK);
/* Test serial communication */
send_string("\n\rSerial Test, press any key\n\r", SCI1);
echo(SCI1);
send_string("\n\rTest successful\n\r",SCI1);
/* Test Relay */
send_string("\n\rPress u to activate the relay up and d to activate it down\n\r", SCI1);
send_string("\n\rPres e to exit relay test\n\r", SCI1);
while(exit != 'e'){
exit = get_char(SCI1);
put_char(exit, SCI1);
if(exit == 'u'){
send_string("\r\nRelay Low side driver 0 active\r\n", SCI1);
LS0_On();
for(delay = 0; delay < 30000; ++delay);
send_string("\r\nRelay Low side driver 0 inactive\r\n", SCI1);
LS0_Off();
exit = 'a';
} else if (exit == 'd') {
send_string("\r\nRelay Low side driver 1 active\r\n", SCI1);
LS1_On();
for(delay = 0; delay < 30000; ++delay);
send_string("\r\nRelay Low side driver 1 inactive\r\n", SCI1);
LS1_Off();
exit = 'a';
}
}
put_char('\n', SCI1);
EnableInterrupts;
for(;;) {
_FEED_COP(); /* feeds the dog */
if(read_sw2){
LS0_On();
send_string("\r\nSwitch 2 pressed\r\n", SCI1);
} else {
LS0_Off();
}
if(read_sw3){
LS1_On();
send_string("\r\nSwitch 3 pressed\r\n", SCI1);
} else {
LS1_Off();
}
for(delay = 0; delay < 30000; ++delay);
send_string("\rADC value: ", SCI1);
send_string("\b\b\b", SCI1);
DisplayInt((unsigned char) ADC_read(POT), SCI1);
put_char(0x55,SCI0); /* Send stuff through LIN */
} /* loop forever */
/* please make sure that you never leave main */
}
static int proc_tag()
{
char ch;
int tag, index = 0;
char *s, *o;
if (check_left_char('*', "/") != 0)
return 0;
if (check_left_char('<', "/*") != 0)
return 0;
if (check_left_char('$', "/*<") != 0)
return 0;
// we are here because input string is "/,*,<,$"
if (get_char(&ch) < 0)
return -1;
if ((ch == 'H') || (ch == 'E') || (ch == 'K') || (ch == '*')) {
switch (ch) {
case 'H' : if (put_header() < 0)
return -1;
Mode = S_KOREAN;
break;
case 'E' : Mode = S_ENGLISH; break;
case 'K' : Mode = S_KOREAN; break;
case '*' : Mode = S_DONE; break;
}
goto end_tags;
}
switch (ch) {
case 'F' : s = _filename; break;
case 'A' : s = _author; break;
case 'V' : s = _version; break;
case 'T' : s = _translator; break;
case 'D' : s = _date; break;
case 'L' : s = _last_update; break;
case 'R' :
_reviewer[num_reviewer] = (char *)malloc(MAX_LENGTH);
if (_reviewer[num_reviewer] == NULL) {
fprintf(stderr, "\nLine %d: malloc failure\n", line);
return -1;
}
s = _reviewer[num_reviewer++];
break;
default :
fprintf(stderr, "\nLine %d: Unknown Tag '%c'\n", line, ch);
return -1;
}
tag = ch;
o = s;
if (check_right_char('=') < 0)
return -1;
if (check_right_char('"') < 0)
return -1;
while (1) {
ch = getchar();
#ifdef DEBUG
putchar(ch);
#endif
if (ch == '"') {
*s = 0;
switch (tag) {
case 'F' :
case 'A' :
case 'V' :
case 'T' :
case 'D' :
case 'L' :
case 'R' :
break;
default : fprintf(stderr, "\nOOOPPPPPS\n");
}
break;
}
if ((ch == '\t') || (ch == '\n') || (ch == '\r'))
ch = ' ';
if ((ch == ' ') && (*s == ' '))
continue;
*s++ = ch;
if (index == MAX_LENGTH) {
fprintf(stderr, "\nLine %d: string too long\n", line);
return -1;
}
}
#ifdef DEBUG
printf("Line %d: TAG '%c' = '%s'\n", line, tag, o);
#endif
end_tags:
if (check_right_char('>') < 0)
return -1;
if (check_right_char('*') < 0)
return -1;
if (check_right_char('/') < 0)
return -1;
if (Mode != S_DONE) {
do
get_char(&ch);
while (ch != '\n');
}
return 0;
}
static struct buffer parse_string(struct buffer buff,
struct rmsgpack_dom_value *value, const char **error)
{
const char * str_start = NULL;
char terminator = '\0';
char c = '\0';
int is_binstr = 0;
(void)c;
buff = get_char(buff, &terminator, error);
if (*error)
return buff;
if (terminator == 'b')
{
is_binstr = 1;
buff = get_char(buff, &terminator, error);
}
if (terminator != '"' && terminator != '\'')
{
buff.offset--;
raise_expected_string(buff.offset, error);
}
str_start = buff.data + buff.offset;
buff = get_char(buff, &c, error);
while (!*error)
{
if (c == terminator)
break;
buff = get_char(buff, &c, error);
}
if (!*error)
{
size_t count;
value->type = is_binstr ? RDT_BINARY : RDT_STRING;
value->val.string.len = (buff.data + buff.offset) - str_start - 1;
count = is_binstr ? (value->val.string.len + 1) / 2 : (value->val.string.len + 1);
value->val.string.buff = (char*)calloc(count, sizeof(char));
if (!value->val.string.buff)
raise_enomem(error);
else if (is_binstr)
{
unsigned i;
const char *tok = str_start;
unsigned j = 0;
for (i = 0; i < value->val.string.len; i += 2)
{
uint8_t hi, lo;
char hic = tok[i];
char loc = tok[i + 1];
if (hic <= '9')
hi = hic - '0';
else
hi = (hic - 'A') + 10;
if (loc <= '9')
lo = loc - '0';
else
lo = (loc - 'A') + 10;
value->val.string.buff[j++] = hi * 16 + lo;
}
value->val.string.len = j;
}
else
memcpy(value->val.string.buff, str_start, value->val.string.len);
}
return buff;
}
static int
check_bom(int get_char(struct tok_state *),
void unget_char(int, struct tok_state *),
int set_readline(struct tok_state *, const char *),
struct tok_state *tok)
{
int ch1, ch2, ch3;
ch1 = get_char(tok);
tok->decoding_state = STATE_RAW;
if (ch1 == EOF) {
return 1;
} else if (ch1 == 0xEF) {
ch2 = get_char(tok);
if (ch2 != 0xBB) {
unget_char(ch2, tok);
unget_char(ch1, tok);
return 1;
}
ch3 = get_char(tok);
if (ch3 != 0xBF) {
unget_char(ch3, tok);
unget_char(ch2, tok);
unget_char(ch1, tok);
return 1;
}
#if 0
/* Disable support for UTF-16 BOMs until a decision
is made whether this needs to be supported. */
} else if (ch1 == 0xFE) {
ch2 = get_char(tok);
if (ch2 != 0xFF) {
unget_char(ch2, tok);
unget_char(ch1, tok);
return 1;
}
if (!set_readline(tok, "utf-16-be"))
return 0;
tok->decoding_state = STATE_NORMAL;
} else if (ch1 == 0xFF) {
ch2 = get_char(tok);
if (ch2 != 0xFE) {
unget_char(ch2, tok);
unget_char(ch1, tok);
return 1;
}
if (!set_readline(tok, "utf-16-le"))
return 0;
tok->decoding_state = STATE_NORMAL;
#endif
} else {
unget_char(ch1, tok);
return 1;
}
if (tok->encoding != NULL)
PyMem_FREE(tok->encoding);
tok->encoding = new_string("utf-8", 5, tok);
if (!tok->encoding)
return 0;
/* No need to set_readline: input is already utf-8 */
return 1;
}
oop bootstrap::get_object() {
char type = get_char();
if (type == '0') {
int v = get_integer();
// if (TraceBootstrap) std->print_cr("i %d", v);
return as_smiOop(v);
}
if (type == '-') {
int v = get_integer();
// if (TraceBootstrap) std->print_cr("i %d", -v);
return as_smiOop(-v);
}
if (type == '3') {
int v = get_integer();
// if (TraceBootstrap) std->print_cr("r %d", v);
return at(v);
}
int size = get_integer();
memOop m = as_memOop(Universe::allocate_tenured(size));
// Clear eventual padding area for byteArray, symbol, doubleByteArray.
m->raw_at_put(size-1, smiOop_zero);
// if (TraceBootstrap) lprintf("%c %d = 0x%lx\n", type, size, m);
add(m);
switch (type) {
// Classes
case 'A': KLASS_CASE(set_klassKlass_vtbl)
case 'B': KLASS_CASE(set_smiKlass_vtbl)
case 'C': KLASS_CASE(set_memOopKlass_vtbl)
case 'D': KLASS_CASE(set_byteArrayKlass_vtbl)
case 'E': KLASS_CASE(set_doubleByteArrayKlass_vtbl)
case 'F': KLASS_CASE(set_objArrayKlass_vtbl)
case 'G': KLASS_CASE(set_symbolKlass_vtbl)
case 'H': KLASS_CASE(set_doubleKlass_vtbl)
case 'I': KLASS_CASE(set_associationKlass_vtbl)
case 'J': KLASS_CASE(set_methodKlass_vtbl)
case 'K': KLASS_CASE(set_blockClosureKlass_vtbl)
case 'L': KLASS_CASE(set_contextKlass_vtbl)
case 'M': KLASS_CASE(set_proxyKlass_vtbl)
case 'N': KLASS_CASE(set_mixinKlass_vtbl)
case 'O': KLASS_CASE(set_weakArrayKlass_vtbl)
case 'P': KLASS_CASE(set_processKlass_vtbl)
case 'Q': KLASS_CASE(set_doubleValueArrayKlass_vtbl)
case 'R': KLASS_CASE(set_vframeKlass_vtbl)
// Objects
case 'a': OBJECT_ERROR("klass")
case 'b': OBJECT_ERROR("smi")
case 'c': OBJECT_CASE(memOop);
case 'd': OBJECT_CASE(byteArrayOop);
case 'e': OBJECT_CASE(doubleByteArrayOop);
case 'f': OBJECT_CASE(objArrayOop)
case 'g': SYMBOL_CASE(symbolOop);
case 'h': OBJECT_CASE(doubleOop);
case 'i': OBJECT_CASE(associationOop);
case 'j': OBJECT_CASE(methodOop);
case 'k': OBJECT_ERROR("blockClosure")
case 'l': OBJECT_ERROR("context")
case 'm': OBJECT_ERROR("proxy")
case 'n': OBJECT_CASE(mixinOop)
case 'o': OBJECT_ERROR("weakArrayOop")
case 'p': OBJECT_CASE(processOop)
default: fatal("unknown object type");
}
return m;
}
static int linenoiseEdit(struct current *current) {
int history_index = 0;
/* The latest history entry is always our current buffer, that
* initially is just an empty string. */
linenoiseHistoryAdd("");
set_current(current, "");
refreshLine(current->prompt, current);
while(1) {
int dir = -1;
int c = fd_read(current);
#ifndef NO_COMPLETION
/* Completion is forbidden for hidden input mode.
* Only autocomplete when the callback is set. It returns < 0 when
* there was an error reading from fd. Otherwise it will return the
* character that should be handled next. */
if (c == '\t' &&
!is_hidden &&
current->pos == current->chars &&
completionCallback != NULL) {
c = completeLine(current);
/* Return on errors */
if (c < 0) return current->len;
/* Read next character when 0 */
if (c == 0) continue;
}
#endif
process_char:
if (c == -1) return current->len;
#ifdef USE_TERMIOS
if (c == 27) { /* escape sequence */
c = check_special(current->fd);
}
#endif
switch(c) {
case '\r': /* enter */
history_len--;
free(history[history_len]);
return current->len;
case ctrl('C'): /* ctrl-c */
errno = EAGAIN;
return -1;
case 127: /* backspace */
case ctrl('H'):
if (remove_char(current, current->pos - 1) == 1) {
refreshLine(current->prompt, current);
}
break;
case ctrl('D'): /* ctrl-d */
if (current->len == 0) {
/* Empty line, so EOF */
history_len--;
free(history[history_len]);
return -1;
}
/* Otherwise fall through to delete char to right of cursor */
case SPECIAL_DELETE:
if (remove_char(current, current->pos) == 1) {
refreshLine(current->prompt, current);
}
break;
case SPECIAL_INSERT:
/* Ignore. Expansion Hook.
* Future possibility: Toggle Insert/Overwrite Modes
*/
break;
case ctrl('W'): /* ctrl-w, delete word at left. save deleted chars */
/* eat any spaces on the left */
{
int pos = current->pos;
while (pos > 0 && get_char(current, pos - 1) == ' ') {
pos--;
}
/* now eat any non-spaces on the left */
while (pos > 0 && get_char(current, pos - 1) != ' ') {
pos--;
}
if (remove_chars(current, pos, current->pos - pos)) {
refreshLine(current->prompt, current);
}
}
break;
case ctrl('R'): /* ctrl-r */
/* Hidden input mode disables use of the history */
if (!is_hidden) {
/* Display the reverse-i-search prompt and process chars */
char rbuf[50];
char rprompt[80];
int rchars = 0;
int rlen = 0;
int searchpos = history_len - 1;
rbuf[0] = 0;
while (1) {
int n = 0;
const char *p = NULL;
int skipsame = 0;
int searchdir = -1;
snprintf(rprompt, sizeof(rprompt), "(reverse-i-search)'%s': ", rbuf);
refreshLine(rprompt, current);
c = fd_read(current);
if (c == ctrl('H') || c == 127) {
if (rchars) {
int p = utf8_index(rbuf, --rchars);
rbuf[p] = 0;
rlen = strlen(rbuf);
}
continue;
}
#ifdef USE_TERMIOS
if (c == 27) {
c = check_special(current->fd);
}
#endif
if (c == ctrl('P') || c == SPECIAL_UP) {
/* Search for the previous (earlier) match */
if (searchpos > 0) {
searchpos--;
}
skipsame = 1;
}
else if (c == ctrl('N') || c == SPECIAL_DOWN) {
/* Search for the next (later) match */
if (searchpos < history_len) {
searchpos++;
}
searchdir = 1;
skipsame = 1;
}
else if (c >= ' ') {
if (rlen >= (int)sizeof(rbuf) + 3) {
continue;
}
n = utf8_getchars(rbuf + rlen, c);
rlen += n;
rchars++;
rbuf[rlen] = 0;
/* Adding a new char resets the search location */
searchpos = history_len - 1;
}
else {
/* Exit from incremental search mode */
break;
}
/* Now search through the history for a match */
for (; searchpos >= 0 && searchpos < history_len; searchpos += searchdir) {
p = strstr(history[searchpos], rbuf);
if (p) {
/* Found a match */
if (skipsame && strcmp(history[searchpos], current->buf) == 0) {
/* But it is identical, so skip it */
continue;
}
/* Copy the matching line and set the cursor position */
set_current(current,history[searchpos]);
current->pos = utf8_strlen(history[searchpos], p - history[searchpos]);
break;
}
}
if (!p && n) {
/* No match, so don't add it */
rchars--;
rlen -= n;
rbuf[rlen] = 0;
}
}
if (c == ctrl('G') || c == ctrl('C')) {
/* ctrl-g terminates the search with no effect */
set_current(current, "");
c = 0;
}
else if (c == ctrl('J')) {
/* ctrl-j terminates the search leaving the buffer in place */
c = 0;
}
/* Go process the char normally */
refreshLine(current->prompt, current);
goto process_char;
}
break;
case ctrl('T'): /* ctrl-t */
if (current->pos > 0 && current->pos <= current->chars) {
/* If cursor is at end, transpose the previous two chars */
int fixer = (current->pos == current->chars);
c = get_char(current, current->pos - fixer);
remove_char(current, current->pos - fixer);
insert_char(current, current->pos - 1, c);
refreshLine(current->prompt, current);
}
break;
case ctrl('V'): /* ctrl-v */
if (has_room(current, 3)) {
/* Insert the ^V first */
if (insert_char(current, current->pos, c)) {
refreshLine(current->prompt, current);
/* Now wait for the next char. Can insert anything except \0 */
c = fd_read(current);
/* Remove the ^V first */
remove_char(current, current->pos - 1);
if (c != -1) {
/* Insert the actual char */
insert_char(current, current->pos, c);
}
refreshLine(current->prompt, current);
}
}
break;
case ctrl('B'):
case SPECIAL_LEFT:
if (current->pos > 0) {
current->pos--;
refreshLine(current->prompt, current);
}
break;
case ctrl('F'):
case SPECIAL_RIGHT:
if (current->pos < current->chars) {
current->pos++;
refreshLine(current->prompt, current);
}
break;
case SPECIAL_PAGE_UP:
dir = history_len - history_index - 1; /* move to start of history */
goto history_navigation;
case SPECIAL_PAGE_DOWN:
dir = -history_index; /* move to 0 == end of history, i.e. current */
goto history_navigation;
case ctrl('P'):
case SPECIAL_UP:
dir = 1;
goto history_navigation;
case ctrl('N'):
case SPECIAL_DOWN:
history_navigation:
/* Hidden input mode disables use of the history */
if (!is_hidden && history_len > 1) {
/* Update the current history entry before to
* overwrite it with tne next one. */
free(history[history_len - 1 - history_index]);
history[history_len - 1 - history_index] = strdup(current->buf);
/* Show the new entry */
history_index += dir;
if (history_index < 0) {
history_index = 0;
break;
} else if (history_index >= history_len) {
history_index = history_len - 1;
break;
}
set_current(current, history[history_len - 1 - history_index]);
refreshLine(current->prompt, current);
}
break;
case ctrl('A'): /* Ctrl+a, go to the start of the line */
case SPECIAL_HOME:
current->pos = 0;
refreshLine(current->prompt, current);
break;
case ctrl('E'): /* ctrl+e, go to the end of the line */
case SPECIAL_END:
current->pos = current->chars;
refreshLine(current->prompt, current);
break;
case ctrl('U'): /* Ctrl+u, delete to beginning of line, save deleted chars. */
if (remove_chars(current, 0, current->pos)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('K'): /* Ctrl+k, delete from current to end of line, save deleted chars. */
if (remove_chars(current, current->pos, current->chars - current->pos)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('Y'): /* Ctrl+y, insert saved chars at current position */
if (current->capture && insert_chars(current, current->pos, current->capture)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('L'): /* Ctrl+L, clear screen */
clearScreen(current);
/* Force recalc of window size for serial terminals */
current->cols = 0;
refreshLine(current->prompt, current);
break;
default:
/* Only tab is allowed without ^V */
if (c == '\t' || c >= ' ') {
if (insert_char(current, current->pos, c) == 1) {
refreshLine(current->prompt, current);
}
}
break;
}
}
return current->len;
}
isearch(f, n)
{
int status; /* Search status */
int col; /* prompt column */
register int cpos; /* character number in search string */
register int c; /* current input character */
char pat_save[NPAT]; /* Saved copy of the old pattern str */
LINE *curline; /* Current line on entry */
int curoff; /* Current offset on entry */
int init_direction; /* The initial search direction */
/* Initialize starting conditions */
cmd_reexecute = -1; /* We're not re-executing (yet?) */
cmd_offset = 0; /* Start at the beginning of the buff */
cmd_buff[0] = '\0'; /* Init the command buffer */
strncpy (pat_save, pat, NPAT); /* Save the old pattern string */
curline = curwp->w_dotp; /* Save the current line pointer */
curoff = curwp->w_doto; /* Save the current offset */
init_direction = n; /* Save the initial search direction */
/* This is a good place to start a re-execution: */
start_over:
/* ask the user for the text of a pattern */
col = promptpattern("ISearch: "); /* Prompt, remember the col */
cpos = 0; /* Start afresh */
status = TRUE; /* Assume everything's cool */
/*
Get the first character in the pattern. If we get an initial Control-S
or Control-R, re-use the old search string and find the first occurrence
*/
c = get_char(); /* Get the first character */
if ((c == IS_FORWARD) ||
(c == IS_REVERSE) ||
(c == IS_VMSFORW)) /* Reuse old search string? */
{
for (cpos = 0; pat[cpos] != 0; cpos++) /* Yup, find the length */
col = echochar(pat[cpos],col); /* and re-echo the string */
if (c == IS_REVERSE) { /* forward search? */
n = -1; /* No, search in reverse */
backchar (TRUE, 1); /* Be defensive about EOB */
} else
n = 1; /* Yes, search forward */
status = scanmore(pat,n,status); /* Do the search */
c = get_char (); /* Get another character */
}
/* Top of the per character loop */
for (;;) /* ISearch per character loop */
{
/* Check for magic characters first: */
/* Most cases here change the search */
switch (c) /* dispatch on the input char */
{
case IS_ABORT: /* If abort search request */
return(FALSE); /* Quit searching again */
case IS_REVERSE: /* If backward search */
case IS_FORWARD: /* If forward search */
case IS_VMSFORW: /* of either flavor */
if (c == IS_REVERSE) /* If reverse search */
n = -1; /* Set the reverse direction */
else /* Otherwise, */
n = 1; /* go forward */
status = scanmore(pat,n,TRUE); /* Start the search again */
c = get_char (); /* Get the next char */
continue; /* Go continue with the search*/
case IS_QUIT: /* Want to quit searching? */
return (TRUE); /* Quit searching now */
case IS_NEWLINE: /* Carriage return */
c = '\n'; /* Make it a new line */
break; /* Make sure we use it */
case IS_QUOTE: /* Quote character */
case IS_VMSQUOTE: /* of either variety */
c = get_char (); /* Get the next char */
case IS_TAB: /* Generically allowed */
case '\n': /* controlled characters */
break; /* Make sure we use it */
case IS_BACKSP: /* If a backspace: */
case IS_RUBOUT: /* or if a Rubout: */
if (cmd_offset <= 1) /* Anything to delete? */
return (TRUE); /* No, just exit */
--cmd_offset; /* Back up over the Rubout */
cmd_buff[--cmd_offset] = '\0'; /* Yes, delete last char */
curwp->w_dotp = curline; /* Reset the line pointer */
curwp->w_doto = curoff; /* and the offset */
n = init_direction; /* Reset the search direction */
strncpy (pat, pat_save, NPAT); /* Restore the old search str */
cmd_reexecute = 0; /* Start the whole mess over */
goto start_over; /* Let it take care of itself */
/* Presumably a quasi-normal character comes here */
default: /* All other chars */
if (c < ' ') /* Is it printable? */
{ /* Nope. */
reeat (c); /* Re-eat the char */
return (TRUE); /* And return the last status */
}
} /* Switch */
/* I guess we got something to search for, so search for it */
pat[cpos++] = c; /* put the char in the buffer */
if (cpos >= NPAT) /* too many chars in string? */
{ /* Yup. Complain about it */
mlwrite("? Search string too long");
return(TRUE); /* Return an error */
}
pat[cpos] = 0; /* null terminate the buffer */
col = echochar(c,col); /* Echo the character */
if (!status) { /* If we lost last time */
(*term.t_putchar)(BELL); /* Feep again */
(*term.t_flush)(); /* see that the feep feeps */
} else /* Otherwise, we must have won*/
if (!(status = checknext(c,pat,n,status))) /* See if match */
status = scanmore(pat,n,TRUE); /* or find the next match */
c = get_char (); /* Get the next char */
} /* for {;;} */
}
