pty_t * pty_new(struct winsize * size) {
pty_t * pty = malloc(sizeof(pty_t));
/* stdin linkage; characters from terminal → PTY slave */
pty->in = ring_buffer_create(TTY_BUFFER_SIZE);
pty->out = ring_buffer_create(TTY_BUFFER_SIZE);
/* Master endpoint - writes go to stdin, reads come from stdout */
pty->master = pty_master_create(pty);
/* Slave endpoint, reads come from stdin, writes go to stdout */
pty->slave = pty_slave_create(pty);
/* TODO PTY name */
pty->name = 0;
if (size) {
memcpy(&pty->size, size, sizeof(struct winsize));
} else {
/* Sane defaults */
pty->size.ws_row = 25;
pty->size.ws_col = 80;
}
/* Controlling and foreground processes are set to 0 by default */
pty->ct_proc = 0;
pty->fg_proc = 0;
pty->tios.c_iflag = ICRNL | BRKINT;
pty->tios.c_oflag = ONLCR | OPOST;
pty->tios.c_lflag = ECHO | ECHOE | ECHOK | ICANON | ISIG | IEXTEN;
pty->tios.c_cflag = CREAD;
pty->tios.c_cc[VEOF] = 4; /* ^D */
pty->tios.c_cc[VEOL] = 0; /* Not set */
pty->tios.c_cc[VERASE] = '\b';
pty->tios.c_cc[VINTR] = 3; /* ^C */
pty->tios.c_cc[VKILL] = 21; /* ^U */
pty->tios.c_cc[VMIN] = 1;
pty->tios.c_cc[VQUIT] = 28; /* ^\ */
pty->tios.c_cc[VSTART] = 17; /* ^Q */
pty->tios.c_cc[VSTOP] = 19; /* ^S */
pty->tios.c_cc[VSUSP] = 26; /* ^Z */
pty->tios.c_cc[VTIME] = 0;
pty->canon_buffer = malloc(TTY_BUFFER_SIZE);
pty->canon_bufsize = TTY_BUFFER_SIZE;
pty->canon_buflen = 0;
return pty;
}
int main()
{
struct ring_buffer rb;
ring_buffer_create(&rb, 16);
ring_buffer_free(&rb);
return 0;
}
void init_buffer_socket(BufferSocket *bs, size_t item_count, size_t payload_len) {
// Initialize a BufferSocket
bs->buf = ring_buffer_create(item_count, payload_len);
set_callback(bs, &default_callback);
bs->run_threads = 0;
bs->userdata = NULL;
}
SEXP R_ring_buffer_create(SEXP r_size, SEXP r_stride) {
size_t size = (size_t)INTEGER(r_size)[0], stride = INTEGER(r_stride)[0];
if (size == 0) {
Rf_error("Can't create ring buffer with size 0");
}
if (stride == 0) {
Rf_error("Can't create ring buffer with stride 0");
}
return R_ring_buffer_build(ring_buffer_create(size, stride));
}
//Start USART with user defined callback
void usart_start(void (*receive_cb)(void)) {
//Set USART parameters (from setbaud.h)
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
#if USE_2X
UCSR0A |= (1<<U2X0);
#else
UCSR0A &= ~(1<<U2X0);
#endif
//Promote callback
usart_receive_cb = receive_cb;
//Enable USART
UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);
UCSR0B = (1<<TXEN0) | (1<<RXEN0) | (1<<RXCIE0);
rx_buff = ring_buffer_create(USART_BUFFER_SIZE);
tx_buff = ring_buffer_create(USART_BUFFER_SIZE);
}
fs_node_t * keyboard_create() {
fs_node_t * keyboard;
keyboard = (fs_node_t *)kmalloc(sizeof(keyboard));
strcpy(keyboard->name, "keyboard");
keyboard->mask = keyboard->uid = keyboard->gid = keyboard->inode = keyboard->length = 0;
keyboard->flags = FS_CHARDEVICE;
keyboard->buffer = ring_buffer_create(8);
// dev_root
keyboard->write = keyboard_write;
keyboard->read = keyboard_read;
return keyboard;
}
struct buffer *create_buffer(int size)
//@ requires true &*& size > 0 &*& size * sizeof(int) < INT_MAX &*& [_]ghost_cell<list<int> >(?id_contents, ?alltext);
/*@ ensures
[_]ghost_cell(id_contents, alltext)
&*& result == 0 ?
emp
:
buffer(result, id_contents, ?id_progress_read, ?id_progress_write)
&*& token(id_progress_read, 0)
&*& token(id_progress_write, 0);
@*/
{
struct buffer *buffer = malloc(sizeof(struct buffer));
if (buffer == 0){
return 0;
}
struct ring_buffer *ring_buffer = ring_buffer_create(size);
if (ring_buffer == 0){
free(buffer);
return 0;
}
buffer->ring_buffer = ring_buffer;
//@ int id_progress_read = create_ghost_cell(0);
//@ int id_progress_write = create_ghost_cell(0);
//@ close create_mutex_ghost_arg(buffer_protected(buffer, id_contents, id_progress_read, id_progress_write));
//@ close exists<list<int> >(nil);
//@ close buffer_protected(buffer, id_contents, id_progress_read, id_progress_write)();
buffer->mutex = create_mutex();
//@ close create_mutex_cond_ghost_args(buffer->mutex);
buffer->cond_can_push = create_mutex_cond();
//@ close create_mutex_cond_ghost_args(buffer->mutex);
buffer->cond_can_pop = create_mutex_cond();
return buffer;
//@ close buffer(buffer, id_contents, id_progress_read, id_progress_write);
//@ close token(id_progress_read, 0);
//@ close token(id_progress_write, 0);
}
static int
Buffer_init(Buffer *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {"order", NULL};
if ( !PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &self->order) ) {
return -1;
}
if (self->order == 0) {
self->order = 12; // the ring buffer size defaults to 4KB
}
if (self->order < 12) {
PyErr_SetString (PyExc_ValueError, "Order is too small, which has to be at least 12");
return NULL;
}
self->buffer = malloc(sizeof *self->buffer);
ring_buffer_create (self->buffer, self->order);
return 0;
}
