int autoconnect(fd_set *master, int *fdmax, servlist *serv) // XXX broken in the face of asynch nl [I have forgotten what was meant by this; I'm not aware of anything broken about this function]
{
servlist *curr=serv;
if(!curr) return(0);
#if ASYNCH_NL
char cstr[36+strlen(serv->name)+strlen(serv->portno)];
sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno);
nl_list *list=irc_connect(serv->name, serv->portno);
if(!list) return(autoconnect(master, fdmax, serv->next));
add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: ");
list->reconn_b=0;
list->autoent=serv;
#else /* ASYNCH_NL */
char cstr[36+strlen(serv->name)+strlen(serv->portno)];
sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno);
add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: ");
int serverhandle=irc_connect(serv->name, serv->portno, master, fdmax);
if(serverhandle)
{
bufs=(buffer *)realloc(bufs, ++nbufs*sizeof(buffer));
cbuf=nbufs-1;
init_buffer(cbuf, SERVER, serv->name, buflines);
bufs[cbuf].handle=serverhandle;
bufs[cbuf].nick=strdup(serv->nick);
bufs[cbuf].autoent=serv;
if(serv) bufs[cbuf].ilist=n_dup(serv->igns);
bufs[cbuf].server=cbuf;
bufs[cbuf].conninpr=true;
add_to_buffer(cbuf, STA, QUIET, 0, false, cstr, "auto: ");
redraw_buffer();
}
#endif /* ASYNCH_NL */
autoconnect(master, fdmax, serv->next);
return(1);
}
lexeme *st_backslash_in_quotes(lexer_info *linfo, buffer *buf)
{
#ifdef LEXER_DEBUG
print_state("ST_BACKSLASH_IN_QUOTES", linfo->c);
#endif
switch (linfo->c) {
case EOF:
linfo->state = ST_ERROR;
break;
case '\"':
add_to_buffer(buf, linfo->c);
break;
case '\n':
print_prompt2();
/* fallthrough */
default:
add_to_buffer(buf, '\\');
add_to_buffer(buf, linfo->c);
break;
}
deferred_get_char(linfo);
linfo->state = ST_IN_QUOTES;
return NULL;
}
nl_list *irc_connect(char *server, const char *portno)
{
// Look up server
struct addrinfo *hints=malloc(sizeof(struct addrinfo));
if(!hints)
{
add_to_buffer(0, ERR, NORMAL, 0, false, strerror(errno), "malloc: ");
return(NULL);
}
memset(hints, 0, sizeof(*hints));
hints->ai_family=AF_INET;
hints->ai_socktype = SOCK_STREAM; // TCP stream sockets
struct gaicb *nl_details=malloc(sizeof(struct gaicb));
if(!nl_details)
{
add_to_buffer(0, ERR, NORMAL, 0, false, strerror(errno), "malloc: ");
return(NULL);
}
nl_list *nl=malloc(sizeof(nl_list));
if(!nl)
{
add_to_buffer(0, ERR, NORMAL, 0, false, strerror(errno), "malloc: ");
free(nl_details);
return(NULL);
}
*nl=(nl_list){.nl_details=nl_details, .autoent=NULL, .reconn_b=0, .pass=NULL, .next=nl_active, .prev=NULL};
*nl_details=(struct gaicb){.ar_name=strdup(server), .ar_service=strdup(portno), .ar_request=hints};
if(nl_active) nl_active->prev=nl;
nl_active=nl;
getaddrinfo_a(GAI_NOWAIT, &nl->nl_details, 1, &(struct sigevent){.sigev_notify=SIGEV_SIGNAL, .sigev_signo=SIGUSR1});
return(nl_active);
}
// TODO Check it!
int result_iterate (void* json_v, int col_count, char** cols, char** col_names) {
int i;
long size, count;
char** json = (char**)json_v;
// Format string
if (add_to_buffer (json, "{") != 0)
return 1;
for (i = 0; i < col_count; i++) {
if (cols[i] == NULL)
continue;
size = buffer_est_size (*json) - 1;
count = snprintf (*json, (size_t)size, "%s: '%s'", col_names[i], cols[i]);
if (count >= size)
return 1;
(*json) += count;
if (i != col_count - 1)
if (add_to_buffer (json, ", ") != 0)
return 1;
}
if (add_to_buffer (json, "}, ") != 0)
return 1;
return 0;
}
int irc_rx(int fd, char ** data, fd_set *master)
{
sigpipe=0;
char buf[512];
unsigned long int l=0;
bool cr=false;
while(!(cr||sigpipe))
{
long bytes=recv(fd, buf+l, 1, 0);
if(bytes>0)
{
char c=buf[l];
if((strchr("\n\r", c)!=NULL) || (l>510))
{
cr=true;
buf[l]=0;
}
l++;
}
else // bytes<=0
{
if(errno==EINTR)
continue;
int b;
for(b=0;b<nbufs;b++)
{
if((fd==bufs[b].handle) && (bufs[b].type==SERVER))
{
add_to_buffer(b, ERR, NORMAL, 0, false, strerror(errno), "irc_rx: recv:");
bufs[b].live=false;
close(bufs[b].handle);
bufs[b].handle=0; // de-bind fd
}
}
FD_CLR(fd, master);
cr=true; // just crash out with a partial message
buf[l]=0;
}
}
*data=strdup(buf);
if(*buf)
{
char rmsg[32+strlen(buf)];
sprintf(rmsg, "%d, %lu bytes: %s", fd, l, buf);
add_to_buffer(0, STA, DEBUG, 0, false, rmsg, sigpipe?"DBG SIGPIPE rx: ":"DBG rx: ");
}
if(sigpipe)
{
sigpipe=0;
return(-1);
}
if(!*data)
return(1);
return(0);
}
int
create_sig (BUFFER * data, BUFFER * signature)
{
#ifdef USE_RSAREF
R_RSA_PRIVATE_KEY sigKey;
R_SIGNATURE_CTX context;
unsigned char sig[MAX_SIGNATURE_LEN];
unsigned int sigLen;
if (get_priv_key (NULL, &sigKey) != 0)
return -1;
R_SignInit (&context, DA_MD5);
R_SignUpdate (&context, data->message, data->length);
if (R_SignFinal (&context, sig, &sigLen, &sigKey) != 0)
{
fprintf (errlog, "Error: Cannot create signature.\n");
return (-1);
}
add_to_buffer (signature, sig, sigLen);
return 0;
#else
/* not implemented */
return (-1);
#endif
}
static void handle_search(t_htable *table, char *key, char *print_buf)
{
char *value;
if (!(value = get_hash(table, key)))
{
add_to_buffer(print_buf, key);
add_to_buffer(print_buf, ": Not found.\n");
}
else
{
add_to_buffer(print_buf, value);
add_to_buffer(print_buf, "\n");
}
free(key);
}
static PmError winmm_write_short(PmInternal *midi, PmEvent *event)
{
midiwinmm_type m = (midiwinmm_type) midi->descriptor;
PmError rslt = pmNoError;
assert(m);
if (midi->latency == 0) { /* use midiOut interface, ignore timestamps */
m->error = midiOutShortMsg(m->handle.out, event->message);
if (m->error) rslt = pmHostError;
} else { /* use midiStream interface -- pass data through buffers */
unsigned long when = event->timestamp;
unsigned long delta;
int full;
if (when == 0) when = midi->now;
/* when is in real_time; translate to intended stream time */
when = when + m->delta + midi->latency;
/* make sure we don't go backward in time */
if (when < m->last_time) when = m->last_time;
delta = when - m->last_time;
m->last_time = when;
/* before we insert any data, we must have a buffer */
if (m->hdr == NULL) {
/* stream interface: buffers allocated when stream is opened */
m->hdr = get_free_output_buffer(midi);
}
full = add_to_buffer(m, m->hdr, delta, event->message);
if (full) rslt = winmm_write_flush(midi, when);
}
return rslt;
}
/*
Producer thread function.
producer producers the set of integers
that satisfy i%num_producers = p_id;
Produer first waits till the buffer is not full.
Producer locks the buffer.
Producer inserts a value into a buffer.
Producer unlocks the buffer.
Producer notifies the buffer is not empty, by calling
sem_post(&count).
*/
void* producer(void* producer_params) {
struct thread_params *params = (struct thread_params*) producer_params;
int p_id = params->id;
int i;
for (i = p_id; i < production_count; i += producer_count) {
//wait until buffer is not full
sem_wait(&buff_size);
//toggle the lock
sem_wait(&buff_lock);
//add item to buffer
add_to_buffer(i);
//release the lock
sem_post(&buff_lock);
//notify that the buffer is not empty.
sem_post(&count);
}
return NULL;
}
static int run_scan_word(lua_State * L) /* HH */
{
saved_tex_scanner texstate;
save_tex_scanner(texstate);
do {
get_x_token();
} while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
if (cur_cmd == 11 || cur_cmd == 12 ) {
declare_buffer;
while (1) {
add_to_buffer(cur_chr);
get_x_token();
if (cur_cmd != 11 && cur_cmd != 12 ) {
break ;
}
}
back_input();
push_buffer;
} else {
back_input();
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
static void sensorResponded(char response, int time) {
if (!IGNORE_RESULT) {
for (int i = 0; i < 8; i++) {
int mask = 1 << i;
int offset = 0;
if (CURR_HIGH_BITS) {
offset += 8;
}
if ((mask & response) != 0 && SENSOR_VALUE[CURR_SENSOR_BOX][7-i+offset] == 0) {
Sensor s;
s.box = CURR_SENSOR_BOX;
s.val = 8 -i + offset;
s.time = time;
add_to_buffer(s);
}
SENSOR_VALUE[CURR_SENSOR_BOX][7-i+offset] = ((mask & response) !=0);
}
}
if (CURR_HIGH_BITS) {
CURR_HIGH_BITS = 0;
++CURR_SENSOR_BOX;
} else {
CURR_HIGH_BITS = 1;
}
if (CURR_SENSOR_BOX >= NUM_SENSOR_BOX) {
CURR_SENSOR_BOX = 0;
IGNORE_RESULT = 0;
}
}
int irc_conn_rest(int b, char *nick, char *username, char *passwd, char *fullname)
{
add_to_buffer(0, STA, DEBUG, 0, false, "", "DBG connect rest");
bufs[b].live=true; // mark it as live
bufs[b].conninpr=false;
bufs[b].ping=0;
bufs[b].last=time(NULL);
if(bufs[b].autoent && bufs[b].autoent->nick)
nick=bufs[b].autoent->nick;
if(bufs[b].autoent && bufs[b].autoent->pass)
passwd=bufs[b].autoent->pass;
if(passwd) // Optionally send a PASS message before the NICK/USER
{
char passmsg[6+strlen(passwd)];
sprintf(passmsg, "PASS %s", passwd); // PASS <password>
irc_tx(bufs[b].handle, passmsg);
}
char nickmsg[6+strlen(nick)];
sprintf(nickmsg, "NICK %s", nick); // NICK <nickname>
irc_tx(bufs[b].handle, nickmsg);
struct utsname arch;
uname(&arch);
char usermsg[16+strlen(username)+strlen(arch.nodename)+strlen(fullname)];
sprintf(usermsg, "USER %s 0 %s :%s", username, arch.nodename, fullname); // USER <user> <mode> <unused> <realname>
irc_tx(bufs[b].handle, usermsg);
return(0);
}
void init(char *yaffs_test_dir,char *yaffs_mount_dir,int argc, char *argv[]){
char output=0;
int x=0;
int seed=-1;
FILE *log_handle;
/*these variables are already set to zero, but it is better not to take chances*/
message_buffer.head=0;
message_buffer.tail=0;
log_handle=fopen(LOG_FILE,"w");
if (log_handle!=NULL){
fputs("log file for yaffs tester\n",log_handle);
fclose(log_handle);
}
add_to_buffer(&message_buffer,"welcome to the yaffs tester",MESSAGE_LEVEL_BASIC_TASKS,PRINT);/* print boot up message*/
yaffs_start_up();
yaffs_mount(yaffs_mount_dir);
for (x=0;x<argc;x++){
// add_to_buffer(&message_buffer,"argv ",MESSAGE_LEVEL_BASIC_TASKS,PRINT);
// add_to_buffer(&message_buffer,argv[x],MESSAGE_LEVEL_BASIC_TASKS,PRINT);
if (strcmp("-seed",argv[x])==0){ /*warning only compares the length of the strings, quick fix*/
seed= atoi(argv[x+1]);
/*add_to_buffer(&message_buffer,"setting seed to ",MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_int_to_buffer(&message_buffer,seed,MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_to_buffer(&message_buffer,"\n",MESSAGE_LEVEL_BASIC_TASKS,PRINT);*/
}
}
if (seed==-1){
seed=time(NULL);
srand(seed);
}
else {
srand(seed);
}
add_to_buffer(&message_buffer,"setting seed to ",MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_int_to_buffer(&message_buffer,seed,MESSAGE_LEVEL_BASIC_TASKS,PRINT);/* print boot up message*/
if (yaffs_access(yaffs_test_dir,0)) /* if the test folder does not exist then create it */
{
add_to_buffer(&message_buffer,"creating dir: ",MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_to_buffer(&message_buffer,yaffs_test_dir,MESSAGE_LEVEL_BASIC_TASKS,PRINT);
output=yaffs_mkdir(yaffs_test_dir,S_IREAD | S_IWRITE);
yaffs_check_for_errors(output, &message_buffer,"could not create dir","created dir\n\n");
}
}
int
compress_buf2buf (BUFFER * in, BUFFER * out, long offset)
{
z_stream s;
int err;
char outbuf[4096];
if (compressed_buf (in, offset))
{
/* is already compressed */
add_to_buffer (out, in->message, in->length);
return 0;
}
add_to_buffer (out, in->message, offset);
s.zalloc = (alloc_func) 0;
s.zfree = (free_func) 0;
s.opaque = (voidpf) 0;
s.next_in = NULL;
sprintf (outbuf, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
Z_DEFLATED, 0 /*flags */ , 0, 0, 0, 0 /*time */ , 0 /*xflags */ ,
3 /* Unix */ );
add_to_buffer (out, outbuf, 10);
if (deflateInit2 (&s, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS,
8, 0) != Z_OK)
return 0;
s.next_in = in->message + offset;
s.avail_in = in->length - offset;
s.next_out = outbuf;
s.avail_out = sizeof (outbuf);
while ((err = deflate (&s, Z_FINISH)) == Z_OK)
{
add_to_buffer (out, outbuf, sizeof (outbuf) - s.avail_out);
s.next_out = outbuf;
s.avail_out = sizeof (outbuf);
}
add_to_buffer (out, outbuf, sizeof (outbuf) - s.avail_out);
if (deflateEnd (&s) != Z_OK || err != Z_STREAM_END)
return 0;
return 1;
}
ssize_t
read_buffer(int fd, struct buffer_s * buffptr)
{
ssize_t bytesin;
unsigned char *buffer;
assert(fd >= 0);
assert(buffptr != NULL);
/*
* Don't allow the buffer to grow larger than MAXBUFFSIZE
*/
if (buffptr->size >= MAXBUFFSIZE)
return 0;
buffer = safemalloc(READ_BUFFER_SIZE);
if (!buffer) {
return -ENOMEM;
}
bytesin = read(fd, buffer, READ_BUFFER_SIZE);
if (bytesin > 0) {
if (add_to_buffer(buffptr, buffer, bytesin) < 0) {
log_message(LOG_ERR,
"readbuff: add_to_buffer() error.");
bytesin = -1;
}
} else {
if (bytesin == 0) {
/* connection was closed by client */
bytesin = -1;
} else {
switch (errno) {
#ifdef EWOULDBLOCK
case EWOULDBLOCK:
#else
# ifdef EAGAIN
case EAGAIN:
# endif
#endif
case EINTR:
bytesin = 0;
break;
default:
log_message(LOG_ERR,
"readbuff: recv() error \"%s\" on file descriptor %d",
strerror(errno), fd);
bytesin = -1;
break;
}
}
}
safefree(buffer);
return bytesin;
}
int
uncompress_buf2buf (BUFFER * in, BUFFER * out, long offset)
{
z_stream s;
char outbuf[4096];
byte *p;
int err;
if (!compressed_buf (in, offset))
return 0; /* not compressed */
add_to_buffer (out, in->message, offset);
s.zalloc = (alloc_func) 0;
s.zfree = (free_func) 0;
s.opaque = (voidpf) 0;
p = gzheader (in->message + offset, in->length);
if (p == NULL)
return -1;
s.next_in = p;
s.avail_in = in->length - (p - in->message);
s.next_out = NULL;
if (inflateInit2 (&s, -MAX_WBITS) != Z_OK)
return (-1);
s.next_out = outbuf;
s.avail_out = sizeof (outbuf);
while ((err = inflate (&s, Z_PARTIAL_FLUSH)) == Z_OK)
{
add_to_buffer (out, outbuf, sizeof (outbuf) - s.avail_out);
s.next_out = outbuf;
s.avail_out = sizeof (outbuf);
}
add_to_buffer (out, outbuf, sizeof (outbuf) - s.avail_out);
if ((err=inflateEnd (&s) != Z_OK))
{
fprintf (errlog, "Decompression error. %d\n",err);
return (-1);
}
return 1; /* compressed */
}
/* The message is returned in a static buffer, so don't call this
again until you're done with the previous response or it will be overwritten. */
const char* recv_msg(char *buf, int bufsize) {
int val;
fd_set read_fdset;
fd_set except_fdset;
struct timeval tv;
char readbuf[bufsize];
unsigned int totalbytes;
/* Is there already a reply in the buffer from before? (can happen if
we get multiple lines in one read) */
const char *reply_msg = extract_reply(buf);
if (reply_msg != NULL)
return reply_msg;
while (1) {
tv.tv_sec = 1;
tv.tv_usec = 0;
FD_ZERO(&read_fdset);
FD_ZERO(&except_fdset);
FD_SET(sock, &read_fdset);
FD_SET(sock, &except_fdset);
if (select(sock+1, &read_fdset, NULL, &except_fdset, &tv) == 0) {
/* we've waited 2 seconds and got no response - too long - conclude
the socket is dead */
printf("timed out waiting response\n");
//connect_to_robot();
//initialize_robot();
return 0;
}
if (FD_ISSET(sock, &except_fdset)) {
connect_to_robot();
re_initialize_robot();
return 0;
}
assert(FD_ISSET(sock, &read_fdset));
val = read(sock, readbuf, bufsize-1);
if (val > 0) {
} else {
/* the write failed - likely the robot was switched off - attempt
to reconnect and reinitialize */
connect_to_robot();
re_initialize_robot();
buf[0]='\0';
return 0;
}
/* ensure readbuf is null terminated */
readbuf[val] = '\0';
totalbytes = strlen(buf);
add_to_buffer(buf, &totalbytes, readbuf);
reply_msg = extract_reply(buf);
if (reply_msg != NULL)
return reply_msg;
}
}
EXPORT void CALL
AiLenChanged( void )
{
// FIXME: We may need near full speed before this is going to work
if(!audioEnabled) return;
short* stream = (short*)(AudioInfo.RDRAM +
(*AudioInfo.AI_DRAM_ADDR_REG & 0xFFFFFF));
unsigned int length = *AudioInfo.AI_LEN_REG;
add_to_buffer(stream, length);
}
void join_paths(char *path1,char *path2,char *new_path ){
/* printf("strlen path1:%d\n",strlen(path1));
printf("strlen path2:%d\n",strlen(path2));
printf("path1; %s\n",path1);
*/
add_to_buffer(&message_buffer, "joining paths:",MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_to_buffer(&message_buffer,path1,MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_to_buffer(&message_buffer, " and ",MESSAGE_LEVEL_BASIC_TASKS,NPRINT);
append_to_buffer(&message_buffer, path2,MESSAGE_LEVEL_BASIC_TASKS,PRINT);
if ( (path1[(sizeof(path1)/sizeof(char))-2]=='/') && path2[0]!='/') {
/*paths are compatiable. concatanate them. note -2 is because of \0*/
strcat(new_path,path1);
strcat(new_path,path2);
//char new_path[(sizeof(path1)/sizeof(char))+(sizeof(path2)/sizeof(char))];
//strcpy(new_path,strcat(path1,path2));
//return new_path;
}
else if ((path1[(sizeof(path1)/sizeof(char))-2]!='/') && path2[0]=='/') {
/*paths are compatiable. concatanate them*/
strcat(new_path,path1);
strcat(new_path,path2);
//char new_path[(sizeof(path1)/sizeof(char))+(sizeof(path2)/sizeof(char))];
//strcpy(new_path,strcat(path1,path2));
//return new_path;
}
else if ((path1[(sizeof(path1)/sizeof(char))-2]!='/') && path2[0]!='/') {
/*need to add a "/". */
strcat(new_path,path1);
strcat(new_path,"/");
strcat(new_path,path2);
//strcpy(new_path,strcat(path1,strcat("/\0",path2)));
#if 0
copy_array(path1,new_path,0,0);
copy_array('\0',new_path,0,(sizeof(path1)/sizeof(char)));
copy_array(path2,new_path,0,(sizeof(path1)/sizeof(char))+1);
old method now trying to use copy_array
//char new_path[(sizeof(path1)/sizeof(char))+(sizeof(path2)/sizeof(char))+1];
for (x=0;x<=(sizeof(path1)/sizeof(char))-1;x++){
new_path[x]=path1[x];
}
new_path[x+1]='/';
for (x=(sizeof(path1)/sizeof(char)) ,i=0 ;i<=(sizeof(path2)/sizeof(char));x++,i++){
new_path[x]=path2[i];
}
#endif
//return new_path;
}
lexeme *st_backslash(lexer_info *linfo, buffer *buf)
{
#ifdef LEXER_DEBUG
print_state("ST_BACKSLASH", linfo->c);
#endif
switch (linfo->c) {
case EOF:
linfo->state = ST_ERROR;
return NULL;
case '\n':
/* Ignore newline symbol */
print_prompt2();
break;
/* Non bash-like behaviour. In bash substitution
* makes in $'string' costruction. */
case 'a':
add_to_buffer(buf, '\a');
break;
case 'b':
add_to_buffer(buf, '\b');
break;
case 'f':
add_to_buffer(buf, '\f');
break;
case 'n':
add_to_buffer(buf, '\n');
break;
case 'r':
add_to_buffer(buf, '\r');
break;
case 't':
add_to_buffer(buf, '\t');
break;
case 'v':
add_to_buffer(buf, '\v');
break;
default:
add_to_buffer(buf, linfo->c);
break;
}
deferred_get_char(linfo);
linfo->state = ST_WORD;
return NULL;
}
int irc_tx(int fd, char * packet)
{
sigpipe=0;
char pq[512];
low_quote(packet, pq);
unsigned long l=min(strlen(pq), 511);
unsigned long p=0;
while((p<l)&&!sigpipe)
{
signed long j=send(fd, pq+p, l-p, 0);
if(j<1)
{
if(errno==EINTR)
continue;
return(p); // Something went wrong with send()!
}
p+=j;
}
if(sigpipe)
{
char tmsg[32+strlen(pq)];
sprintf(tmsg, "%d, %lu bytes: %s", fd, p, pq);
add_to_buffer(0, STA, DEBUG, 0, false, tmsg, "DBG SIGPIPE tx: ");
sigpipe=0;
return(-1);
}
send(fd, "\n", 1, 0);
char tmsg[32+strlen(pq)];
sprintf(tmsg, "%d, %lu bytes: %s", fd, l, pq);
add_to_buffer(0, STA, DEBUG, 0, false, tmsg, "DBG tx: ");
if(sigpipe)
{
sigpipe=0;
return(-1);
}
return(l); // Return the number of bytes sent
}
lexeme *st_one_two_sym_lex(lexer_info *linfo, buffer *buf)
{
lexeme *lex = NULL;
#ifdef LEXER_DEBUG
print_state("ST_ONE_TWO_SYM_LEX", linfo->c);
#endif
if (buf->count_sym == 0) {
add_to_buffer(buf, linfo->c);
deferred_get_char(linfo);
} else if (buf->count_sym == 1) {
/* TODO: make it more pretty */
char prev_c = get_last_from_buffer(buf);
clear_buffer(buf);
switch (prev_c) {
case '>':
lex = (prev_c == linfo->c) ?
make_lex(LEX_APPEND) :
make_lex(LEX_OUTPUT);
break;
case '|':
lex = (prev_c == linfo->c) ?
make_lex(LEX_OR) :
make_lex(LEX_PIPE);
break;
case '&':
lex = (prev_c == linfo->c) ?
make_lex(LEX_AND) :
make_lex(LEX_BACKGROUND);
break;
default:
fprintf(stderr, "Lexer: error (type 1) in ST_ONE_TWO_SYM_LEX;");
print_state("ST_ONE_TWO_SYM_LEX", linfo->c);
exit(ES_LEXER_INCURABLE_ERROR);
}
if (prev_c == linfo->c)
deferred_get_char(linfo);
linfo->state = ST_START;
return lex;
} else {
fprintf(stderr, "Lexer: error (type 2) in ST_ONE_TWO_SYM_LEX;");
print_state("ST_ONE_TWO_SYM_LEX", linfo->c);
exit(ES_LEXER_INCURABLE_ERROR);
}
return lex;
}
static int run_scan_argument(lua_State * L) /* HH */
{ /* can be simplified, no need for intermediate list */
saved_tex_scanner texstate;
halfword t, saved_defref;
save_tex_scanner(texstate);
do {
get_token();
} while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
if (cur_cmd == left_brace_cmd) {
back_input();
saved_defref = def_ref;
(void) scan_toks(false, true);
t = def_ref;
def_ref = saved_defref;
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == call_cmd) {
halfword saved_cur_tok = cur_tok;
cur_tok = right_brace_token + '}';
back_input();
cur_tok = saved_cur_tok;
back_input();
cur_tok = left_brace_token + '{';
back_input();
saved_defref = def_ref;
(void) scan_toks(false, true);
t = def_ref;
def_ref = saved_defref;
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == 11 || cur_cmd == 12 ) {
declare_buffer;
while (1) {
add_to_buffer(cur_chr);
get_x_token();
if (cur_cmd != 11 && cur_cmd != 12 ) {
break ;
}
}
back_input();
push_buffer;
} else {
back_input();
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
int initialise_buffers(int buflines)
{
bufs=malloc(sizeof(buffer));
if(!bufs)
return(1);
init_buffer(0, STATUS, "status", buflines); // buf 0 is always STATUS
nbufs=1;
cbuf=0;
bufs[0].live=true; // STATUS is never dead
bufs[0].nick=nick;
nick=NULL;
bufs[0].ilist=igns;
add_to_buffer(0, STA, QUIET, 0, false, GPL_TAIL, "quirc -- ");
init_ring(&d_buf);
d_buf.loop=true;
return(0);
}
int
readbuf (int fd, BUFFER * b)
{
int len;
char *p;
if (readn (fd, (char *) &len, sizeof (len)) != sizeof (len))
return (0);
len = ntohs (len);
if (len > 32 * 1024)
return (0);
p = malloc (len);
if (readn (fd, p, len) != len)
return (0);
add_to_buffer (b, p, len);
free (p);
return (1);
}
static
PT_THREAD(producer(struct pt *pt))
{
static int produced;
PT_BEGIN(pt);
for(produced = 0; produced < NUM_ITEMS; ++produced) {
PT_SEM_WAIT(pt, &full);
add_to_buffer(produce_item());
PT_SEM_SIGNAL(pt, &empty);
}
PT_END(pt);
}
int main(void)
{
setlocale(LC_ALL, "Russian");
char buffer[MAX_STR_LENGTH];
init_buffer();
FILE* file;
fopen_s(&file, "prog.pas", "r");
while (!feof(file))
{
fgets(buffer, MAX_STR_LENGTH, file);
add_to_buffer(buffer);
}
fclose(file);
process_program();
getchar();
return 0;
}
lexeme *st_word(lexer_info *linfo, buffer *buf)
{
lexeme *lex = NULL;
#ifdef LEXER_DEBUG
print_state("ST_WORD", linfo->c);
#endif
switch (linfo->c) {
case EOF:
case '\n':
case ' ':
case '\t':
case '<':
case ';':
case '(':
case ')':
case '>':
case '|':
case '&':
case '`':
linfo->state = ST_START;
lex = make_lex(LEX_WORD);
lex->str = convert_to_string(buf, 1);
return lex;
case '\\':
deferred_get_char(linfo);
linfo->state = ST_BACKSLASH;
break;
case '\"':
deferred_get_char(linfo);
linfo->state = ST_IN_QUOTES;
break;
default:
add_to_buffer(buf, linfo->c);
deferred_get_char(linfo);
}
return lex;
}
/**
* Free stack buffer.
*
* \param b pointer to buffer
*
*/
#ifdef CHECK_BUFFERS
void stack_buffer_free ( buffer_t *b, uint8_t which_from )
#else /* !CHECK_BUFFERS */
void stack_buffer_free ( buffer_t *b)
// which from : which code part sends the command
#endif /* CHECK_BUFFERS */
{
if (b !=0 )
{
debug("fre\r\n");
#ifdef CHECK_BUFFERS
if (add_to_buffer(b, avail_buffers, "avail_buf") == pdFALSE) {
debug_printf("from: %d\r\n", which_from);
}
#endif /* CHECK_BUFFERS */
if ((b != last_buffer_pushed) || (b->options.last_buffer_when_pulled == 1) /*means b is the last buffer available all other are in the stack*/)
{
b->from = MODULE_NONE;
b->to = MODULE_NONE;
memset(b, 0, sizeof(buffer_t));
if(safe_xQueueSend( buffers, ( void * ) &b, ( portTickType ) 5 ) != pdTRUE)
{
stack_mac_check_buffers = pdTRUE;
#ifdef CHECK_BUFFERS
debug_printf("S: Buf queue error from: %d\r\n", which_from);
#else /* !CHECK_BUFFERS */
debug("S: Buf queue error\r\n");
#endif /* CHECK_BUFFERS */
}
else
{
buffer_left++;
last_buffer_pushed = b;
b = 0;
}
}
}
}
void static write(int fd, byte data)
{
char spc_chr = special_char_behaviour(data);
if (spc_chr && spc_chr != '\b')
return;
if (fd == WRITE)
{
if (!spc_chr)
{
if (current_shell->lbuf_offset < MAX_LINE - 1)
{
add_to_buffer(data);
} else {
return;
}
} else {
if (current_shell->lbuf_offset)
{
current_shell->
line_buffer[--current_shell->lbuf_offset] = 0;
}
return;
}
}
if (current_shell->cursor >= 4000)
{
jump_line();
current_shell->cursor -= 160;
}
out_video(current_shell->cursor, data);
current_shell->cursor+=2;
}
