/* Erase a single character off the end of the rawq, and delete
it from the screen appropriately. Set ERASE_CHAR if this
is being done by the VERASE character, to that character. */
static void
erase_1 (char erase_char)
{
int quoted;
char c;
quoted_char cq;
if (qsize (rawq) == 0)
return;
cq = queue_erase (rawq);
c = unquote_char (cq);
quoted = char_quoted_p (cq);
if (!echo_p (c, quoted))
return;
/* The code for WERASE knows that we echo erase_char iff
!ECHOPRT && !ECHO. */
if (echo_qsize--)
{
if (termstate.c_lflag & ECHOPRT)
echo_char (c, 1, quoted);
else if (!(termstate.c_lflag & ECHOE) && erase_char)
echo_char (erase_char, 0, 0);
else
{
int nerase;
if (echo_double (c, quoted))
nerase = 2;
else if (c == '\t')
{
quoted_char *cp;
int loc = echo_pstart;
for (cp = rawq->ce - echo_qsize; cp != rawq->ce; cp++)
loc += (echo_double (unquote_char (*cp), char_quoted_p (*cp))
? 2
: output_width (*cp, loc));
nerase = output_psize - loc;
}
else
nerase = output_width (c, output_psize);
while (nerase--)
write_erase_sequence ();
}
if (echo_qsize == 0)
assert (echo_pstart == output_psize);
}
else
reprint_line ();
}
void
HumanSummaryReportWriter::write_tree_summary
( ostream& p_os,
map<std::string, ActivityStats> const& p_activity_stats_map
)
{
// TODO When the user passes a string even without the -r option,
// when printing in tree mode, it should probably match that string
// to non-leaf nodes as well as just leaf nodes. (It should possibly
// even do this when not printing in tree mode.)
if (p_activity_stats_map.empty())
{
p_os << endl;
return;
}
ActivityTree const tree(p_activity_stats_map);
ActivityTree::PrintNode const print_node = [this]
( ostream& p_ostream,
unsigned int p_node_depth,
string const& p_node_label,
ActivityStats const& p_stats
)
{
StreamFlagGuard guard(p_ostream);
p_ostream << string(p_node_depth * (output_width() + 4), ' ')
<< "[ "
<< fixed << setprecision(output_precision())
<< right << setw(output_width())
<< seconds_to_rounded_hours(p_stats.seconds)
<< " ]";
guard.reset();
if (m_include_beginning)
{
auto const& b = p_stats.beginning;
auto const s = time_point_to_stamp(b, time_format(), formatted_buf_len());
p_ostream << "[ " << s << " ]";
}
if (m_include_ending)
{
auto const& e = p_stats.ending;
auto const s = time_point_to_stamp(e, time_format(), formatted_buf_len());
p_ostream << "[ " << s << " ]";
}
p_ostream << ' ' << p_node_label << endl;
return;
};
tree.print(p_os, print_node);
return;
}
/*============================
* mvcwaddnstr -- convert to GUI codeset & call mvwaddstr with length limit
* Created: 2002/12/13 (Perry Rapp)
*==========================*/
int
mvccwaddnstr (WINDOW *wp, int y, int x, const char *cp, int n)
{
ZSTR zstr = zs_news(cp);
int rtn=0;
int_to_disp(zstr);
if (zs_len(zstr) < (unsigned int)n) {
rtn = mvwaddstr(wp, y, x, zs_str(zstr));
} else {
if (output_width(zstr) > (size_t)n) {
STRING str = zs_str(zstr);
/* We need to do length truncation correctly for UTF-8 output */
/* #1) We need to not break UTF-8 multibytes */
INT width=0;
STRING prev = find_prev_char(&str[n-1], &width, str, gui8);
width += (prev - str);
zs_chop(zstr, width);
/* #2) We should account for zero-width characters, eg, use wcwidth */
/* Unfortunately, lifelines doesn't yet use wcwidth or config test it */
/* TODO:
config test for wcswidth
and substitute Markus Kuhn's
http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
*/
}
rtn = mvwaddnstr(wp, y, x, zs_str(zstr), n);
}
zs_free(&zstr);
return rtn;
}
void
HumanSummaryReportWriter::print_label_and_rounded_hours
( ostream& p_os,
string const& p_label,
unsigned long long p_seconds,
TimePoint const* p_beginning,
TimePoint const* p_ending,
unsigned int p_left_col_width
) const
{
StreamFlagGuard guard(p_os);
if (!p_label.empty())
{
p_os << left << setw(p_left_col_width) << p_label << ' '
<< right << setw(output_width());
}
p_os << fixed << setprecision(output_precision())
<< seconds_to_rounded_hours(p_seconds);
guard.reset();
if (p_beginning != nullptr)
{
p_os << " "
<< time_point_to_stamp(*p_beginning, time_format(), formatted_buf_len());
}
if (p_ending != nullptr)
{
p_os << " "
<< time_point_to_stamp(*p_ending, time_format(), formatted_buf_len());
}
p_os << endl;
return;
}
local_contrast_normalization(
geometric_layer_property const& glp,
int batch_size,
scalar alpha, scalar beta,
boost::compute::context const& context)
: glp_(glp), batch_size_(batch_size),
alpha_(alpha), beta_(beta),
output_width_(output_width(glp)),
local_mean_(output_dim(glp)*batch_size, context),
local_variance_(output_dim(glp)*batch_size, context),
input_(input_dim(glp)*batch_size, context),
output_(output_dim(glp)*batch_size, context),
local_mean_kernel_(make_kernel(local_mean_kernel_source,
"local_mean", context)),
local_variance_kernel_(make_kernel(local_variance_kernel_source,
"local_variance", context)),
forward_kernel_(make_kernel(
local_contrast_normalization_forward_kernel_source,
"forward", context)),
backward_kernel_(make_kernel(
local_contrast_normalization_backward_kernel_source,
"backward", context)) {}
/* Place newly input character C on the input queue. If all remaining
pending input characters should be dropped, return 1; else return
0. */
int
input_character (int c)
{
int lflag = termstate.c_lflag;
int iflag = termstate.c_iflag;
int cflag = termstate.c_cflag;
cc_t *cc = termstate.c_cc;
struct queue **qp = (lflag & ICANON) ? &rawq : &inputq;
int flush = 0;
/* Handle parity errors */
if ((iflag & INPCK)
&& ((cflag & PARODD) ? checkoddpar (c) : checkevenpar (c)))
{
if (iflag & IGNPAR)
goto alldone;
else if (iflag & PARMRK)
{
enqueue_quote (qp, CHAR_USER_QUOTE);
enqueue_quote (qp, '\0');
enqueue_quote (qp, c);
goto alldone;
}
else
c = 0;
}
/* Check to see if we should send IXOFF */
if ((iflag & IXOFF)
&& !qavail (*qp)
&& (cc[VSTOP] != _POSIX_VDISABLE))
{
poutput (cc[VSTOP]);
termflags |= SENT_VSTOP;
}
/* Character mutations */
if (!(iflag & ISTRIP) && (iflag & PARMRK) && (c == CHAR_USER_QUOTE))
enqueue_quote (qp, CHAR_USER_QUOTE); /* cause doubling */
if (iflag & ISTRIP)
c &= 0x7f;
/* Handle LNEXT right away */
if (!external_processing && (termflags & LAST_LNEXT))
{
enqueue_quote (qp, c);
echo_char (c, 0, 1);
termflags &= ~LAST_LNEXT;
goto alldone;
}
/* Mutate ILCASE */
if (!external_processing && (iflag & ILCASE) && isalpha(c))
{
if (termflags & LAST_SLASH)
erase_1 (0); /* remove the slash from input */
else
c = isupper(c) ? tolower (c) : c;
}
/* IEXTEN control chars */
if (!external_processing && (lflag & IEXTEN))
{
if (CCEQ (cc[VLNEXT], c))
{
if (lflag & ECHO)
{
poutput ('^');
poutput ('\b');
}
termflags |= LAST_LNEXT;
goto alldone;
}
if (CCEQ (cc[VDISCARD], c))
{
if (termflags & FLUSH_OUTPUT)
termflags &= ~FLUSH_OUTPUT;
else
{
drop_output ();
poutput (cc[VDISCARD]);
termflags |= FLUSH_OUTPUT;
}
goto alldone;
}
}
/* Signals */
if (!external_processing && (lflag & ISIG))
{
if (CCEQ (cc[VINTR], c) || CCEQ (cc[VQUIT], c))
{
if (!(lflag & NOFLSH))
{
drop_output ();
clear_queue (inputq);
clear_queue (rawq);
flush = 1;
}
echo_char (c, 0, 0);
echo_qsize = 0;
echo_pstart = output_psize;
send_signal (CCEQ (cc[VINTR], c) ? SIGINT : SIGQUIT);
goto alldone;
}
if (CCEQ (cc[VSUSP], c))
{
if (!(lflag & NOFLSH))
{
flush = 1;
clear_queue (inputq);
clear_queue (rawq);
}
echo_char (c, 0, 0);
echo_qsize = 0;
echo_pstart = output_psize;
send_signal (SIGTSTP);
goto alldone;
}
}
/* IXON */
if (!external_processing && (iflag & IXON))
{
if (CCEQ (cc[VSTOP], c))
{
if (CCEQ(cc[VSTART], c) && (termflags & USER_OUTPUT_SUSP))
/* Toggle if VSTART == VSTOP. Alldone code always turns
off USER_OUTPUT_SUSP. */
goto alldone;
termflags |= USER_OUTPUT_SUSP;
(*bottom->suspend_physical_output) ();
return flush;
}
if (CCEQ (cc[VSTART], c))
goto alldone;
}
if (!external_processing)
{
/* Newline and carriage-return frobbing */
if (c == '\r')
{
if (iflag & ICRNL)
c = '\n';
else if (iflag & IGNCR)
goto alldone;
}
else if ((c == '\n') && (iflag & INLCR))
c = '\r';
}
/* Canonical mode processing */
if (!external_processing && (lflag & ICANON))
{
if (CCEQ (cc[VERASE], c))
{
if (qsize(rawq))
erase_1 (c);
if (!(termflags & LAST_SLASH)
|| !(lflag & IEXTEN))
goto alldone;
}
if (CCEQ (cc[VKILL], c))
{
if (!(termflags & LAST_SLASH)
|| !(lflag & IEXTEN))
{
if ((lflag & ECHOKE) && !(lflag & ECHOPRT)
&& (echo_qsize == qsize (rawq)))
{
while (output_psize > echo_pstart)
write_erase_sequence ();
}
else
{
echo_char (c, 0, 0);
if ((lflag & ECHOK) || (lflag & ECHOKE))
echo_char ('\n', 0, 0);
}
clear_queue (rawq);
echo_qsize = 0;
echo_pstart = output_psize;
termflags &= ~(LAST_SLASH|LAST_LNEXT|INSIDE_HDERASE);
goto alldone;
}
else
erase_1 (0); /* remove \ */
}
if (CCEQ (cc[VWERASE], c))
{
/* If we are not going to echo the erase, then
echo a WERASE character right now. (If we
passed it to erase_1; it would echo it multiple
times.) */
if (!(lflag & (ECHOPRT|ECHOE)))
echo_char (cc[VWERASE], 0, 1);
/* Erase whitespace */
while (qsize (rawq) && isblank (unquote_char (rawq->ce[-1])))
erase_1 (0);
/* Erase word. */
if (lflag & ALTWERASE)
/* For ALTWERASE, we erase back to the first blank */
while (qsize (rawq) && !isblank (unquote_char (rawq->ce[-1])))
erase_1 (0);
else
/* For regular WERASE, we erase back to the first nonalpha/_ */
while (qsize (rawq) && !isblank (unquote_char (rawq->ce[-1]))
&& (isalnum (unquote_char (rawq->ce[-1]))
|| (unquote_char (rawq->ce[-1]) != '_')))
erase_1 (0);
goto alldone;
}
if (CCEQ (cc[VREPRINT], c) && (lflag & IEXTEN))
{
reprint_line ();
goto alldone;
}
if (CCEQ (cc[VSTATUS], c) && (lflag & ISIG) && (lflag & IEXTEN))
{
send_signal (SIGINFO);
goto alldone;
}
}
/* Now we have a character intended as input. See if it will fit. */
if (!qavail (*qp))
{
if (iflag & IMAXBEL)
poutput ('\a');
else
{
/* Drop everything */
drop_output ();
clear_queue (inputq);
clear_queue (rawq);
echo_pstart = 0;
echo_qsize = 0;
flush = 1;
}
goto alldone;
}
/* Echo */
echo_char (c, 0, 0);
if (CCEQ (cc[VEOF], c) && (lflag & ECHO))
{
/* Special bizarre echo processing for VEOF character. */
int n;
n = echo_double (c, 0) ? 2 : output_width (c, output_psize);
while (n--)
poutput ('\b');
}
/* Put character on input queue */
enqueue (qp, c);
/* Check for break characters in canonical input processing */
if (lflag & ICANON)
{
if (CCEQ (cc[VEOL], c)
|| CCEQ (cc[VEOL2], c)
|| CCEQ (cc[VEOF], c)
|| c == '\n')
/* Make input available */
while (qsize (rawq))
enqueue (&inputq, dequeue (rawq));
}
alldone:
/* Restart output */
if ((iflag & IXANY) || (CCEQ (cc[VSTART], c)))
termflags &= ~USER_OUTPUT_SUSP;
(*bottom->start_output) ();
return flush;
}
char *request(const char *prompt, const char * const default_string, const bool alpha_allowed, const int completion_type, const bool prefer_utf8) {
set_attr(0);
input_buffer[pos = len = offset = 0] = 0;
encoding = ENC_ASCII;
x = start_x = print_prompt(prompt);
init_history();
if (default_string) {
strncpy(input_buffer, default_string, MAX_INPUT_LINE_LEN);
len = strlen(input_buffer);
encoding = detect_encoding(input_buffer, len);
input_refresh();
}
bool first_char_typed = true, last_char_completion = false, selection = false;
while(true) {
assert(input_buffer[len] == 0);
move_cursor(ne_lines - 1, x);
int c;
input_class ic;
do c = get_key_code(); while((ic = CHAR_CLASS(c)) == IGNORE);
/* ISO 10646 characters *above 256* can be added only to UTF-8 lines, or ASCII lines (making them, of course, UTF-8). */
if (ic == ALPHA && c > 0xFF && encoding != ENC_ASCII && encoding != ENC_UTF8) ic = INVALID;
if (ic != TAB) last_char_completion = false;
if (ic == TAB && !completion_type) ic = ALPHA;
switch(ic) {
case INVALID:
alert();
break;
case ALPHA:
if (first_char_typed) {
input_buffer[len = 0] = 0;
clear_to_eol();
}
if (encoding == ENC_ASCII && c > 0x7F) encoding = prefer_utf8 || c > 0xFF ? ENC_UTF8 : ENC_8_BIT;
int c_len = encoding == ENC_UTF8 ? utf8seqlen(c) : 1;
int c_width = output_width(c);
assert(c_len > 0);
if (len <= MAX_INPUT_LINE_LEN - c_len && (alpha_allowed || (c < 0x100 && isxdigit(c)) || c=='X' || c=='x')) {
memmove(&input_buffer[pos + c_len], &input_buffer[pos], len - pos + 1);
if (c_len == 1) input_buffer[pos] = c;
else utf8str(c, &input_buffer[pos]);
len += c_len;
move_cursor(ne_lines - 1, x);
if (x < ne_columns - c_width) {
if (pos == len - c_len) output_char(c, 0, encoding);
else if (char_ins_del_ok) insert_char(c, 0, encoding);
else input_refresh();
}
input_move_right(true);
}
break;
case RETURN:
selection = true;
break;
case TAB:
if (completion_type == COMPLETE_FILE || completion_type == COMPLETE_SYNTAX) {
bool quoted = false;
char *prefix, *completion, *p;
if (len && input_buffer[len - 1] == '"') {
input_buffer[len - 1] = 0;
if (prefix = strrchr(input_buffer, '"')) {
quoted = true;
prefix++;
}
else input_buffer[len - 1] = '"';
}
if (!quoted) {
prefix = strrchr(input_buffer, ' ');
if (prefix) prefix++;
else prefix = input_buffer;
}
if (last_char_completion || completion_type == COMPLETE_SYNTAX) {
if (completion_type == COMPLETE_FILE )
completion = p = request_files(prefix, true);
else
completion = p = request_syntax(prefix, true);
reset_window();
if (completion) {
if (*completion) selection = true;
else completion++;
}
}
else {
if (completion_type == COMPLETE_FILE )
completion = p = complete_filename(prefix);
else
completion = p = request_syntax(prefix, true);
last_char_completion = true;
if (!completion) alert();
}
if (completion && (prefix - input_buffer) + strlen(completion) + 1 < MAX_INPUT_LINE_LEN) {
const encoding_type completion_encoding = detect_encoding(completion, strlen(completion));
if (encoding == ENC_ASCII || completion_encoding == ENC_ASCII || encoding == completion_encoding) {
strcpy(prefix, completion);
if (quoted) strcat(prefix, "\"");
len = strlen(input_buffer);
pos = offset = 0;
x = start_x;
if (encoding == ENC_ASCII) encoding = completion_encoding;
input_move_to_eol();
if (quoted) input_move_left(false);
input_refresh();
}
else alert();
}
else if (quoted) strcat(prefix, "\"");
free(p);
}
break;
case COMMAND:
if (c < 0) c = -c - 1;
const int a = parse_command_line(key_binding[c], NULL, NULL, false);
if (a >= 0) {
switch(a) {
case LINEUP_A:
case LINEDOWN_A:
case MOVESOF_A:
case MOVEEOF_A:
case PAGEUP_A:
case PAGEDOWN_A:
case NEXTPAGE_A:
case PREVPAGE_A:
if (history_buff) {
switch(a) {
case LINEUP_A: line_up(history_buff); break;
case LINEDOWN_A: line_down(history_buff); break;
case MOVESOF_A: move_to_sof(history_buff); break;
case MOVEEOF_A: move_to_bof(history_buff); break;
case PAGEUP_A:
case PREVPAGE_A: prev_page(history_buff); break;
case PAGEDOWN_A:
case NEXTPAGE_A: next_page(history_buff); break;
}
/* In some cases, the default displayed on the command line will be the same as the
first history item. In that case we skip it. */
if (first_char_typed == true
&& a == LINEUP_A
&& history_buff->cur_line_desc->line
&& !strncmp(history_buff->cur_line_desc->line, input_buffer, history_buff->cur_line_desc->line_len))
line_up(history_buff);
if (history_buff->cur_line_desc->line) {
strncpy(input_buffer,
history_buff->cur_line_desc->line,
min(history_buff->cur_line_desc->line_len,MAX_INPUT_LINE_LEN));
input_buffer[min(history_buff->cur_line_desc->line_len,MAX_INPUT_LINE_LEN)] = 0;
len = strlen(input_buffer);
encoding = detect_encoding(input_buffer, len);
}
else {
input_buffer[len = 0] = 0;
encoding = ENC_ASCII;
}
x = start_x;
pos = 0;
offset = 0;
input_refresh();
}
break;
case MOVELEFT_A:
input_move_left(true);
break;
case MOVERIGHT_A:
input_move_right(true);
break;
case BACKSPACE_A:
if (pos == 0) break;
input_move_left(true);
case DELETECHAR_A:
if (len > 0 && pos < len) {
int c_len = encoding == ENC_UTF8 ? utf8len(input_buffer[pos]) : 1;
int c_width = get_char_width(&input_buffer[pos], encoding);
memmove(&input_buffer[pos], &input_buffer[pos + c_len], len - pos - c_len + 1);
len -= c_len;
if (input_buffer_is_ascii()) encoding = ENC_ASCII;
if (char_ins_del_ok) {
int i, j;
move_cursor(ne_lines - 1, x);
delete_chars(c_width);
for(i = x, j = pos; j < len && i + get_char_width(&input_buffer[j], encoding) < ne_columns - c_width; i += get_char_width(&input_buffer[j], encoding), j = next_pos(input_buffer, j, encoding));
if (j < len) {
move_cursor(ne_lines - 1, i);
while(j < len && i + get_char_width(&input_buffer[j], encoding) < ne_columns) {
output_char(get_char(&input_buffer[j], encoding), 0, encoding);
i += get_char_width(&input_buffer[j], encoding);
j = next_pos(input_buffer, j, encoding);
}
}
}
else input_refresh();
}
break;
case DELETELINE_A:
move_cursor(ne_lines - 1, start_x);
clear_to_eol();
input_buffer[len = pos = offset = 0] = 0;
encoding = ENC_ASCII;
x = start_x;
break;
case DELETEEOL_A:
input_buffer[len = pos] = 0;
clear_to_eol();
if (input_buffer_is_ascii()) encoding = ENC_ASCII;
break;
case MOVEINCUP_A:
if (x != start_x) {
pos = offset;
x = start_x;
break;
}
case MOVESOL_A:
input_move_to_sol();
break;
case MOVEINCDOWN_A: {
int i, j;
for(i = x, j = pos; j < len && i + get_char_width(&input_buffer[j], encoding) < ne_columns; i += get_char_width(&input_buffer[j], encoding), j = next_pos(input_buffer, j, encoding));
if (j != pos && j < len) {
pos = j;
x = i;
break;
}
}
case MOVEEOL_A:
input_move_to_eol();
break;
case TOGGLESEOL_A:
case TOGGLESEOF_A:
if (pos != 0) input_move_to_sol();
else input_move_to_eol();
break;
case PREVWORD_A:
input_prev_word();
break;
case NEXTWORD_A:
input_next_word();
break;
case REFRESH_A:
input_refresh();
break;
case PASTE_A:
input_paste();
break;
case AUTOCOMPLETE_A:
input_autocomplete();
break;
case ESCAPE_A:
return NULL;
default:
break;
}
}
break;
default:
break;
}
if (selection) {
const line_desc * const last = (line_desc *)history_buff->line_desc_list.tail_pred->prev;
assert(input_buffer[len] == 0);
if (history_buff->num_lines == 0 || len != last->line_len || strncmp(input_buffer, last->line, last->line_len)) add_to_history(input_buffer);
return input_buffer;
}
first_char_typed = false;
}
}
