GothenburgBitFactory/taskwarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/taskwarrior.git synced 2025-06-26 10:54:26 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Nibbler: Elimnated, migrated to Pig

Browse source
This commit is contained in:
Paul Beckingham 2017-03-04 22:21:49 -05:00
parent 2912df58fb
commit d0ec6b27aa
3 changed files with 0 additions and 716 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/CMakeLists.txt
View file

@ -14,7 +14,6 @@ add_library (task CLI2.cpp CLI2.h
Filter.cpp Filter.h Filter.cpp Filter.h
Hooks.cpp Hooks.h Hooks.cpp Hooks.h
Lexer.cpp Lexer.h Lexer.cpp Lexer.h
Nibbler.cpp Nibbler.h
TDB2.cpp TDB2.h TDB2.cpp TDB2.h
Task.cpp Task.h Task.cpp Task.h
TLSClient.cpp TLSClient.h TLSClient.cpp TLSClient.h

626
src/Nibbler.cpp
View file

@ -1,626 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2006 - 2017, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <cmake.h>
#include <Nibbler.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <Lexer.h>
#include <util.h>
static const char* _uuid_pattern = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
static const unsigned int _uuid_min_length = 8;
////////////////////////////////////////////////////////////////////////////////
Nibbler::Nibbler ()
: _length (0)
, _cursor (0)
, _saved (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Nibbler::Nibbler (const std::string& input)
: _input (std::make_shared <std::string> (input))
, _length (input.length ())
, _cursor (0)
{
}
////////////////////////////////////////////////////////////////////////////////
Nibbler::Nibbler (const Nibbler& other)
: _input (other._input)
, _length (other._length)
, _cursor (other._cursor)
{
}
////////////////////////////////////////////////////////////////////////////////
Nibbler& Nibbler::operator= (const Nibbler& other)
{
if (this != &other)
{
_input = other._input;
_length = other._length;
_cursor = other._cursor;
}
return *this;
}
////////////////////////////////////////////////////////////////////////////////
Nibbler::~Nibbler ()
{
}
////////////////////////////////////////////////////////////////////////////////
// Extract up until the next c (but not including) or EOS.
bool Nibbler::getUntil (char c, std::string& result)
{
if (_cursor < _length)
{
auto i = _input->find (c, _cursor);
if (i != std::string::npos)
{
result = _input->substr (_cursor, i - _cursor);
_cursor = i;
}
else
{
result = _input->substr (_cursor);
_cursor = _length;
}
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getUntil (const std::string& terminator, std::string& result)
{
if (_cursor < _length)
{
auto i = _input->find (terminator, _cursor);
if (i != std::string::npos)
{
result = _input->substr (_cursor, i - _cursor);
_cursor = i;
}
else
{
result = _input->substr (_cursor);
_cursor = _length;
}
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getUntilOneOf (const std::string& chars, std::string& result)
{
if (_cursor < _length)
{
auto i = _input->find_first_of (chars, _cursor);
if (i != std::string::npos)
{
result = _input->substr (_cursor, i - _cursor);
_cursor = i;
}
else
{
result = _input->substr (_cursor);
_cursor = _length;
}
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getUntilWS (std::string& result)
{
return this->getUntilOneOf (" \t\r\n\f", result);
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getUntilEOS (std::string& result)
{
if (_cursor < _length)
{
result = _input->substr (_cursor);
_cursor = _length;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getN (const int quantity, std::string& result)
{
if (_cursor + quantity <= _length)
{
result = _input->substr (_cursor, quantity);
_cursor += quantity;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
// Gets quote content: "foobar" -> foobar (for c = '"')
// Handles escaped quotes: "foo\"bar" -> foo\"bar (for c = '"')
// Returns false if first character is not c, or if there is no closing c
bool Nibbler::getQuoted (char c, std::string& result)
{
result = "";
if (_cursor >= _length ||
(*_input)[_cursor] != c)
{
return false;
}
std::string::size_type start = _cursor + 1; // Skip first quote char
std::string::size_type i = start;
while (i < _length)
{
i = (*_input).find (c, i);
if (i == std::string::npos)
return false; // Unclosed quote
if (i == start)
{
// Empty quote
_cursor += 2; // Skip both quote chars
return true;
}
if ((*_input)[i-1] == '\\')
{
// Check for escaped backslashes. Backtracking like this is not very
// efficient, but is only done in extreme corner cases.
auto j = i-2; // Start one character further left
bool is_escaped_quote = true;
while (j >= start && (*_input)[j] == '\\')
{
// Toggle flag for each further backslash encountered.
is_escaped_quote = is_escaped_quote ? false : true;
--j;
}
if (is_escaped_quote)
{
// Keep searching
++i;
continue;
}
}
// None of the above applied, we must have found the closing quote char.
result.assign ((*_input), start, i - start);
_cursor = i + 1; // Skip closing quote char
return true;
}
// This should never be reached. We could throw here instead.
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getDigit (int& result)
{
if (_cursor < _length &&
Lexer::isDigit ((*_input)[_cursor]))
{
result = (*_input)[_cursor++] - '0';
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getDigit4 (int& result)
{
auto i = _cursor;
if (i < _length &&
_length - i >= 4)
{
if (Lexer::isDigit ((*_input)[i + 0]) &&
Lexer::isDigit ((*_input)[i + 1]) &&
Lexer::isDigit ((*_input)[i + 2]) &&
Lexer::isDigit ((*_input)[i + 3]))
{
result = strtoimax (_input->substr (_cursor, 4).c_str (), NULL, 10);
_cursor += 4;
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getDigit3 (int& result)
{
auto i = _cursor;
if (i < _length &&
_length - i >= 3)
{
if (Lexer::isDigit ((*_input)[i + 0]) &&
Lexer::isDigit ((*_input)[i + 1]) &&
Lexer::isDigit ((*_input)[i + 2]))
{
result = strtoimax (_input->substr (_cursor, 3).c_str (), NULL, 10);
_cursor += 3;
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getDigit2 (int& result)
{
auto i = _cursor;
if (i < _length &&
_length - i >= 2)
{
if (Lexer::isDigit ((*_input)[i + 0]) &&
Lexer::isDigit ((*_input)[i + 1]))
{
result = strtoimax (_input->substr (_cursor, 2).c_str (), NULL, 10);
_cursor += 2;
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getInt (int& result)
{
auto i = _cursor;
if (i < _length)
{
if ((*_input)[i] == '-')
++i;
else if ((*_input)[i] == '+')
++i;
}
// TODO Potential for use of find_first_not_of
while (i < _length && Lexer::isDigit ((*_input)[i]))
++i;
if (i > _cursor)
{
result = strtoimax (_input->substr (_cursor, i - _cursor).c_str (), NULL, 10);
_cursor = i;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getUnsignedInt (int& result)
{
auto i = _cursor;
// TODO Potential for use of find_first_not_of
while (i < _length && Lexer::isDigit ((*_input)[i]))
++i;
if (i > _cursor)
{
result = strtoimax (_input->substr (_cursor, i - _cursor).c_str (), NULL, 10);
_cursor = i;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
// number:
// int frac? exp?
//
// int:
// (-|+)? digit+
//
// frac:
// . digit+
//
// exp:
// e digit+
//
// e:
// e|E (+|-)?
//
bool Nibbler::getNumber (std::string& result)
{
auto i = _cursor;
// [+-]?
if (i < _length && ((*_input)[i] == '-' || (*_input)[i] == '+'))
++i;
// digit+
if (i < _length && Lexer::isDigit ((*_input)[i]))
{
++i;
while (i < _length && Lexer::isDigit ((*_input)[i]))
++i;
// ( . digit+ )?
if (i < _length && (*_input)[i] == '.')
{
++i;
while (i < _length && Lexer::isDigit ((*_input)[i]))
++i;
}
// ( [eE] [+-]? digit+ )?
if (i < _length && ((*_input)[i] == 'e' || (*_input)[i] == 'E'))
{
++i;
if (i < _length && ((*_input)[i] == '+' || (*_input)[i] == '-'))
++i;
if (i < _length && Lexer::isDigit ((*_input)[i]))
{
++i;
while (i < _length && Lexer::isDigit ((*_input)[i]))
++i;
result = _input->substr (_cursor, i - _cursor);
_cursor = i;
return true;
}
return false;
}
result = _input->substr (_cursor, i - _cursor);
_cursor = i;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getNumber (double &result)
{
std::string s;
if (getNumber (s))
{
result = strtof (s.c_str (), NULL);
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getLiteral (const std::string& literal)
{
if (_cursor < _length &&
_input->find (literal, _cursor) == _cursor)
{
_cursor += literal.length ();
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::getPartialUUID (std::string& result)
{
std::string::size_type i;
for (i = 0; i < 36 && i < (_length - _cursor); i++)
{
if (_uuid_pattern[i] == 'x' && !isxdigit ((*_input)[_cursor + i]))
break;
else if (_uuid_pattern[i] == '-' && (*_input)[_cursor + i] != '-')
break;
}
// If the partial match found is long enough, consider it a match.
if (i >= _uuid_min_length)
{
// Fail if there is another hex digit.
if (_cursor + i < _length &&
isxdigit ((*_input)[_cursor + i]))
return false;
result = _input->substr (_cursor, i);
_cursor += i;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
// Assumes that the options are sorted by decreasing length, so that if the
// options contain 'fourteen' and 'four', the stream is first matched against
// the longer entry.
bool Nibbler::getOneOf (
const std::vector <std::string>& options,
std::string& found)
{
for (auto& option : options)
{
if (getLiteral (option))
{
found = option;
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::skipN (const int quantity /* = 1 */)
{
if (_cursor < _length &&
_cursor <= _length - quantity)
{
_cursor += quantity;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::skip (char c)
{
if (_cursor < _length &&
(*_input)[_cursor] == c)
{
++_cursor;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::skipWS ()
{
return this->skipAllOneOf (" \t\n\r\f");
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::skipAllOneOf (const std::string& chars)
{
if (_cursor < _length)
{
auto i = _input->find_first_not_of (chars, _cursor);
if (i == _cursor)
return false;
if (i == std::string::npos)
_cursor = _length; // Yes, off the end.
else
_cursor = i;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
// Peeks ahead - does not move cursor.
char Nibbler::next ()
{
if (_cursor < _length)
return (*_input)[_cursor];
return '\0';
}
////////////////////////////////////////////////////////////////////////////////
std::string::size_type Nibbler::cursor ()
{
return _cursor;
}
////////////////////////////////////////////////////////////////////////////////
// Peeks ahead - does not move cursor.
std::string Nibbler::next (const int quantity)
{
if ( _cursor < _length &&
(unsigned) quantity <= _length &&
_cursor <= _length - quantity)
return _input->substr (_cursor, quantity);
return "";
}
////////////////////////////////////////////////////////////////////////////////
std::string::size_type Nibbler::save ()
{
return _saved = _cursor;
}
////////////////////////////////////////////////////////////////////////////////
std::string::size_type Nibbler::restore ()
{
return _cursor = _saved;
}
////////////////////////////////////////////////////////////////////////////////
const std::string& Nibbler::str () const
{
return *_input;
}
////////////////////////////////////////////////////////////////////////////////
bool Nibbler::depleted ()
{
if (_cursor >= _length)
return true;
return false;
}
////////////////////////////////////////////////////////////////////////////////
std::string Nibbler::dump ()
{
return std::string ("Nibbler ‹")
+ _input->substr (_cursor)
+ "›";
}
////////////////////////////////////////////////////////////////////////////////

89
src/Nibbler.h
View file

@ -1,89 +0,0 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright 2006 - 2017, Paul Beckingham, Federico Hernandez.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#ifndef INCLUDED_NIBBLER
#define INCLUDED_NIBBLER
#include <string>
#include <vector>
#include <time.h>
#include <memory>
class Nibbler
{
public:
Nibbler (); // Default constructor
Nibbler (const std::string&); // Constructor
Nibbler (const Nibbler&); // Copy constructor
Nibbler& operator= (const Nibbler&); // Assignment operator
~Nibbler (); // Destructor
bool getUntil (char, std::string&);
bool getUntil (const std::string&, std::string&);
bool getUntilOneOf (const std::string&, std::string&);
bool getUntilWS (std::string&);
bool getUntilEOS (std::string&);
bool getN (const int, std::string&);
bool getQuoted (char, std::string&);
bool getDigit (int&);
bool getDigit4 (int&);
bool getDigit3 (int&);
bool getDigit2 (int&);
bool getInt (int&);
bool getUnsignedInt (int&);
bool getNumber (std::string&);
bool getNumber (double&);
bool getLiteral (const std::string&);
bool getPartialUUID (std::string&);
bool getOneOf (const std::vector <std::string>&, std::string&);
bool skipN (const int quantity = 1);
bool skip (char);
bool skipAllOneOf (const std::string&);
bool skipWS ();
char next ();
std::string next (const int quantity);
std::string::size_type cursor ();
std::string::size_type save ();
std::string::size_type restore ();
const std::string& str () const;
bool depleted ();
std::string dump ();
private:
std::shared_ptr<std::string> _input;
std::string::size_type _length;
std::string::size_type _cursor;
std::string::size_type _saved;
};
#endif
////////////////////////////////////////////////////////////////////////////////