src/ui/inputwin.c

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 014literal_string.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v1">
<meta name="syntax" content="cpp">
<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
body { font-family: monospace; color: #eeeeee; background-color: #080808; }
* { font-size: 1.05em; }
.traceContains { color: #008000; }
.cSpecial { color: #008000; }
.Comment { color: #9090ff; }
.Delimiter { color: #a04060; }
.Special { color: #ff6060; }
.Identifier { color: #804000; }
.Constant { color: #00a0a0; }
-->
</style>

<script type='text/javascript'>
<!--

-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Comment">//: For convenience, some instructions will take literal arrays of characters (strings).</span>
<span class="Comment">//:</span>
<span class="Comment">//: Instead of quotes, we'll use [] to delimit strings. That'll reduce the</span>
<span class="Comment">//: need for escaping since we can support nested brackets. And we can also</span>
<span class="Comment">//: imagine that 'recipe' might one day itself be defined in mu, doing its own</span>
<span class="Comment">//: parsing.</span>

<span class="Delimiter">:(scenarios load)</span>
<span class="Delimiter">:(scenario string_literal)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc def]  <span class="Comment"># copy can't really take a string</span>
]
<span class="traceContains">+parse:   ingredient: {&quot;abc def&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_with_colons)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc:def/ghi]
]
<span class="traceContains">+parse:   ingredient: {&quot;abc:def/ghi&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(before &quot;End Mu Types Initialization&quot;)</span>
put<span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;literal-string&quot;</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span>

<span class="Delimiter">:(before &quot;End next_word Special-cases&quot;)</span>
if <span class="Delimiter">(</span>in<span class="Delimiter">.</span>peek<span class="Delimiter">()</span> == <span class="Constant">'['</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
  string result = slurp_quoted<span class="Delimiter">(</span>in<span class="Delimiter">);</span>
  skip_whitespace_and_comments_but_not_newline<span class="Delimiter">(</span>in<span class="Delimiter">);</span>
  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(code)</span>
string slurp_quoted<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  ostringstream out<span class="Delimiter">;</span>
  assert<span class="Delimiter">(</span>has_data<span class="Delimiter">(</span>in<span class="Delimiter">));</span>  assert<span class="Delimiter">(</span>in<span class="Delimiter">.</span>peek<span class="Delimiter">()</span> == <span class="Constant">'['</span><span class="Delimiter">);</span>  out &lt;&lt; static_cast&lt;char&gt;<span class="Delimiter">(</span>in<span class="Delimiter">.</span>get<span class="Delimiter">());</span>  <span class="Comment">// slurp the '['</span>
  if <span class="Delimiter">(</span>is_code_string<span class="Delimiter">(</span>in<span class="Delimiter">,</span> out<span class="Delimiter">))</span>
    slurp_quoted_comment_aware<span class="Delimiter">(</span>in<span class="Delimiter">,</span> out<span class="Delimiter">);</span>
  else
    slurp_quoted_comment_oblivious<span class="Delimiter">(</span>in<span class="Delimiter">,</span> out<span class="Delimiter">);</span>
  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

<span class="Comment">// A string is a code string if it contains a newline before any non-whitespace</span>
<span class="Comment">// todo: support comments before the newline. But that gets messy.</span>
bool is_code_string<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  while <span class="Delimiter">(</span>has_data<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Delimiter">{</span>
    char c = in<span class="Delimiter">.</span>get<span class="Delimiter">();</span>
    if <span class="Delimiter">(</span>!isspace<span class="Delimiter">(</span>c<span class="Delimiter">))</span> <span class="Delimiter">{</span>
      in<span class="Delimiter">.</span>putback<span class="Delimiter">(</span>c<span class="Delimiter">);</span>
      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    out &lt;&lt; c<span class="Delimiter">;</span>
    if <span class="Delimiter">(</span>c == <span class="cSpecial">'\n'</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
  <span class="Delimiter">}</span>
  <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>

<span class="Comment">// Read a regular string. Regular strings can only contain other regular</span>
<span class="Comment">// strings.</span>
void slurp_quoted_comment_oblivious<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  int brace_depth = <span class="Constant">1</span><span class="Delimiter">;</span>
  while <span class="Delimiter">(</span>has_data<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Delimiter">{</span>
    char c = in<span class="Delimiter">.</span>get<span class="Delimiter">();</span>
    if <span class="Delimiter">(</span>c == <span class="cSpecial">'\\'</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      out &lt;&lt; static_cast&lt;char&gt;<span class="Delimiter">(</span>in<span class="Delimiter">.</span>get<span class="Delimiter">());</span>
      <span class="Identifier">continue</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    out &lt;&lt; c<span class="Delimiter">;</span>
    if <span class="Delimiter">(</span>c == <span class="Constant">'['</span><span class="Delimiter">)</span> ++brace_depth<span class="Delimiter">;</span>
    if <span class="Delimiter">(</span>c == <span class="Constant">']'</span><span class="Delimiter">)</span> --brace_depth<span class="Delimiter">;</span>
    if <span class="Delimiter">(</span>brace_depth == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">break</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  if <span class="Delimiter">(</span>!has_data<span class="Delimiter">(</span>in<span class="Delimiter">)</span> &amp;&amp; brace_depth &gt; <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
    raise_error &lt;&lt; <span class="Constant">&quot;unbalanced '['</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
    out<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
  <span class="Delimiter">}</span>
<span class="Delimiter">}</span>

<span class="Comment">// Read a code string. Code strings can contain either code or regular strings.</span>
void slurp_quoted_comment_aware<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  char c<span class="Delimiter">;</span>
  while <span class="Delimiter">(</span>in &gt;&gt; c<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    if <span class="Delimiter">(</span>c == <span class="cSpecial">'\\'</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      out &lt;&lt; static_cast&lt;char&gt;<span class="Delimiter">(</span>in<span class="Delimiter">.</span>get<span class="Delimiter">());</span>
      <span class="Identifier">continue</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    if <span class="Delimiter">(</span>c == <span class="Constant">'#'</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      out &lt;&lt; c<span class="Delimiter">;</span>
      while <span class="Delimiter">(</span>has_data<span class="Delimiter">(</span>in<span class="Delimiter">)</span> &amp;&amp; in<span class="Delimiter">.</span>peek<span class="Delimiter">()</span> != <span class="cSpecial">'\n'</span><span class="Delimiter">)</span> out &lt;&lt; static_cast&lt;char&gt;<span class="Delimiter">(</span>in<span class="Delimiter">.</span>get<span class="Delimiter">());</span>
      <span class="Identifier">continue</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    if <span class="Delimiter">(</span>c == <span class="Constant">'['</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
      in<span class="Delimiter">.</span>putback<span class="Delimiter">(</span>c<span class="Delimiter">);</span>
      <span class="Comment">// recurse</span>
      out &lt;&lt; slurp_quoted<span class="Delimiter">(</span>in<span class="Delimiter">);</span>
      <span class="Identifier">continue</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    out &lt;&lt; c<span class="Delimiter">;</span>
    if <span class="Delimiter">(</span>c == <span class="Constant">']'</span><span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  raise_error &lt;&lt; <span class="Constant">&quot;unbalanced '['</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
  out<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(after &quot;Parsing reagent(string s)&quot;)</span>
if <span class="Delimiter">(</span>s<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> == <span class="Constant">'['</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
  assert<span class="Delimiter">(</span>*s<span class="Delimiter">.</span>rbegin<span class="Delimiter">()</span> == <span class="Constant">']'</span><span class="Delimiter">);</span>
  <span class="Comment">// delete [] delimiters</span>
  s<span class="Delimiter">.</span>erase<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">);</span>
  strip_last<span class="Delimiter">(</span>s<span class="Delimiter">);</span>
  name = s<span class="Delimiter">;</span>
  type = new type_tree<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
  properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span>name<span class="Delimiter">,</span> new string_tree<span class="Delimiter">(</span><span class="Constant">&quot;literal-string&quot;</span><span class="Delimiter">)));</span>
  <span class="Identifier">return</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>

<span class="Comment">//: Unlike other reagents, escape newlines in literal strings to make them</span>
<span class="Comment">//: more friendly to trace().</span>

<span class="Delimiter">:(after &quot;string reagent::to_string()&quot;)</span>
  if <span class="Delimiter">(</span>is_literal_string<span class="Delimiter">(</span>*this<span class="Delimiter">))</span>
    <span class="Identifier">return</span> emit_literal_string<span class="Delimiter">(</span>name<span class="Delimiter">);</span>

<span class="Delimiter">:(code)</span>
bool is_literal_string<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  <span class="Identifier">return</span> x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>second &amp;&amp; x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>second<span class="Delimiter">-&gt;</span>value == <span class="Constant">&quot;literal-string&quot;</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>

string emit_literal_string<span class="Delimiter">(</span>string name<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  size_t pos = <span class="Constant">0</span><span class="Delimiter">;</span>
  while <span class="Delimiter">(</span>pos != string::npos<span class="Delimiter">)</span>
    pos = replace<span class="Delimiter">(</span>name<span class="Delimiter">,</span> <span class="Constant">&quot;</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">,</span> <span class="Constant">&quot;</span><span class="cSpecial">\\</span><span class="Constant">n&quot;</span><span class="Delimiter">,</span> pos<span class="Delimiter">);</span>
  <span class="Identifier">return</span> <span class="Constant">&quot;{</span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span>+name+<span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">: </span><span class="cSpecial">\&quot;</span><span class="Constant">literal-string</span><span class="cSpecial">\&quot;</span><span class="Constant">}&quot;</span><span class="Delimiter">;</span>
<span class="Delimiter">}</span>

size_t replace<span class="Delimiter">(</span>string&amp; str<span class="Delimiter">,</span> const string&amp; from<span class="Delimiter">,</span> const string&amp; to<span class="Delimiter">,</span> size_t n<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  size_t result = str<span class="Delimiter">.</span>find<span class="Delimiter">(</span>from<span class="Delimiter">,</span> n<span class="Delimiter">);</span>
  if <span class="Delimiter">(</span>result != string::npos<span class="Delimiter">)</span>
    str<span class="Delimiter">.</span>replace<span class="Delimiter">(</span>result<span class="Delimiter">,</span> from<span class="Delimiter">.</span>length<span class="Delimiter">(),</span> to<span class="Delimiter">);</span>
  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span class="Delimiter">}</span>

void strip_last<span class="Delimiter">(</span>string&amp; s<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  if <span class="Delimiter">(</span>!s<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> s<span class="Delimiter">.</span>erase<span class="Delimiter">(</span>SIZE<span class="Delimiter">(</span>s<span class="Delimiter">)</span>-<span class="Constant">1</span><span class="Delimiter">);</span>
<span class="Delimiter">}</span>

<span class="Delimiter">:(scenario string_literal_nested)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc [def]]
]
<span class="traceContains">+parse:   ingredient: {&quot;abc [def]&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_escaped)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc \[def]
]
<span class="traceContains">+parse:   ingredient: {&quot;abc [def&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_escaped_comment_aware)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [
abc \\\[def]
]
<span class="traceContains">+parse:   ingredient: {&quot;\nabc \[def&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_and_comment)</span>
recipe main [
  <span class="Constant">1</span>:address:array:character<span class="Special"> &lt;- </span>copy [abc]  <span class="Comment"># comment</span>
]
<span class="traceContains">+parse: --- defining main</span>
<span class="traceContains">+parse: instruction: copy</span>
<span class="traceContains">+parse:   number of ingredients: 1</span>
<span class="traceContains">+parse:   ingredient: {&quot;abc&quot;: &quot;literal-string&quot;}</span>
<span class="traceContains">+parse:   product: {&quot;1&quot;: &lt;&quot;address&quot; : &lt;&quot;array&quot; : &lt;&quot;character&quot; : &lt;&gt;&gt;&gt;&gt;}</span>

<span class="Delimiter">:(scenario string_literal_escapes_newlines_in_trace)</span>
recipe main [
  copy [abc
def]
]
<span class="traceContains">+parse:   ingredient: {&quot;abc\ndef&quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_can_skip_past_comments)</span>
recipe main [
  copy [
    <span class="Comment"># ']' inside comment</span>
    bar
  ]
]
<span class="traceContains">+parse:   ingredient: {&quot;\n    # ']' inside comment\n    bar\n  &quot;: &quot;literal-string&quot;}</span>

<span class="Delimiter">:(scenario string_literal_empty)</span>
recipe main [
  copy []
]
<span class="traceContains">+parse:   ingredient: {&quot;&quot;: &quot;literal-string&quot;}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->
	Commit message (Collapse)	Author	Age	Files	Lines
*	Define POSIX macro to have strdup	Michael Vetter	2020-06-12	1	-2/+2
\| \| \| \| \| \| \| \| \| \| \| \| \| \|	https://github.com/profanity-im/profanity/commit/98c38dc6d6d29333c63f80327774f094610d8602 sets C99 as standard. strdup() is not part of C99. For now set `-D_POSIX_C_SOURCE=200809L` macro to have strdup() in C99. Using `gnu99` instead would be another option. We should take more care to use glib functions whenever possible. Regards https://github.com/profanity-im/profanity/issues/1357
*	inp_readline() Correct slashguard feature	Michael Vetter	2020-04-21	1	-4/+6
\| \| \| \|	Protect against invalid reads by checking the length.
*	Make _inp_edited() more robust	Dmitry Podgorny	2020-04-19	1	-1/+8
\|
*	Add slashguard feature	Michael Vetter	2020-03-18	1	-0/+7
\| \| \| \| \|	New command `/slashguard` tries to protect against typing ` /quit` by not allowing a slash in the first 4 characters.
*	Add vim modeline	Michael Vetter	2019-11-13	1	-0/+1
\|
*	Fix add_history usage in down arrow handler	Michael Vetter	2019-11-05	1	-4/+1
\| \| \| \| \| \| \| \| \| \| \| \| \| \|	[Programming with GNU History](http://www.math.utah.edu/docs/info/hist_2.html) mentions using_history(). Chet, maintainer of readline told me about it. (Thanks Chet!) Seems like we need to call this so that the history offset is at the right end of the list. I assume it's called in the linehandler automatically. Fix https://github.com/profanity-im/profanity/issues/200
*	Store current input line in history	Michael Vetter	2019-11-05	1	-0/+16
\| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|	Regards https://github.com/profanity-im/profanity/issues/200 This doesn't work yet. And I have no idea why. Weird behaviour: - start profanity - type 'ASDF' - ctrl+arrow down -> text vanishes (like intended) - arrow up -> nothing happens (intended is that the last history item [ASDF] appears) - type 'ABC' - press enter - arrow up -> ABC appears - enter - type 'UUU' - ctrl+arrow down - type 'ZZZ' - enter - arrow up - ZZZ appears - arrow up - UUU appears So in the latter case we added to history and deleted from the input line and then immediately entered new text and pressed enter, to add this to the history too. When we do this the not sent text succesfully was stored in history.
*	Bind key to switch to next active window	Michael Vetter	2019-09-30	1	-0/+14
\| \| \| \| \| \|	alt-a brings one to the next window with unread messages. Regards https://github.com/profanity-im/profanity/issues/1114
*	Define keybindings to switch to up to 20 windows	Michael Vetter	2019-09-30	1	-0/+100
\| \| \| \| \| \| \| \| \| \|	alt-2 brings one ot the window. irssi supports alt + 1234567890qwertyuio to easily switch to 20 windows instead of just ten. Hardcode this too. Regards https://github.com/profanity-im/profanity/issues/1114
*	Update copyright to include 2019	Michael Vetter	2019-01-22	1	-1/+1
\|
*	Add prof_win_close (#1017)	twardziejszy	2019-01-10	1	-0/+11
\|
*	WIP add self prefs for statusbar	James Booth	2018-03-10	1	-2/+2
\|
*	Clear autocompletes on line edits	James Booth	2018-02-09	1	-3/+19
\|
*	Update copyright	James Booth	2018-01-21	1	-1/+1
\|
*	Allow previous autocompletion with shift tab	James Booth	2017-04-01	1	-2/+49
\|
*	Update Copyright	James Booth	2017-01-28	1	-1/+1
\|
*	Allow vertical positioning of all windows	James Booth	2016-09-23	1	-10/+4
\|
*	Add /inputwin top\|bottom command	James Booth	2016-09-19	1	-1/+8
\| \| \| \|	closes #853
*	Move all filepath handling to files.c	James Booth	2016-07-24	1	-1/+1
\|
*	Move xgd functions	James Booth	2016-07-24	1	-1/+2
\|
*	Tidy headers	James Booth	2016-07-24	1	-7/+7
\|
*	Moved roster_list.c	James Booth	2016-07-24	1	-1/+1
\|
*	Moved muc.c	James Booth	2016-07-24	1	-1/+1
\|
*	Moved chat_state.c	James Booth	2016-07-24	1	-1/+1
\|
*	Moved chat state handling code to chat_state.c	James Booth	2016-07-24	1	-2/+3
\|
*	Update GPL link in headers	James Booth	2016-07-24	1	-1/+1
\|
*	Rename command sources	James Booth	2016-05-22	1	-1/+1
\|
*	Add cmd_autocomplete.c	James Booth	2016-05-20	1	-3/+3
\|
*	Reorder headers in inputwin.c	James Booth	2016-05-11	1	-1/+1
\| \| \| \|	Fixes unknown type name '_fpos64_t' error on Cygwin
*	Implement XEP-0363: HTTP File Upload	Dominik Heidler	2016-04-26	1	-0/+3
\|
*	Removed #AX_PREFIX_CONFIG_H	James Booth	2016-03-31	1	-3/+3
\|
*	Merge branch 'master' into plugins-c	James Booth	2016-02-14	1	-1/+1
\|\ \| \| \| \| \| \| \| \| \| \|	Conflicts: src/main.c src/ui/console.c
\| *	Updated copyright	James Booth	2016-02-14	1	-1/+1
\| \|
* \|	Added C plugin code from plugins branch	James Booth	2016-02-14	1	-3/+3
\|/
*	Added sys/select.h header includes	James Booth	2016-01-19	1	-0/+1
\|
*	Use MB_CUR_MAX when calculating cursor position	James Booth	2015-12-19	1	-1/+1
\|
*	Read ~/.config/profanity/inputrc	James Booth	2015-12-06	1	-0/+7
\|
*	Renamed readline handlers	James Booth	2015-12-06	1	-93/+93
\|
*	Added readline function definitions	James Booth	2015-12-06	1	-1/+24
\|
*	readline: set rl_outstream to /dev/null	James Booth	2015-12-01	1	-0/+5
\|
*	Disable readline completion	James Booth	2015-11-29	1	-0/+3
\|
*	Clear Readline undo list when autocompleting command history	James Booth	2015-11-09	1	-2/+2
\| \| \| \|	fixes #667
*	Renamed ui_switch_win -> ui_focus_win	James Booth	2015-11-02	1	-3/+3
\|
*	Removed ui_ paging functions	James Booth	2015-11-01	1	-4/+8
\|
*	Removed inp_win_clear()	James Booth	2015-11-01	1	-9/+0
\|
*	Removed ui_events module	James Booth	2015-10-27	1	-1/+0
\|
*	Removed ui_ev_focus_win	James Booth	2015-10-27	1	-3/+3
\|
*	Get rid of compiler warning concerning NULL pointer	Michael Vetter	2015-10-26	1	-1/+1
\| \| \| \|	Casting the into correct type.
*	Applied coding style to src/ui/	James Booth	2015-10-25	1	-2/+2
\|
*	Fixed resize during password and tls commands	James Booth	2015-10-06	1	-0/+2
\|