int main(void) {
int input, ret;
const char *prompt = "Input please: ";
printf("Enter the number between 0 and 10 and I will tell you your grade!\n");
while(1) {
printf("%s", prompt);
ret = scanf("%d", &input);
if(ret == 0) {
printf("Sorry, invalid character data, your input must be from 0 to 10.\n");
flush_stream();
continue;
}
if(ret > 0) {
if (input < 0 || input > 10) {
printf("Sorry, invalid character data, your input must be from 0 to 10.\n");
flush_stream();
continue;
}
switch (input) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
printf("Your grade is F. \n");
break;
case 6:
printf("Your grade is D. \n");
break;
}
}
}
}
//read string from stdin
void scan_string(char* ptr)
{
int i = 0;
char c;
//clean stdin before emp name input
flush_stream();
while(((c = getchar()) != '\n') && (i < SIZE))
{
*(ptr + i) = c;
++i;
}
//if number of characters read is exactly the amount of memory allocated, then, overwrite last char with nul ('\0')
//else simply append nul ('\0') at the end
if(i == SIZE)
{
--i;
}
*(ptr + i) = '\0';
//clean stdin after emp name input to dump extra characters in stream
//if user hasn't pressed '\n' already, only then clean until newline is encountered
if(c != '\n')
{
flush_stream();
}
}
int free_stream(struct Stream_t **Stream)
{
if(!*Stream)
return -1;
int ret = 0;
if(! --(*Stream)->refs)
{
if((*Stream)->Class->flush)
ret |= (*Stream)->Class->flush(*Stream);
if((*Stream)->Class->freeFunc)
ret |= (*Stream)->Class->freeFunc(*Stream);
if((*Stream)->Next)
ret |= free_stream(&(*Stream)->Next);
free(*Stream);
}
else if ((*Stream)->Next)
ret |= flush_stream((*Stream)->Next);
*Stream = NULL;
return ret;
}
static void event_get_context(void * arg) {
GetContextArgs * s = (GetContextArgs *)arg;
Channel * c = s->c;
Context * ctx = s->ctx;
if (!is_stream_closed(c)) {
int err = 0;
write_stringz(&c->out, "R");
write_stringz(&c->out, s->token);
if (ctx->exited) err = ERR_ALREADY_EXITED;
write_errno(&c->out, err);
if (err == 0) {
write_context(&c->out, ctx, s->parent != 0);
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
}
stream_unlock(c);
context_unlock(ctx);
loc_free(s);
}
static void process_exited(ChildProcess * prs) {
send_event_process_exited(&prs->bcg->out, prs);
flush_stream(&prs->bcg->out);
#if defined(_WRS_KERNEL)
semTake(prs_list_lock, WAIT_FOREVER);
#endif
list_remove(&prs->link);
close(prs->inp);
close(prs->out);
if (prs->out != prs->err) close(prs->err);
if (prs->inp_struct) {
ProcessInput * inp = prs->inp_struct;
if (!inp->req_posted) {
virtual_stream_delete(inp->vstream);
loc_free(inp);
}
else {
inp->prs = NULL;
}
}
if (prs->out_struct) prs->out_struct->prs = NULL;
if (prs->err_struct) prs->err_struct->prs = NULL;
loc_free(prs);
#if defined(_WRS_KERNEL)
semGive(prs_list_lock);
#endif
}
__int64 read_int(FILE* fp)
{
__int64 n = 0;
__int8 result;
char ch;
do
{
result = fscanf(fp, "%lld", &n);
if (result == EOF)
{
fprintf(stderr, "Unexpected EOF\n");
exit(74);
}
if (result == 0)
{
do
{
ch = fgetc(fp);
} while (ch <= '0' && ch >= '9');
fprintf(stderr, "Incorrect symbol\n");
}
} while (!result);
flush_stream(fp);
return n;
}
static long write_metadata_block_packets(FILE *out, const int serial, const char *vendor, const size_t num_tags, char **tags, size_t padding, ogg_packet **metadata)
{
const size_t header_length = vc_size(vendor, num_tags, tags);
if (header_length > (2<<24))
return OGGEDIT_ALLOCATION_FAILURE;
char magic[4];
magic[0] = VCTYPE;
magic[1] = header_length >> 16 & 0xFF;
magic[2] = header_length >> 8 & 0xFF;
magic[3] = header_length & 0xFF;
ogg_packet_clear(metadata[0]);
if (!fill_vc_packet(magic, 4, vendor, num_tags, tags, false, padding, metadata[0]))
return OGGEDIT_ALLOCATION_FAILURE;
ogg_stream_state os;
if (ogg_stream_init(&os, serial))
return OGGEDIT_FAILED_TO_INIT_STREAM;
os.b_o_s = 1;
os.pageno = 1;
for (int i = 0; metadata[i]; i++) {
if (!metadata[i+1])
metadata[i]->packet[0] |= LASTBLOCK;
ogg_stream_packetin(&os, metadata[i]);
}
return flush_stream(out, &os);
}
void send_stream_format(int fd, const char *fmt, ...)
{
unsigned int len;
va_list ap;
char s[FORMAT_STRING_SIZE];
va_start(ap, fmt);
len = vsnprintf(s, FORMAT_STRING_SIZE, fmt, ap);
va_end(ap);
if (len >= FORMAT_STRING_SIZE)
{
char *s2 = malloc(len + 1);
va_start(ap, fmt);
vsprintf(s2, fmt, ap);
va_end(ap);
send_stream(fd, s2, len);
free(s2);
}
else
send_stream(fd, s, len);
flush_stream(fd);
}
static void send_read_reply(StreamClient * client, char * token, size_t size) {
VirtualStream * stream = client->stream;
Channel * c = client->channel;
unsigned lost = 0;
unsigned read1 = 0;
unsigned read2 = 0;
int eos = 0;
char * data1 = NULL;
char * data2 = NULL;
unsigned pos = 0;
unsigned len = (stream->buf_inp + stream->buf_len - stream->buf_out) % stream->buf_len;
assert(len > 0 || stream->eos);
assert(client->pos <= stream->pos);
if ((uint64_t)len < stream->pos - client->pos) {
lost = (long)(stream->pos - client->pos - len);
}
else {
len = (unsigned)(stream->pos - client->pos);
}
pos = (stream->buf_inp + stream->buf_len - len) % stream->buf_len;
if (len > size) len = size;
data1 = stream->buf + pos;
if (pos + len <= stream->buf_len) {
read1 = len;
}
else {
read1 = stream->buf_len - pos;
data2 = stream->buf;
read2 = len - read1;
}
assert(read1 + read2 == len);
client->pos += lost + read1 + read2;
assert(client->pos <= stream->pos);
if (client->pos == stream->pos && stream->eos) eos = 1;
assert(eos || lost + read1 + read2 > 0);
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
if (read1 + read2 > 0) {
JsonWriteBinaryState state;
json_write_binary_start(&state, &c->out, read1 + read2);
json_write_binary_data(&state, data1, read1);
json_write_binary_data(&state, data2, read2);
json_write_binary_end(&state);
write_stream(&c->out, 0);
}
else {
write_stringz(&c->out, "null");
}
write_errno(&c->out, 0);
json_write_long(&c->out, lost);
write_stream(&c->out, 0);
json_write_boolean(&c->out, eos);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
}
static void event_context_created(Context * ctx, void * client_data) {
TCFBroadcastGroup * bcg = client_data;
assert(!ctx->exited);
assert(!ctx->intercepted);
assert(!ctx->stopped);
send_event_context_added(&bcg->out, ctx);
flush_stream(&bcg->out);
}
static void event_context_exited(Context * ctx, void * client_data) {
TCFBroadcastGroup * bcg = client_data;
assert(!ctx->stopped);
assert(!ctx->intercepted);
if (ctx->pending_safe_event) check_safe_events(ctx);
send_event_context_removed(&bcg->out, ctx);
flush_stream(&bcg->out);
}
int flush_stream(Stream_t *Stream)
{
int ret=0;
if(!batchmode) {
if(Stream->Class->flush)
ret |= Stream->Class->flush(Stream);
if(Stream->Next)
ret |= flush_stream(Stream->Next);
}
return ret;
}
state input_str(void* data, void* params)
{
cci.dwSize = 5;
cci.bVisible = TRUE;
SetConsoleCursorInfo(hConsole, &cci);
system("cls");
flush_stream(stdin);
printf(Rus("Вводите строки.\n"));
printf(Rus("Для прекращения ввода-<Enter> в начале строки.\n"));
str = read_strings(stdin, str, &str_count);
return REDRAW_ALL;
}
state input_arr(void* data, void* params)
{
cci.dwSize = 5;
cci.bVisible = TRUE;
SetConsoleCursorInfo(hConsole, &cci);
system("cls");
flush_stream(stdin);
printf(Rus("Вводите числа и они будут записаны в массив.\n"));
printf(Rus("Для прекращения ввода-<Enter> в начале строки.\n"));
arr = read_array(arr, &arr_count);
return REDRAW_ALL;
}
int flush_stream(struct Stream_t *Stream)
{
int ret = 0;
if(Stream->Class->flush)
ret |= Stream->Class->flush(Stream);
if(Stream->Next)
ret |= flush_stream(Stream->Next);
return ret;
}
void xmpp_close ( void )
{
/* Close stream */
send_stream_ascii ( session.wfs, "</stream:stream>" );
flush_stream ( session.wfs );
close ( session.wfs );
#ifdef USE_TLS
close_tls_stream ( );
free_tls_stream ( );
#endif
}
static void attach_done(int error, Context * ctx, void * arg) {
AttachDoneArgs * data = arg;
Channel * c = data->c;
if (!is_stream_closed(c)) {
write_stringz(&c->out, "R");
write_stringz(&c->out, data->token);
write_errno(&c->out, error);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
}
stream_unlock(c);
loc_free(data);
}
static void proxy_connecting(Channel * c) {
Proxy * target = c->client_data;
assert(c == target->c);
assert(target->other == -1);
assert(target->state == ProxyStateInitial);
assert((target + target->other)->state == ProxyStateConnected);
trace(LOG_PROXY, "Proxy waiting Hello from target");
target->state = ProxyStateConnecting;
send_hello_message(target->proto, target->c);
flush_stream(&target->c->out);
}
static void send_event_stream_disposed(OutputStream * out, VirtualStream * stream) {
char id[256];
virtual_stream_get_id(stream, id, sizeof(id));
write_stringz(out, "E");
write_stringz(out, STREAMS);
write_stringz(out, "disposed");
json_write_string(out, stream->type);
write_stream(out, 0);
json_write_string(out, id);
write_stream(out, 0);
write_stream(out, MARKER_EOM);
flush_stream(out);
}
void send_stream_ack(int fd)
{
struct stream_hdr hdr;
hdr.magic = STREAM_MAGIC;
hdr.se = SE_CLIENT_ACK;
hdr.len = 0;
#ifdef DEBUG
printf("----()-> ACK KEY\n");
#endif
SEND(fd, &hdr, sizeof (hdr));
flush_stream(fd);
}
static int64_t write_opus_tags(FILE *out, const int64_t serial, const char *vendor, const uint32_t num_tags, char **tags, const size_t padding)
{
ogg_packet op;
if (!fill_vc_packet(TAGMAGIC, strlen(TAGMAGIC), vendor, num_tags, tags, false, padding, &op))
return OGGEDIT_ALLOCATION_FAILURE;
ogg_stream_state os;
if (ogg_stream_init(&os, (int)serial))
return OGGEDIT_FAILED_TO_INIT_STREAM;
os.b_o_s = 1;
os.pageno = 1;
ogg_stream_packetin(&os, &op);
ogg_packet_clear(&op);
return flush_stream(out, &os);
}
static void start_done(int error, Context * ctx, void * arg) {
AttachDoneArgs * data = arg;
Channel * c = data->c;
if (!is_stream_closed(c)) {
write_stringz(&c->out, "R");
write_stringz(&c->out, data->token);
write_errno(&c->out, error);
if (ctx == NULL) write_string(&c->out, "null");
else write_context(&c->out, ctx->pid);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
}
stream_unlock(c);
loc_free(data);
}
static void event_context_stopped(Context * ctx, void * client_data) {
TCFBroadcastGroup * bcg = client_data;
assert(ctx->stopped);
assert(!ctx->intercepted);
assert(!ctx->exited);
if (ctx->pending_safe_event) check_safe_events(ctx);
if (ctx->pending_signals != 0) {
send_event_context_exception(&bcg->out, ctx);
}
if (ctx->pending_intercept) {
send_event_context_suspended(&bcg->out, ctx);
flush_stream(&bcg->out);
}
if (!ctx->intercepted && safe_event_list == NULL) {
context_continue(ctx);
}
}
static void delete_write_request(WriteRequest * r, int error) {
Channel * c = r->client->channel;
Trap trap;
if (set_trap(&trap)) {
write_stringz(&c->out, "R");
write_stringz(&c->out, r->token);
write_errno(&c->out, error);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
clear_trap(&trap);
}
else {
trace(LOG_ALWAYS, "Exception handling pending stream write command: %d %s",
trap.error, errno_to_str(trap.error));
}
list_remove(&r->link_client);
loc_free(r->data);
loc_free(r);
}
static void proxy_connected(Channel * c) {
Proxy * target = c->client_data;
Proxy * host = target + target->other;
int i;
assert(target->c == c);
assert(target->other == -1);
assert(target->state == ProxyStateConnecting);
assert(host->state == ProxyStateConnected);
target->state = ProxyStateConnected;
trace(LOG_PROXY, "Proxy connected, target services:");
for (i = 0; i < target->c->peer_service_cnt; i++) {
trace(LOG_PROXY, " %s", target->c->peer_service_list[i]);
protocol_get_service(host->proto, target->c->peer_service_list[i]);
}
send_hello_message(host->proto, host->c);
flush_stream(&host->c->out);
}
static void delete_read_request(ReadRequest * r) {
Channel * c = r->client->channel;
Trap trap;
if (set_trap(&trap)) {
write_stringz(&c->out, "R");
write_stringz(&c->out, r->token);
write_stringz(&c->out, "null");
write_errno(&c->out, ERR_COMMAND_CANCELLED);
json_write_long(&c->out, 0);
write_stream(&c->out, 0);
json_write_boolean(&c->out, 1);
write_stream(&c->out, 0);
write_stream(&c->out, MARKER_EOM);
flush_stream(&c->out);
clear_trap(&trap);
}
else {
trace(LOG_ALWAYS, "Exception handling pending stream read command: %d %s",
trap.error, errno_to_str(trap.error));
}
list_remove(&r->link_client);
loc_free(r);
}
int bg_ogg_encoder_close(void * data, int do_delete)
{
int ret = 1;
int i;
bg_ogg_encoder_t * e = data;
if(!e->write_callback_data)
return 1;
for(i = 0; i < e->num_audio_streams; i++)
{
bg_ogg_stream_t * s = &e->audio_streams[i];
if(!s->codec->close(e->audio_streams[i].codec_priv))
{
ret = 0;
break;
}
flush_stream(s);
ogg_stream_clear(&s->os);
if(s->asink)
{
gavl_audio_sink_destroy(s->asink);
s->asink = NULL;
}
if(s->psink_out)
{
gavl_packet_sink_destroy(s->psink_out);
s->psink_out = NULL;
}
}
for(i = 0; i < e->num_video_streams; i++)
{
bg_ogg_stream_t * s = &e->video_streams[i];
if(!s->codec->close(s->codec_priv))
{
ret = 0;
break;
}
flush_stream(s);
ogg_stream_clear(&s->os);
if(s->vsink)
{
gavl_video_sink_destroy(s->vsink);
s->vsink = NULL;
}
if(s->psink_out)
{
gavl_packet_sink_destroy(s->psink_out);
s->psink_out = NULL;
}
}
e->close_callback(e->write_callback_data);
e->write_callback_data = NULL;
if(do_delete && e->filename)
remove(e->filename);
return ret;
}
val debug(val ctx, val bindings, val data, val line, val pos, val base)
{
uses_or2;
val form = ctx_form(ctx);
val rl = source_loc(form);
cons_bind (lineno, file, rl);
if (consp(data))
data = car(data);
else if (data == t)
data = nil;
if (!step_mode && !memqual(rl, breakpoints)
&& (debug_depth > next_depth))
{
return nil;
} else {
val print_form = t;
val print_data = t;
for (;;) {
val input, command;
if (print_form) {
format(std_debug, lit("stopped at line ~d of ~a\n"),
lineno, file, nao);
format(std_debug, lit("form: ~s\n"), form, nao);
format(std_debug, lit("depth: ~s\n"), num(debug_depth), nao);
print_form = nil;
}
if (print_data) {
int lim = cols * 8;
if (data && pos) {
val half = num((lim - 8) / 2);
val full = num((lim - 8));
val prefix, suffix;
if (lt(pos, half)) {
prefix = sub_str(data, zero, pos);
suffix = sub_str(data, pos, full);
} else {
prefix = sub_str(data, minus(pos, half), pos);
suffix = sub_str(data, pos, plus(pos, half));
}
format(std_debug, lit("data (~d:~d):\n~s . ~s\n"),
line, plus(pos, base), prefix, suffix, nao);
} else if (data && length_str_ge(data, num(lim - 2))) {
format(std_debug, lit("data (~d):\n~s...~s\n"), line,
sub_str(data, zero, num(lim/2 - 4)),
sub_str(data, num(-(lim/2 - 3)), t), nao);
} else {
format(std_debug, lit("data (~d):\n~s\n"), line, data, nao);
}
print_data = nil;
}
format(std_debug, lit("txr> "), nao);
flush_stream(std_debug);
input = split_str_set(or2(get_line(std_input), lit("q")), lit("\t "));
command = if3(equal(first(input), null_string),
or2(last_command, lit("")), first(input));
last_command = command;
if (equal(command, lit("?")) || equal(command, lit("h"))) {
help(std_debug);
continue;
} else if (equal(command, null_string)) {
continue;
} else if (equal(command, lit("c"))) {
step_mode = 0;
next_depth = -1;
return nil;
} else if (equal(command, lit("s"))) {
step_mode = 1;
return nil;
} else if (equal(command, lit("n"))) {
step_mode = 0;
next_depth = debug_depth;
return nil;
} else if (equal(command, lit("f"))) {
step_mode = 0;
next_depth = debug_depth - 1;
return nil;
} else if (equal(command, lit("v"))) {
show_bindings(bindings, std_debug);
} else if (equal(command, lit("o"))) {
print_form = t;
} else if (equal(command, lit("i"))) {
print_data = t;
} else if (equal(command, lit("b")) || equal(command, lit("d")) ||
equal(command, lit("g")))
{
if (!rest(input)) {
format(std_debug, lit("~s needs arguments\n"), command, nao);
continue;
} else {
val n = int_str(second(input), num(10));
val l = cons(n, or2(third(input), file));
if (!n) {
format(std_debug, lit("~s needs <line> [ <file> ]\n"),
command, nao);
continue;
}
if (equal(command, lit("b"))) {
breakpoints = remqual(l, breakpoints, nil);
push(l, &breakpoints);
} else if (equal(command, lit("d"))) {
val breakpoints_old = breakpoints;
breakpoints = remqual(l, breakpoints, nil);
if (breakpoints == breakpoints_old)
format(std_debug, lit("no such breakpoint\n"), nao);
} else {
opt_loglevel = c_num(n);
}
}
} else if (equal(command, lit("l"))) {
format(std_debug, lit("breakpoints: ~s\n"), breakpoints, nao);
} else if (equal(command, lit("w"))) {
format(std_debug, lit("backtrace:\n"), nao);
{
uw_frame_t *iter;
for (iter = uw_current_frame(); iter != 0; iter = iter->uw.up) {
if (iter->uw.type == UW_DBG) {
if (iter->db.ub_p_a_pairs)
format(std_debug, lit("(~s ~s ~s)\n"), iter->db.func,
args_copy_to_list(iter->db.args),
iter->db.ub_p_a_pairs, nao);
else
format(std_debug, lit("(~s ~s)\n"), iter->db.func,
args_copy_to_list(iter->db.args), nao);
}
}
}
} else if (equal(command, lit("q"))) {
uw_throwf(debug_quit_s, lit("terminated via debugger"), nao);
} else {
format(std_debug, lit("unrecognized command: ~a\n"), command, nao);
}
}
return nil;
}
}
int32_t xar_attrcopy_from_heap_to_stream(xar_stream *stream) {
xar_stream_state_t *state = stream->state;
int r, i;
size_t bsize;
void *inbuf;
if( state->pending_buf_size ) {
return flush_stream(stream);
}
bsize = state->bsize;
inbuf = malloc(bsize);
if( !inbuf ) {
return XAR_STREAM_ERR;
}
/* Size has been reached */
if( state->fsize == stream->total_in ) {
free(inbuf);
return XAR_STREAM_END;
}
if( (state->fsize - stream->total_in) < bsize )
bsize = state->fsize - stream->total_in;
r = read(XAR(state->x)->fd, inbuf, bsize);
if( r == 0 ) {
free(inbuf);
return XAR_STREAM_END;
}
if( (r < 0) && (errno == EINTR) ) {
free(inbuf);
return XAR_STREAM_OK;
}
if( r < 0 ) {
free(inbuf);
return XAR_STREAM_ERR;
}
XAR(state->x)->heap_offset += r;
stream->total_in += r;
bsize = r;
/* filter the data through the in modules */
for( i = 0; i < state->modulecount; i++) {
if( xar_datamods[i].fh_in ) {
int32_t ret;
ret = xar_datamods[i].fh_in(state->x, state->f, state->p, &inbuf, &bsize, &(state->modulecontext[i]));
if( ret < 0 )
return XAR_STREAM_ERR;
}
}
/* filter the data through the out modules */
for( i = 0; i < state->modulecount; i++) {
if( xar_datamods[i].fh_out ) {
int32_t ret;
ret = xar_datamods[i].fh_out(state->x, state->f, state->p, inbuf, bsize, &(state->modulecontext[i]));
if( ret < 0 )
return XAR_STREAM_ERR;
}
}
write_to_stream(inbuf, bsize, stream);
free(inbuf);
return XAR_STREAM_OK;
}
static void done_io_request(void * arg) {
int err = 0;
IORequest * req = (IORequest *)((AsyncReqInfo *)arg)->client_data;
OpenFileInfo * handle = req->handle;
if (handle == NULL) {
loc_free(req->info.u.fio.bufp);
loc_free(req);
return;
}
assert(handle->posted_req == req);
assert(&handle->posted_req->link_reqs == handle->link_reqs.next);
handle->posted_req = NULL;
list_remove(&req->link_reqs);
switch (req->req) {
case REQ_READ:
if (req->info.error) {
reply_read(req->token, handle->out, req->info.error, NULL, 0, 0);
}
else {
reply_read(req->token, handle->out, 0,
req->info.u.fio.bufp, req->info.u.fio.rval,
(size_t)req->info.u.fio.rval < req->info.u.fio.bufsz);
}
break;
case REQ_WRITE:
if (req->info.error) err = req->info.error;
else if ((size_t)req->info.u.fio.rval < req->info.u.fio.bufsz) err = ENOSPC;
reply_write(req->token, handle->out, err);
break;
case REQ_CLOSE:
err = req->info.error;
reply_close(req->token, handle->out, err);
if (err == 0) {
loc_free(req);
while (!list_is_empty(&handle->link_reqs)) {
LINK * link = handle->link_reqs.next;
req = reqs2req(link);
switch (req->req) {
case REQ_READ:
reply_read(req->token, handle->out, EBADF, NULL, 0, 0);
break;
case REQ_WRITE:
reply_write(req->token, handle->out, EBADF);
break;
case REQ_FSTAT:
reply_stat(req->token, handle->out, EBADF, NULL);
break;
case REQ_FSETSTAT:
reply_setstat(req->token, handle->out, EBADF);
break;
case REQ_CLOSE:
reply_close(req->token, handle->out, EBADF);
break;
default:
assert(0);
}
list_remove(link);
loc_free(req->info.u.fio.bufp);
loc_free(req);
}
flush_stream(handle->out);
delete_open_file_info(handle);
return;
}
break;
default:
assert(0);
}
loc_free(req->info.u.fio.bufp);
loc_free(req);
post_io_requst(handle);
flush_stream(handle->out);
}
