ReturnCode process_()
{
MSS_BEGIN(ReturnCode, logns);
Name name;
switch (const auto rc = pop_name_(name))
{
case ReturnCode::OK:
break;
case ReturnCode::NotFound:
MSS_RETURN_OK();
break;
default: MSS(rc); break;
}
Attributes attrs;
MSS(pop_attrs_(attrs));
receiver_().parser_open(name, attrs);
pop_whitespace_();
if (content_.pop_if('{'))
{
pop_whitespace_();
while (!content_.pop_if('}'))
{
MSS(process_());
}
}
receiver_().parser_close();
MSS_END();
}
bool processEnd()
{
if (state_ == MacroInclude)
{
receiver_().include_detected(include_.str(), IncludeType::Macro);
include_.str("");
state_ = Idle;
}
receiver_().include_end();
return true;
}
//Indicate that we received an alive message
//This will send oostatus_online() to Receiver when it comes online again
void indicateOnline()
{
timeout_ = Timeout;
if (isOnline_)
return;
isOnline_ = true;
receiver_().oostatus_online();
}
void process()
{
if (isExpired_)
return;
if (clock::now() < expireTime_)
return;
isExpired_ = true;
receiver_().timer_expired();
}
//Will send oostatus_offline() when we timeout and become offline
void process(int elapse)
{
if (!isOnline_)
//We are already offline, further processing doesn't matter anymore
return;
if (elapse <= timeout_)
{
//Timeout is getting closer...
timeout_ -= elapse;
return;
}
//We timed-out and will become offline
timeout_ = 0;
isOnline_ = false;
receiver_().oostatus_offline();
}
ReturnCode process()
{
MSS_BEGIN(ReturnCode);
if (out_.empty())
{
if (mss::isOK(receiver_().framer_getNextFrameToSend(out_)))
{
outIt_ = out_.begin();
MSS(Configuration::Protocol::sendStartOfFrame(physical_()));
}
}
while (!out_.empty())
{
if (outIt_ == out_.end())
{
out_.clear();
MSS(Configuration::Protocol::sendEndOfFrame(physical_()));
}
else
MSS(Configuration::Protocol::sendByte(physical_(), *outIt_++));
}
MSS_END();
}
void metronome_tick()
{
clearInfo_.reset();
receiver_().top_slice(info_);
}
void sendMessage(std::string message) override {
receiver_(std::move(message));
}
ReturnCode process(const pp::Token &token)
{
MSS_BEGIN(ReturnCode);
if (state_ == MacroInclude)
{
if (isLineFeed(token) || isCarriageReturn(token))
{
receiver_().include_detected(include_.str(), IncludeType::Macro);
include_.str("");
state_ = Idle;
}
else
include_ << token.range.content();
}
else if (token.isWhitespace())
{
}
else
{
switch (state_)
{
case Idle:
if (isMacro(token) && token.range.content() == "include")
state_ = IncludeDetected;
break;
case IncludeDetected:
if (isString(token))
{
const auto content = token.range.content();
MSS(content.front() == '"' && content.back() == '"', IllegalInclude);
MSS(content.size() > 2, IllegalIncludeSize);
receiver_().include_detected(content.substr(1, content.size()-2), IncludeType::Local);
state_ = Idle;
}
else if (isSymbol(token))
{
MSS(token.range.content() == "<");
include_.str("");
state_ = BeginBracketInclude;
}
else if (isIdentifier(token))
{
include_.str("");
include_ << token.range.content();
state_ = MacroInclude;
}
else
{
std::ostringstream oss;
oss << "I expected either a Symbol or a String, but I got a " << toString(token.type);
receiver_().include_error(oss.str());
MSS_L(UnexpectedToken);
}
break;
case BeginBracketInclude:
switch (token.type)
{
case Token::Identifier:
include_ << token.range.content();
break;
case Token::Symbol:
{
const auto symbol = token.range.content();
assert(symbol.size() == 1);
switch (symbol[0])
{
case '.':
case '/':
include_ << symbol;
break;
case '>':
receiver_().include_detected(include_.str(), IncludeType::System);
include_.str("");
state_ = Idle;
break;
default:
MSS_L(UnexpectedSymbol);
break;
}
}
break;
default:
MSS_L(UnexpectedToken);
break;
}
break;
}
}
MSS_END();
}
bool processBegin()
{
receiver_().include_begin();
return true;
}
bool process(const pp::Token &token)
{
if (isIdentifier(token))
receiver_().identifier_detected(token.range.content());
return true;
}
ReturnCode process(const gubg::file::File &file)
{
MSS_BEGIN(ReturnCode);
Range range;
MSS(gubg::file::read(range, file));
pp::Lexer<std::vector<pp::Token>> lexer;
MSS(lexer.tokenize(range));
enum State {Idle, IncludeDetected, BeginBracketInclude, MacroInclude};
State state = Idle;
std::ostringstream incl;
auto &tokens = lexer.tokens();
for (auto it = tokens.begin(); it != tokens.end(); ++it)
{
auto &token = *it;
typedef pp::Token Token;
if (state == MacroInclude)
{
if (isLineFeed(token) || isCarriageReturn(token))
{
receiver_().includes_detected(incl.str(), IncludeType::Macro);
incl.str("");
state = Idle;
}
else
incl << token.range.content();
continue;
}
if (token.isWhitespace())
continue;
switch (state)
{
case Idle:
if (isMacro(token) && token.range.content() == "include")
state = IncludeDetected;
break;
case IncludeDetected:
if (isString(token))
{
const auto content = token.range.content();
MSS(content.front() == '"' && content.back() == '"', IllegalInclude);
MSS(content.size() > 2, IllegalIncludeSize);
receiver_().includes_detected(content.substr(1, content.size()-2), IncludeType::Local);
state = Idle;
}
else if (isSymbol(token))
{
MSS(token.range.content() == "<");
incl.str("");
state = BeginBracketInclude;
}
else if (isIdentifier(token))
{
incl.str("");
incl << token.range.content();
state = MacroInclude;
}
else
{
std::ostringstream oss;
oss << "I expected either a Symbol or a String, but I got a " << toString(token.type);
receiver_().includes_error(oss.str());
MSS_L(UnexpectedToken);
}
break;
case BeginBracketInclude:
switch (token.type)
{
case Token::Identifier:
incl << token.range.content();
break;
case Token::Symbol:
{
const auto symbol = token.range.content();
assert(symbol.size() == 1);
switch (symbol[0])
{
case '.':
case '/':
case '-':
case '+':
incl << symbol;
break;
case '>':
receiver_().includes_detected(incl.str(), IncludeType::System);
incl.str("");
state = Idle;
break;
default:
MSS_L(UnexpectedSymbol);
break;
}
}
break;
default:
MSS_L(UnexpectedToken);
break;
}
break;
}
}
if (state == MacroInclude)
{
receiver_().includes_detected(incl.str(), IncludeType::Macro);
incl.str("");
state = Idle;
}
MSS_END();
}
//Call this in setup to make sure Receiver will get the oostatus_offline() message
void setup()
{
isOnline_ = false;
receiver_().oostatus_offline();
}
int repaint_()
{
receiver_().canvas_repaint();
return IUP_DEFAULT;
}
