/*
* Spread the selection outwards according to the selection mode.
*/
static pos
sel_spread_half(pos p, bool forward)
{
switch (term.mouse_state) {
when MS_SEL_CHAR: {
/*
* In this mode, every character is a separate unit, except
* for runs of spaces at the end of a non-wrapping line.
*/
termline *line = fetch_line(p.y);
if (!(line->attr & LATTR_WRAPPED)) {
termchar *q = line->chars + term.cols;
while (q > line->chars && q[-1].chr == ' ' && !q[-1].cc_next)
q--;
if (q == line->chars + term.cols)
q--;
if (p.x >= q - line->chars)
p.x = forward ? term.cols - 1 : q - line->chars;
}
release_line(line);
}
when MS_SEL_WORD:
p = sel_spread_word(p, forward);
when MS_SEL_LINE:
if (forward) {
termline *line = fetch_line(p.y);
while (line->attr & LATTR_WRAPPED) {
release_line(line);
line = fetch_line(++p.y);
p.x = 0;
}
int x = p.x;
p.x = term.cols - 1;
do {
if (get_char(line, x) != ' ')
p.x = x;
} while (++x < line->cols);
release_line(line);
}
else {
p.x = 0;
while (p.y > -sblines()) {
termline *line = fetch_line(p.y - 1);
bool wrapped = line->attr & LATTR_WRAPPED;
release_line(line);
if (!wrapped)
break;
p.y--;
}
}
default:
/* Shouldn't happen. */
break;
}
return p;
}
/* fetch_line: read one line from user and put it in input_buf. */
int fetch_line(char* prompt)
{
int c;
int count;
input_char = input_buf;
token = token_buf;
printf("%s", prompt);
fflush(stdout);
count = 0;
for (;;) {
c = getchar();
if (c == EOF)
return EOF;
if (count < MAXBUF)
input_buf[count++] = c;
if (c == '\n' && count < MAXBUF) {
input_buf[count] = 0;
return count;
}
if (c == '\n') {
printf("too long input line\n");
return fetch_line(prompt);
}
}
}
void parse_config(char *filename, struct conf *conf) {
int conf_file = open(filename, O_RDONLY);
char buffer[DFINGER_BUFFER_SIZE];
memset(buffer, 0, DFINGER_BUFFER_SIZE);
char line[DFINGER_LINE_SIZE];
memset(line, 0, DFINGER_LINE_SIZE);
size_t blen = DFINGER_BUFFER_SIZE;
size_t boffset = 0;
size_t llen = DFINGER_LINE_SIZE;
int ret;
int num_read;
while ((num_read = read(conf_file, buffer, DFINGER_BUFFER_SIZE) > 0)) {
blen += num_read;
while ((ret = fetch_line(buffer, blen, &boffset, line, llen)) !=
RTL_WANT_MORE) {
switch (ret) {
case RTL_LINE_FETCHED:
set_option(line, conf);
break;
case RTL_BLANK_LINE:
break;
default:
return;
}
}
move_buffer(buffer, blen, &boffset);
}
close(conf_file);
}
scanner::scanner(std::istream & strm, char const * strm_name, pos_info const & skip_to_pos) :
scanner(strm, strm_name) {
for (unsigned line_no = 1; line_no < skip_to_pos.first; line_no++)
fetch_line();
m_line = m_sline;
for (unsigned col_idx = 0; col_idx < skip_to_pos.second; col_idx++)
next();
}
static pos
sel_spread_word(pos p, bool forward)
{
pos ret_p = p;
termline *line = fetch_line(p.y);
for (;;) {
wchar c = get_char(line, p.x);
if (iswalnum(c) || strchr("_#~+-", c))
ret_p = p;
else if (strchr(".@/\\", c)) {
if (!forward)
ret_p = p;
}
else if (!(strchr("&,?$%", c) || c == (forward ? '=' : ':')))
break;
if (forward) {
p.x++;
if (p.x >= term.cols - ((line->attr & LATTR_WRAPPED2) != 0)) {
if (!(line->attr & LATTR_WRAPPED))
break;
p.x = 0;
release_line(line);
line = fetch_line(++p.y);
}
}
else {
if (p.x <= 0) {
if (p.y <= -sblines())
break;
release_line(line);
line = fetch_line(--p.y);
if (!(line->attr & LATTR_WRAPPED))
break;
p.x = term.cols - ((line->attr & LATTR_WRAPPED2) != 0);
}
p.x--;
}
}
release_line(line);
return ret_p;
}
/* main: main program of simple shell. */
int main(int argc, char** argv)
{
progname = argv[0];
init_search_path();
while (fetch_line("% ") != EOF)
parse_line();
return 0;
}
scanner::scanner(std::istream & strm, char const * strm_name):
m_tokens(nullptr), m_stream(strm) {
m_stream_name = strm_name ? strm_name : "[unknown]";
m_sline = 0;
m_spos = 0;
m_upos = 0;
m_uskip = 0;
m_in_notation = false;
m_last_line = false;
fetch_line();
m_line = m_sline;
}
int find_urb()
{
do
{
if (line[0] == '[' && strstr(line, " URB ") &&
(strstr(line, "going down") || strstr(line, "coming back")))
{
return 1;
}
}
while( fetch_line() );
return 0;
}
/* This code should be replaced with header buckets. */
static apr_status_t fetch_headers(serf_bucket_t *bkt, response_context_t *ctx)
{
apr_status_t status;
/* RFC 2616 says that CRLF is the only line ending, but we can easily
* accept any kind of line ending.
*/
status = fetch_line(ctx, SERF_NEWLINE_ANY);
if (SERF_BUCKET_READ_ERROR(status)) {
return status;
}
/* Something was read. Process it. */
if (ctx->linebuf.state == SERF_LINEBUF_READY && ctx->linebuf.used) {
const char *end_key;
const char *c;
end_key = c = memchr(ctx->linebuf.line, ':', ctx->linebuf.used);
if (!c) {
/* Bad headers? */
return SERF_ERROR_BAD_HTTP_RESPONSE;
}
/* Skip over initial ':' */
c++;
/* And skip all whitespaces. */
for(; c < ctx->linebuf.line + ctx->linebuf.used; c++)
{
if (!apr_isspace(*c))
{
break;
}
}
/* Always copy the headers (from the linebuf into new mem). */
/* ### we should be able to optimize some mem copies */
serf_bucket_headers_setx(
ctx->headers,
ctx->linebuf.line, end_key - ctx->linebuf.line, 1,
c, ctx->linebuf.line + ctx->linebuf.used - c, 1);
}
return status;
}
void scanner::next() {
lean_assert(m_curr != EOF);
m_spos++;
while (m_spos >= static_cast<int>(m_curr_line.size())) {
if (m_last_line) {
m_curr = EOF;
return;
} else {
return fetch_line();
}
}
m_curr = m_curr_line[m_spos];
if (m_uskip > 0) {
if (!is_utf8_next(m_curr))
throw_exception("invalid utf-8 sequence character");
m_uskip--;
} else {
m_upos++;
m_uskip = get_utf8_size(m_curr);
m_uskip--;
}
}
unsigned char* parse_data_dump(int len)
{
int count = 0;
char* ptr= NULL;
unsigned char* data = (unsigned char *)malloc(len);
if (!data)
return NULL;
while(count < len)
{
if ((count % 16) == 0)
{
if (count)
{
if (!fetch_line())
{
free(data);
return NULL;
}
}
ptr = strchr(line, ':');
if (!ptr)
{
free(data);
return NULL;
}
ptr += 2;
}
data[count++] = strtoul(ptr, NULL, 16);
ptr += 3;
}
return data;
}
void
term_update_search()
{
int update_type = term.results.update_type;
if (term.results.update_type == NO_UPDATE)
return;
term.results.update_type = NO_UPDATE;
if (term.results.query_length == 0)
return;
circbuf cb;
// Allocate room for the circular buffer of termlines.
int lcurr = 0;
if (update_type == PARTIAL_UPDATE) {
// How much of the backscroll we need to update on a partial update?
// Do a ceil: (x + y - 1) / y
// On query_length - 1
int pstart = -((term.results.query_length + term.cols - 2) / term.cols) + term.sblines;
lcurr = lcurr > pstart ? lcurr:pstart;
results_partial_clear(lcurr);
} else {
term_clear_results();
}
int llen = term.results.query_length / term.cols + 1;
if (llen < 2)
llen = 2;
circbuf_init(&cb, llen);
// Fill in our starting set of termlines.
for (int i = lcurr; i < term.rows + term.sblines && cb.length < cb.capacity; ++i) {
circbuf_push(&cb, fetch_line(i - term.sblines));
}
int cpos = term.cols * lcurr;
/* the number of matched chars in the current run */
int npos = 0;
/* the number of matched cells in the current run (anpos >= npos) */
int anpos = 0;
int end = term.cols * (term.rows + term.sblines);
// Loop over every character and search for query.
while (cpos < end) {
// Determine the current position.
int x = (cpos % term.cols);
int y = (cpos / term.cols);
// If our current position isn't in the buffer, add it in.
if (y - lcurr >= llen) {
circbuf_push(&cb, fetch_line(lcurr + llen - term.sblines));
++lcurr;
}
termline * lll = circbuf_get(&cb, y - lcurr);
termchar * chr = lll->chars + x;
if (npos == 0 && cpos + term.results.query_length >= end)
break;
if (chr->chr != term.results.query[npos]) {
// Skip the second cell of any wide characters
if (chr->chr == UCSWIDE) {
++anpos;
++cpos;
continue;
}
cpos -= npos - 1;
npos = 0;
anpos = 0;
continue;
}
++anpos;
++npos;
if (term.results.query_length == npos) {
int start = cpos - anpos + 1;
result run = {
.x = start % term.cols,
.y = start / term.cols,
.len = anpos
};
#ifdef debug_search
printf("%d, %d, %d\n", run.x, run.y, run.len);
#endif
results_add(run);
npos = 0;
anpos = 0;
}
++cpos;
}
circbuf_destroy(&cb);
}
child_write(buf, 6);
}
static pos
box_pos(pos p)
{
p.y = min(max(0, p.y), term.rows - 1);
p.x = min(max(0, p.x), term.cols - 1);
return p;
}
static pos
get_selpoint(const pos p)
{
pos sp = { .y = p.y + term.disptop, .x = p.x };
termline *line = fetch_line(sp.y);
if ((line->attr & LATTR_MODE) != LATTR_NORM)
sp.x /= 2;
/*
* Transform x through the bidi algorithm to find the _logical_
* click point from the physical one.
*/
if (term_bidi_line(line, p.y) != null)
sp.x = term.post_bidi_cache[p.y].backward[sp.x];
// Back to previous cell if current one is second half of a wide char
if (line->chars[sp.x].chr == UCSWIDE)
sp.x--;
release_line(line);
void parse_urb_body(struct urb* urb)
{
int setup_packet = 0;
while (fetch_line())
{
if (line[0] == '[')
break;
if (strstr(line, "TransferBufferLength"))
{
urb->len = get_hex_value();
}
else if (strstr(line, "TransferFlags"))
{
urb->flags = get_hex_value();
}
else if (strstr(line, "Index"))
{
urb->index = get_hex_value();
}
else if (strstr(line, "DescriptorType"))
{
urb->type = get_hex_value();
}
else if (strstr(line, "RequestTypeReservedBits"))
{
urb->reserved = get_hex_value();
}
else if (strstr(line, "Request"))
{
urb->request = get_hex_value();
}
else if (strstr(line, "Value"))
{
urb->value = get_hex_value();
}
else if (strstr(line, "SetupPacket"))
{
setup_packet = 1;
}
else if (strstr(line, "00000000:"))
{
if (!setup_packet && !urb->data)
urb->data = parse_data_dump(urb->len);
}
else if (strstr(line, "-- URB_FUNCTION_"))
{
if (strstr(line, "URB_FUNCTION_CONTROL_TRANSFER"))
urb->func = FUNC_CONTROL_TXFER;
else if (strstr(line, "URB_FUNCTION_CLASS_INTERFACE"))
urb->func = FUNC_CLASS_INTERFACE;
else if (strstr(line, "URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE"))
urb->func = FUNC_GET_DESC;
else if (strstr(line, "URB_FUNCTION_SELECT_CONFIGURATION"))
urb->func = FUNC_SELECT_CONFIG;
else if (strstr(line, "URB_FUNCTION_GET_DESCRIPTOR_FROM_INTERFACE"))
urb->func = FUNC_GET_DESC_FROM_IFACE;
else if (strstr(line, "URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER"))
urb->func = FUNC_BULK_TXFER;
else if (strstr(line, "URB_FUNCTION_RESET_PIPE"))
urb->func = FUNC_RESET_PIPE;
else if (strstr(line, "URB_FUNCTION_ABORT_PIPE"))
urb->func = FUNC_ABORT_PIPE;
else
{
urb->func = FUNC_UNKNOWN;
printf("Unknown FUNC: %s\n", line);
exit(0);
}
}
}
}
/* Perform one iteration of the state machine.
*
* Will return when one the following conditions occurred:
* 1) a state change
* 2) an error
* 3) the stream is not ready or at EOF
* 4) APR_SUCCESS, meaning the machine can be run again immediately
*/
static apr_status_t run_machine(serf_bucket_t *bkt, response_context_t *ctx)
{
apr_status_t status = APR_SUCCESS; /* initialize to avoid gcc warnings */
switch (ctx->state) {
case STATE_STATUS_LINE:
/* RFC 2616 says that CRLF is the only line ending, but we can easily
* accept any kind of line ending.
*/
status = fetch_line(ctx, SERF_NEWLINE_ANY);
if (SERF_BUCKET_READ_ERROR(status))
return status;
if (ctx->linebuf.state == SERF_LINEBUF_READY) {
/* The Status-Line is in the line buffer. Process it. */
status = parse_status_line(ctx, bkt->allocator);
if (status)
return status;
/* Good times ahead: we're switching protocols! */
if (ctx->sl.code == 101) {
ctx->body =
serf_bucket_barrier_create(ctx->stream, bkt->allocator);
ctx->state = STATE_DONE;
break;
}
/* Okay... move on to reading the headers. */
ctx->state = STATE_HEADERS;
}
else {
/* The connection closed before we could get the next
* response. Treat the request as lost so that our upper
* end knows the server never tried to give us a response.
*/
if (APR_STATUS_IS_EOF(status)) {
return SERF_ERROR_REQUEST_LOST;
}
}
break;
case STATE_HEADERS:
status = fetch_headers(bkt, ctx);
if (SERF_BUCKET_READ_ERROR(status))
return status;
/* If an empty line was read, then we hit the end of the headers.
* Move on to the body.
*/
if (ctx->linebuf.state == SERF_LINEBUF_READY && !ctx->linebuf.used) {
const void *v;
/* Advance the state. */
ctx->state = STATE_BODY;
ctx->body =
serf_bucket_barrier_create(ctx->stream, bkt->allocator);
/*
* Instaweb/mod_pagespeed change: This section is
* re-ordered from the original code from serf to Follow
* HTTP spec by checking "Transfer-Encoding: chunked",
* before "Content-Length".
*/
/* Are we C-L, chunked, or conn close? */
v = serf_bucket_headers_get(ctx->headers, "Transfer-Encoding");
/* Need to handle multiple transfer-encoding. */
if (v && strcasecmp("chunked", v) == 0) {
ctx->chunked = 1;
ctx->body = serf_bucket_dechunk_create(ctx->body,
bkt->allocator);
}
else {
v = serf_bucket_headers_get(ctx->headers, "Content-Length");
if (v) {
apr_uint64_t length;
length = apr_strtoi64(v, NULL, 10);
if (errno == ERANGE) {
return APR_FROM_OS_ERROR(ERANGE);
}
ctx->body = serf_bucket_limit_create(ctx->body, length,
bkt->allocator);
}
else if ((ctx->sl.code == 204 || ctx->sl.code == 304)) {
ctx->state = STATE_DONE;
}
}
/*
* Instaweb would prefer to receive gzipped output if that's what
* was asked for.
*
* v = serf_bucket_headers_get(ctx->headers, "Content-Encoding");
* if (v) {
* * Need to handle multiple content-encoding. *
* if (v && strcasecmp("gzip", v) == 0) {
* ctx->body =
* serf_bucket_deflate_create(ctx->body, bkt->allocator,
* SERF_DEFLATE_GZIP);
* }
* else if (v && strcasecmp("deflate", v) == 0) {
* ctx->body =
* serf_bucket_deflate_create(ctx->body, bkt->allocator,
* SERF_DEFLATE_DEFLATE);
* }
* }
*/
/* If we're a HEAD request, we don't receive a body. */
if (ctx->head_req) {
ctx->state = STATE_DONE;
}
}
break;
case STATE_BODY:
/* Don't do anything. */
break;
case STATE_TRAILERS:
status = fetch_headers(bkt, ctx);
if (SERF_BUCKET_READ_ERROR(status))
return status;
/* If an empty line was read, then we're done. */
if (ctx->linebuf.state == SERF_LINEBUF_READY && !ctx->linebuf.used) {
ctx->state = STATE_DONE;
return APR_EOF;
}
break;
case STATE_DONE:
return APR_EOF;
default:
/* Not reachable */
return APR_EGENERAL;
}
return status;
}
void read_obj(const char* strName)
{
int i,j,k;
FILE *fp;
int nwords;
char *comment_ptr;
char *first_word;
float x,y,z,w;
/* read from standard input */
fp = fopen(strName,"r");
while (1) {
comment_ptr = fetch_line (fp);
if (comment_ptr == (char *) -1) /* end-of-file */
break;
/* did we get a comment? */
if (comment_ptr) {
make_comment (comment_ptr);
continue;
}
/* if we get here, the line was not a comment */
nwords = fetch_words();
/* skip empty lines */
if (nwords == 0)
continue;
first_word = words[0];
if (equal_strings (first_word, "v")) {
if (nwords < 4) {
fprintf (stderr, "Too few coordinates: '%s'", str_orig);
exit (-1);
}
#ifdef NEW_LOAD
float3 pos;
pos.x = atof (words[1]);
pos.y = atof (words[2]);
pos.z = atof (words[3]);
vPosition.push_back(pos);
#else
x = atof (words[1]);
y = atof (words[2]);
z = atof (words[3]);
if (nwords == 5) {
w = atof (words[3]);
has_w = 1;
}
else
w = 1.0;
make_vertex (x, y, z, w);
#endif
}
else if (equal_strings (first_word, "vn")) {
#ifdef NEW_LOAD
float3 n;
n.x = atof (words[1]);
n.y = atof (words[2]);
n.z = atof (words[3]);
vNormal.push_back(n);
has_normals = true;
#endif
}
else if (equal_strings (first_word, "vt")) {
#ifdef NEW_LOAD
float2 t;
t.x = atof (words[1]);
t.y = atof (words[2]);
vUV.push_back(t);
texture_coords = true;
#endif
}
else if (equal_strings (first_word, "f")) {
#ifdef NEW_LOAD
LoadFace(&words[1],nwords-1);
#else
make_face (&words[1], nwords-1);
#endif
}
else {
fprintf (stderr, "Do not recognize: '%s'\n", str_orig);
}
}
nverts = vVertex.size();
nfaces = vIndex.size()/3;
fclose(fp);
}
void read_obj ( void )
/******************************************************************************/
/*
Purpose:
READ_OBJ reads in a Wavefront OBJ file.
Author:
Greg Turk
*/
{
char *comment_ptr;
char *first_word;
FILE *fp;
int i;
int j;
int k;
int nwords;
float w;
float x;
float y;
float z;
/*
Read from standard input.
*/
fp = stdin;
while (1)
{
comment_ptr = fetch_line ( fp );
/*
End of file?
*/
if ( comment_ptr == ( char * ) -1 )
{
break;
}
/*
Did we actually get a comment?
*/
if ( comment_ptr )
{
make_comment ( comment_ptr );
continue;
}
/*
If we get here, the line was not a comment.
*/
nwords = fetch_words ( );
/*
Skip empty lines.
*/
if ( nwords == 0 )
{
continue;
}
first_word = words[0];
if (equal_strings (first_word, "v"))
{
if (nwords < 4)
{
fprintf (stderr, "Too few coordinates: '%s'", str_orig);
exit (-1);
}
x = atof (words[1]);
y = atof (words[2]);
z = atof (words[3]);
if (nwords == 5)
{
w = atof (words[3]);
has_w = 1;
}
else
{
w = 1.0;
}
make_vertex ( x, y, z, w );
}
else if (equal_strings (first_word, "vn"))
{
}
else if (equal_strings (first_word, "vt"))
{
}
else if (equal_strings (first_word, "f"))
{
make_face (&words[1], nwords-1);
}
else
{
fprintf (stderr, "Do not recognize: '%s'\n", str_orig);
}
}
return;
}
