392 lines
8.1 KiB
C++
392 lines
8.1 KiB
C++
// CODYlib -*- mode:c++ -*-
|
|
// Copyright (C) 2020 Nathan Sidwell, nathan@acm.org
|
|
// License: Apache v2.0
|
|
|
|
// Cody
|
|
#include "internal.hh"
|
|
// C++
|
|
#include <algorithm>
|
|
// C
|
|
#include <cstring>
|
|
// OS
|
|
#include <unistd.h>
|
|
#include <cerrno>
|
|
|
|
// MessageBuffer code
|
|
|
|
// Lines consist of words and end with a NEWLINE (0xa) char
|
|
// Whitespace characters are TAB (0x9) and SPACE (0x20)
|
|
// Words consist of non-whitespace chars separated by whitespace.
|
|
// Multiple lines in one transaction are indicated by ending non-final
|
|
// lines with a SEMICOLON (0x3b) word, immediately before the NEWLINE
|
|
// Continuations with ; preceding it
|
|
// Words matching regexp [-+_/%.a-zA-Z0-9]+ need no quoting.
|
|
// Quoting with '...'
|
|
// Anything outside of [-+_/%.a-zA-Z0-9] needs quoting
|
|
// Anything outside of <= <space> or DEL or \' or \\ needs escaping.
|
|
// Escapes are \\, \', \n, \t, \_, everything else as \<hex><hex>?
|
|
// Spaces separate words, UTF8 encoding for non-ascii chars
|
|
|
|
namespace Cody {
|
|
namespace Detail {
|
|
|
|
static const char CONTINUE = S2C(u8";");
|
|
|
|
void MessageBuffer::BeginLine ()
|
|
{
|
|
if (!buffer.empty ())
|
|
{
|
|
// Terminate the previous line with a continuation
|
|
buffer.reserve (buffer.size () + 3);
|
|
buffer.push_back (S2C(u8" "));
|
|
buffer.push_back (CONTINUE);
|
|
buffer.push_back (S2C(u8"\n"));
|
|
}
|
|
lastBol = buffer.size ();
|
|
}
|
|
|
|
// QUOTE means 'maybe quote', we search it for quote-needing chars
|
|
|
|
void MessageBuffer::Append (char const *str, bool quote, size_t len)
|
|
{
|
|
if (len == ~size_t (0))
|
|
len = strlen (str);
|
|
|
|
if (!len && !quote)
|
|
return;
|
|
|
|
// We want to quote characters outside of [-+_A-Za-z0-9/%.], anything
|
|
// that could remotely be shell-active. UTF8 encoding for non-ascii.
|
|
if (quote && len)
|
|
{
|
|
quote = false;
|
|
// Scan looking for quote-needing characters. We could just
|
|
// append until we find one, but that's probably confusing
|
|
for (size_t ix = len; ix--;)
|
|
{
|
|
unsigned char c = (unsigned char)str[ix];
|
|
if (!((c >= S2C(u8"a") && c <= S2C(u8"z"))
|
|
|| (c >= S2C(u8"A") && c <= S2C(u8"Z"))
|
|
|| (c >= S2C(u8"0") && c <= S2C(u8"9"))
|
|
|| c == S2C(u8"-") || c == S2C(u8"+") || c == S2C(u8"_")
|
|
|| c == S2C(u8"/") || c == S2C(u8"%") || c == S2C(u8".")))
|
|
{
|
|
quote = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Maximal length of appended string
|
|
buffer.reserve (buffer.size () + len * (quote ? 3 : 1) + 2);
|
|
|
|
if (quote)
|
|
buffer.push_back (S2C(u8"'"));
|
|
|
|
for (auto *end = str + len; str != end;)
|
|
{
|
|
auto *e = end;
|
|
|
|
if (quote)
|
|
// Look for next escape-needing char. More relaxed than
|
|
// the earlier needs-quoting check.
|
|
for (e = str; e != end; ++e)
|
|
{
|
|
unsigned char c = (unsigned char)*e;
|
|
if (c < S2C(u8" ") || c == 0x7f
|
|
|| c == S2C(u8"\\") || c == S2C(u8"'"))
|
|
break;
|
|
}
|
|
buffer.insert (buffer.end (), str, e);
|
|
str = e;
|
|
|
|
if (str == end)
|
|
break;
|
|
|
|
buffer.push_back (S2C(u8"\\"));
|
|
switch (unsigned char c = (unsigned char)*str++)
|
|
{
|
|
case S2C(u8"\t"):
|
|
c = S2C(u8"t");
|
|
goto append;
|
|
|
|
case S2C(u8"\n"):
|
|
c = S2C(u8"n");
|
|
goto append;
|
|
|
|
case S2C(u8"'"):
|
|
case S2C(u8"\\"):
|
|
append:
|
|
buffer.push_back (c);
|
|
break;
|
|
|
|
default:
|
|
// Full-on escape. Use 2 lower-case hex chars
|
|
for (unsigned shift = 8; shift;)
|
|
{
|
|
shift -= 4;
|
|
|
|
char nibble = (c >> shift) & 0xf;
|
|
nibble += S2C(u8"0");
|
|
if (nibble > S2C(u8"9"))
|
|
nibble += S2C(u8"a") - (S2C(u8"9") + 1);
|
|
buffer.push_back (nibble);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (quote)
|
|
buffer.push_back (S2C(u8"'"));
|
|
}
|
|
|
|
void MessageBuffer::Append (char c)
|
|
{
|
|
buffer.push_back (c);
|
|
}
|
|
|
|
void MessageBuffer::AppendInteger (unsigned u)
|
|
{
|
|
// Sigh, even though std::to_string is C++11, we support building on
|
|
// gcc 4.8, which is a C++11 compiler lacking std::to_string. so
|
|
// have something horrible.
|
|
std::string v (20, 0);
|
|
size_t len = snprintf (const_cast<char *> (v.data ()), v.size (), "%u", u);
|
|
v.erase (len);
|
|
|
|
AppendWord (v);
|
|
}
|
|
|
|
int MessageBuffer::Write (int fd) noexcept
|
|
{
|
|
size_t limit = buffer.size () - lastBol;
|
|
ssize_t count = write (fd, &buffer.data ()[lastBol], limit);
|
|
|
|
int err = 0;
|
|
if (count < 0)
|
|
err = errno;
|
|
else
|
|
{
|
|
lastBol += count;
|
|
if (size_t (count) != limit)
|
|
err = EAGAIN;
|
|
}
|
|
|
|
if (err != EAGAIN && err != EINTR)
|
|
{
|
|
// Reset for next message
|
|
buffer.clear ();
|
|
lastBol = 0;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
int MessageBuffer::Read (int fd) noexcept
|
|
{
|
|
constexpr size_t blockSize = 200;
|
|
|
|
size_t lwm = buffer.size ();
|
|
size_t hwm = buffer.capacity ();
|
|
if (hwm - lwm < blockSize / 2)
|
|
hwm += blockSize;
|
|
buffer.resize (hwm);
|
|
|
|
auto iter = buffer.begin () + lwm;
|
|
ssize_t count = read (fd, &*iter, hwm - lwm);
|
|
buffer.resize (lwm + (count >= 0 ? count : 0));
|
|
|
|
if (count < 0)
|
|
return errno;
|
|
|
|
if (!count)
|
|
// End of file
|
|
return -1;
|
|
|
|
bool more = true;
|
|
for (;;)
|
|
{
|
|
auto newline = std::find (iter, buffer.end (), S2C(u8"\n"));
|
|
if (newline == buffer.end ())
|
|
break;
|
|
more = newline != buffer.begin () && newline[-1] == CONTINUE;
|
|
iter = newline + 1;
|
|
|
|
if (iter == buffer.end ())
|
|
break;
|
|
|
|
if (!more)
|
|
{
|
|
// There is no continuation, but there are chars after the
|
|
// newline. Truncate the buffer and return an error
|
|
buffer.resize (iter - buffer.begin ());
|
|
return EINVAL;
|
|
}
|
|
}
|
|
|
|
return more ? EAGAIN : 0;
|
|
}
|
|
|
|
int MessageBuffer::Lex (std::vector<std::string> &result)
|
|
{
|
|
result.clear ();
|
|
|
|
if (IsAtEnd ())
|
|
return ENOENT;
|
|
|
|
Assert (buffer.back () == S2C(u8"\n"));
|
|
|
|
auto iter = buffer.begin () + lastBol;
|
|
|
|
for (std::string *word = nullptr;;)
|
|
{
|
|
char c = *iter;
|
|
|
|
++iter;
|
|
if (c == S2C(u8" ") || c == S2C(u8"\t"))
|
|
{
|
|
word = nullptr;
|
|
continue;
|
|
}
|
|
|
|
if (c == S2C(u8"\n"))
|
|
break;
|
|
|
|
if (c == CONTINUE)
|
|
{
|
|
// Line continuation
|
|
if (word || *iter != S2C(u8"\n"))
|
|
goto malformed;
|
|
++iter;
|
|
break;
|
|
}
|
|
|
|
if (c <= S2C(u8" ") || c >= 0x7f)
|
|
goto malformed;
|
|
|
|
if (!word)
|
|
{
|
|
result.emplace_back ();
|
|
word = &result.back ();
|
|
}
|
|
|
|
if (c == S2C(u8"'"))
|
|
{
|
|
// Quoted word
|
|
for (;;)
|
|
{
|
|
c = *iter;
|
|
|
|
if (c == S2C(u8"\n"))
|
|
{
|
|
malformed:;
|
|
result.clear ();
|
|
iter = std::find (iter, buffer.end (), S2C(u8"\n"));
|
|
auto back = iter;
|
|
if (back[-1] == CONTINUE && back[-2] == S2C(u8" "))
|
|
// Smells like a line continuation
|
|
back -= 2;
|
|
result.emplace_back (&buffer[lastBol],
|
|
back - buffer.begin () - lastBol);
|
|
++iter;
|
|
lastBol = iter - buffer.begin ();
|
|
return EINVAL;
|
|
}
|
|
|
|
if (c < S2C(u8" ") || c >= 0x7f)
|
|
goto malformed;
|
|
|
|
++iter;
|
|
if (c == S2C(u8"'"))
|
|
break;
|
|
|
|
if (c == S2C(u8"\\"))
|
|
// escape
|
|
switch (c = *iter)
|
|
{
|
|
case S2C(u8"\\"):
|
|
case S2C(u8"'"):
|
|
++iter;
|
|
break;
|
|
|
|
case S2C(u8"n"):
|
|
c = S2C(u8"\n");
|
|
++iter;
|
|
break;
|
|
|
|
case S2C(u8"_"):
|
|
// We used to escape SPACE as \_, so accept that
|
|
c = S2C(u8" ");
|
|
++iter;
|
|
break;
|
|
|
|
case S2C(u8"t"):
|
|
c = S2C(u8"\t");
|
|
++iter;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
unsigned v = 0;
|
|
for (unsigned nibble = 0; nibble != 2; nibble++)
|
|
{
|
|
c = *iter;
|
|
if (c < S2C(u8"0"))
|
|
{
|
|
if (!nibble)
|
|
goto malformed;
|
|
break;
|
|
}
|
|
else if (c <= S2C(u8"9"))
|
|
c -= S2C(u8"0");
|
|
else if (c < S2C(u8"a"))
|
|
{
|
|
if (!nibble)
|
|
goto malformed;
|
|
break;
|
|
}
|
|
else if (c <= S2C(u8"f"))
|
|
c -= S2C(u8"a") - 10;
|
|
else
|
|
{
|
|
if (!nibble)
|
|
goto malformed;
|
|
break;
|
|
}
|
|
++iter;
|
|
v = (v << 4) | c;
|
|
}
|
|
c = v;
|
|
}
|
|
}
|
|
word->push_back (c);
|
|
}
|
|
}
|
|
else
|
|
// Unquoted character
|
|
word->push_back (c);
|
|
}
|
|
lastBol = iter - buffer.begin ();
|
|
if (result.empty ())
|
|
return ENOENT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void MessageBuffer::LexedLine (std::string &str)
|
|
{
|
|
if (lastBol)
|
|
{
|
|
size_t pos = lastBol - 1;
|
|
for (; pos; pos--)
|
|
if (buffer[pos-1] == S2C(u8"\n"))
|
|
break;
|
|
|
|
size_t end = lastBol - 1;
|
|
if (buffer[end-1] == CONTINUE && buffer[end-2] == S2C(u8" "))
|
|
// Strip line continuation
|
|
end -= 2;
|
|
str.append (&buffer[pos], end - pos);
|
|
}
|
|
}
|
|
} // Detail
|
|
} // Cody
|