static void get_ants(t_env *data, char *line)
{
int i;
i = 0;
if (get_next_line(0, &line) == -1)
ft_error("read");
if (line[0] == '#')
{
if (!ft_strcmp(line, "##start") || !ft_strcmp(line, "##end"))
parsing_error(data, line);
}
else
{
while (line[i])
{
if (!ft_isdigit(line[i]))
parsing_error(data, line);
i++;
}
data->ants = ft_atoi(line);
if (!data->ants)
parsing_error(data, line);
}
ft_putendl(line);
ft_strdel(&line);
}
/** \brief notify a utmsg packet
*
* @return a tokeep from the bt_swarm_full_t notification (if no notification, return true)
*/
bool bt_utmsg_fstart_cnx_t::parse_pkt(const bt_utmsgtype_t &bt_utmsgtype
, const pkt_t &pkt) throw()
{
// log to debug
KLOG_DBG("enter bt_utmsgtype=" << bt_utmsgtype << " pkt=" << pkt);
// sanity check - bt_utmsgtype MUST be the one of the bt_utmsg_vapi_t
DBG_ASSERT( utmsg_fstart->utmsgtype() == bt_utmsgtype );
// convert the fstart message body to a dvar_t
dvar_t dvar = bencode_t::to_dvar(pkt.to_datum(datum_t::NOCOPY));
// if the handshake_dvar failed to parse the bencoded data, return an error
if( dvar.is_null() || dvar.type() != dvar_type_t::MAP )
return parsing_error("unable to find fstart payload as dvar_type_t::MAP");
// if the dvar doesnt include the balance, return an error
if( !dvar.map().contain("v", dvar_type_t::INTEGER) )
return parsing_error("unable to find 'v' fstart payload");
// get the data from the dvar_t
m_remote_fstart = dvar.map()["v"].integer().to_size_t();
// log to debug
KLOG_ERR("remote_fstart=" << remote_fstart() );
// return noerror
return true;
}
int factorParsing(int nLayer)
{
parsingPrintLn(nLayer-1, "FACTOR", 0);
switch(allWords[nAllIndex].eType) {
case IDENTIFY:
PARSING_PRINT("IDENTIFY");
break;
case INTEGER:
case FLOATNUM:
PARSING_PRINT("NUMBER");
break;
case LPAREN:
PARSING_PRINT("LEFT_PAREN");
expressionParsing(nLayer+1);
if (allWords[nAllIndex].eType == RPAREN) {
PARSING_PRINT("RIGHT_PAREN");
}
else {
parsing_error(NEED_RPAREN);
}
break;
default:
parsing_error(NOT_FACTOR);
break;
}
return 0;
}
int parsing(t_env *data)
{
char *line;
int ret;
line = NULL;
while (!(data->ants))
get_ants(data, line);
while ((ret = get_next_line(0, &line)))
{
if (!check_line(&line, data))
{
if (!can_start(data))
parsing_error(data, line);
ft_strdel(&line);
ft_putchar('\n');
return (solve(data));
}
ft_putendl(line);
ft_strdel(&line);
}
if (ret == -1)
ft_error("read");
ft_putchar('\n');
if (!can_start(data))
parsing_error(data, line);
return (solve(data));
}
int procedureDefParsing(int nLayer)
{
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("IDENTIFY");
if (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
subProgramParsing(nLayer+1);
if (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
}
else {
parsing_error(NEED_SEMICOLON);
}
}
else {
parsing_error(NEED_SEMICOLON);
}
}
return 0;
}
int oneConstDefParsing(int nLayer)
{
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("IDENTIFY");
if (allWords[nAllIndex].eType == CONSTDEF) {
PARSING_PRINT("CONSTDEF");
if (allWords[nAllIndex].eType == INTEGER || allWords[nAllIndex].eType == FLOATNUM) {
PARSING_PRINT("NUMBER");
}
else {
parsing_error(NEED_NUMBER);
}
}
else {
parsing_error(NEED_CONSTDEF);
}
}
else {
parsing_error(NEED_IDENTIFY);
}
return 0;
}
int varDefParsing(int nLayer)
{
parsingPrintLn(nLayer, "ONE_VARIABLE_DEF", 0);
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("VARIABLE");
while (allWords[nAllIndex].eType == COMMA) {
PARSING_PRINT("COMMA");
parsingPrintLn(nLayer, "ONE_VARIABLE_DEF", 0);
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("VARIABLE");
}
else {
parsing_error(NEED_IDENTIFY);
}
}
}
else {
parsing_error(NEED_IDENTIFY);
}
if (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
}
return 0;
}
int parsing_analysis(int e)
{
nAllIndex = 0;
int nLayer = 0;
if (e) {
return 1;
}
subProgramParsing(nLayer);
if (allWords[nAllIndex].eType != PERIOD) {
parsing_error(BAD_END);
}
PARSING_PRINT("END_OF_PROGRAM");
printParsingError();
return 0;
}
int constDefParsing(int nLayer)
{
parsingPrintLn(nLayer, "ONE_CONSTENT_DEF", 0);
oneConstDefParsing(nLayer+1);
while (allWords[nAllIndex].eType == COMMA) {
PARSING_PRINT("COMMA");
parsingPrintLn(nLayer, "ONE_CONSTENT_DEF", 0);
oneConstDefParsing(nLayer+1);
}
if (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
}
else {
parsing_error(NEED_SEMICOLON);
}
return 0;
}
int conditionParsing(int nLayer)
{
parsingPrintLn(nLayer-1, "CONDITION", 0);
if (allWords[nAllIndex].eType == ODDSYM) {
PARSING_PRINT("ODD");
expressionParsing(nLayer+1);
}
else {
expressionParsing(nLayer+1);
if (ETYPE_IN_COMPARE(allWords[nAllIndex].eType)) {
PARSING_PRINT(symStringMap[allWords[nAllIndex].eType]);
expressionParsing(nLayer+1);
}
else {
parsing_error(NEED_COMPARE);
}
}
return 0;
}
/** \brief Parse a bt_cmdtype_t::UTMSG_PAYL received by the attached bt_swarm_full_t
*
* @return a tokeep for the bt_swarm_full_t
*/
bool bt_swarm_full_utmsg_t::parse_utmsg_payl(pkt_t &pkt) throw()
{
uint8_t recved_opcode;
bt_utmsgtype_t recved_utmsgtype;
// log to debug
KLOG_DBG("enter pkt="<< pkt);
// parse the bt_utmsgtype_t
try {
pkt >> recved_opcode;
}catch(serial_except_t &e){
return bt_err_t::ERROR;
}
// log to debug
KLOG_DBG("recved_opcode=" << (int)recved_opcode);
// convert the recved_opcode with the convtable_db_t
convtable_db_t::const_iterator iter;
for(iter = convtable_db.begin(); iter != convtable_db.end(); iter++){
const bt_utmsgtype_t & local_utmsgtype = iter->first;
const uint8_t & remote_opcode = iter->second;
// if the remote_opcode is not the recved_opcode, goto the next
if( recved_opcode != remote_opcode ) continue;
// set the recved_utmsgtype and leave the loop
recved_utmsgtype = local_utmsgtype;
break;
}
// if the recved_opcode has not been found in the convtable_db, return an error
if( iter == convtable_db.end() )
return parsing_error("received opcode not in convtable_db from a " + swarm_full->remote_peerid().peerid_progfull());
// if the recved_utmsgtype is a HANDSHAKE, parse it internally
if( recved_utmsgtype == bt_utmsgtype_t::HANDSHAKE ) return parse_handshake(pkt);
// sanity check - the cnx_vapi_db MUST contain the bt_utmsgtype_t too
DBG_ASSERT( cnx_vapi_db.find(recved_utmsgtype) != cnx_vapi_db.end() );
// send the packet to parse to the bt_utmsg_cnx_vapi_t
bt_utmsg_cnx_vapi_t * cnx_vapi = cnx_vapi_db.find(recved_utmsgtype)->second;
return cnx_vapi->parse_pkt(recved_utmsgtype, pkt);
}
// Scope
ScopeNode* Parser::parse_scope()
{
auto node = ast.store.alloc<ScopeNode>();
node->code = *token_iter;
std::vector<StatementNode*> statements;
// Open scope
if (token_iter->type != LPAREN) {
// Error
std::ostringstream msg;
msg << "Opening scope with wrong character: '" << token_iter->text << "'.";
parsing_error(*token_iter, msg.str());
}
++token_iter;
// Push this scope
fn_scope.push_scope();
while (true) {
skip_newlines();
// Close scope?
if (token_iter->type == RPAREN) {
++token_iter;
break;
}
// Should be an expression
else {
statements.push_back(parse_statement());
}
}
node->statements = ast.store.alloc_from_iters(statements.begin(), statements.end());
// Pop this scope
fn_scope.pop_scope();
node->code.text.set_end((token_iter - 1)->text.end());
return node;
}
// Statement
// Parses a single full statement. In general this means a declaration
// or an expression, but also includes things like return and break
// statements.
StatementNode* Parser::parse_statement()
{
switch (token_iter->type) {
// Return statement
case K_RETURN: {
return parse_return();
}
// Declaration
case K_CONST:
case K_VAL:
case K_VAR:
case K_FN:
case K_STRUCT:
case K_TYPE: {
return parse_declaration();
}
// Expression
case INTEGER_LIT:
case FLOAT_LIT:
case STRING_LIT:
case RAW_STRING_LIT:
case LPAREN:
case IDENTIFIER:
case OPERATOR:
case DOLLAR: {
return parse_expression();
}
default: {
// Error
std::ostringstream msg;
msg << "Unknown statement '" << token_iter->text << "'.";
parsing_error(*token_iter, msg.str());
throw 0; // Silence warnings about not returning, parsing_error throws anyway
}
}
}
/** \brief parse a bt_utmsgtype_t::HANDSHAKE
*
* @return a tokeep for the bt_swarm_full_t
*/
bool bt_swarm_full_utmsg_t::parse_handshake(pkt_t &pkt) throw()
{
bt_swarm_t * bt_swarm = swarm_full->get_swarm();
bt_swarm_utmsg_t * swarm_utmsg = bt_swarm->swarm_utmsg();
// log to debug
KLOG_DBG("enter pkt=" << pkt);
// convert the handshake message body to a dvar_t
dvar_t handshake_dvar = bencode_t::to_dvar(pkt.to_datum(datum_t::NOCOPY));
// if the handshake_dvar failed to parse the bencoded data, return an error
if( handshake_dvar.is_null() || handshake_dvar.type() != dvar_type_t::MAP )
return parsing_error("unable to find handshake_dvar as dvar_type_t::MAP");
// get the prog_version if available
if( handshake_dvar.map().contain("v", dvar_type_t::STRING) )
remote_prog_version = handshake_dvar.map()["v"].str().get();
// get the tcp_listen_port if available
if( handshake_dvar.map().contain("p", dvar_type_t::INTEGER) ){
uint16_t tcp_listen_port = handshake_dvar.map()["p"].integer().get();
// build the remote_tcp_listen_ipport from the connection remote_addr and listen port
remote_tcp_listen_ipport = swarm_full->remote_addr().get_peerid_vapi()->to_string()
+ std::string(":") + OSTREAMSTR(tcp_listen_port);
// if tcp_listen_port is 0, nullify remote_tcp_listen_ipport
if( tcp_listen_port == 0 ) remote_tcp_listen_ipport = ipport_addr_t();
}
// if the handshake_dvar doesnt contains the convtable map, return now
if( !handshake_dvar.map().contain("m", dvar_type_t::MAP) ) return true;
// create an alias on the convtable_dvar
const dvar_map_t &convtable_dvar = handshake_dvar.map()["m"].map();
// parse the convtable for each registered bt_utmsg_vapi_t
const bt_swarm_utmsg_t::utmsg_vapi_db_t &utmsg_vapi_db = swarm_utmsg->utmsg_vapi_db();
bt_swarm_utmsg_t::utmsg_vapi_db_t::const_iterator iter;
for(iter = utmsg_vapi_db.begin(); iter != utmsg_vapi_db.end(); iter++){
bt_utmsg_vapi_t * utmsg_vapi = *iter;
bt_utmsgtype_t bt_utmsgtype = utmsg_vapi->utmsgtype();
std::string utmsgstr = utmsg_vapi->utmsgstr();
// if this utmsg is not supported by remove peer, goto the next
if( !convtable_dvar.contain(utmsgstr, dvar_type_t::INTEGER) ) continue;
// get the opcode used by the remote peer
uint8_t opcode = convtable_dvar[utmsgstr].integer().get();
// if the new opcode is 0, DO NOT add it and goes to the next
// - if an opcode is 0, this mean disable the option
if( opcode == 0 ){
// if bt_utmsgtype_t is not in convtable_db, goto the next
// - this means a bug in the remote peer as it put a 0 opcode for
// an extension which has not yet been initialized
if( convtable_db.find(bt_utmsgtype) == convtable_db.end() ) continue;
// sanity check - the cnx_vapi_db MUST contain the bt_utmsgtype_t too
DBG_ASSERT( cnx_vapi_db.find(bt_utmsgtype) != cnx_vapi_db.end() );
// delete the cnx_vapi object
bt_utmsg_cnx_vapi_t * cnx_vapi = cnx_vapi_db.find(bt_utmsgtype)->second;
nipmem_delete cnx_vapi;
// remote this bt_utmsgtype_t from both database
cnx_vapi_db.erase(bt_utmsgtype);
convtable_db.erase(bt_utmsgtype);
continue;
}
// insert/update this bt_utmsgtype to the convtable_db
convtable_db[bt_utmsgtype] = opcode;
// create the bt_utmsg_cnx_vapi_t - if not yet initialized
// - it links itself to the bt_swarm_full_utmsg_t
if( cnx_vapi_db.find(bt_utmsgtype) == cnx_vapi_db.end() ){
bt_utmsg_cnx_vapi_t * cnx_vapi = utmsg_vapi->cnx_ctor(this);
DBG_ASSERT( cnx_vapi );
}
}
// return no error
return true;
}
int statementParsing(int nLayer)
{
switch(allWords[nAllIndex].eType) {
case IDENTIFY:
parsingPrintLn(nLayer-1, "ASSIGN_STATEMENT", 0);
PARSING_PRINT("IDENTIFY");
if (allWords[nAllIndex].eType == BECOMES) {
PARSING_PRINT("BECOMES");
expressionParsing(nLayer+1);
if (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
}
else {
parsing_error(NEED_SEMICOLON);
}
}
else {
parsing_error(NEED_BECOMES);
}
break;
case CALLSYM:
parsingPrintLn(nLayer-1, "CALL_STATEMENT", 0);
PARSING_PRINT("CALL");
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("IDENTIFY");
}
else {
parsing_error(NEED_IDENTIFY);
}
break;
case BEGINSYM:
parsingPrintLn(nLayer-1, "BEGIN_STATEMENT", 0);
PARSING_PRINT("BEGIN");
statementParsing(nLayer+1);
while (allWords[nAllIndex].eType == SEMICOLON) {
PARSING_PRINT("SEMICOLON");
statementParsing(nLayer+1);
}
if (allWords[nAllIndex].eType == ENDSYM) {
PARSING_PRINT("END");
}
else {
parsing_error(NEED_END);
}
break;
case IFSYM:
parsingPrintLn(nLayer-1, "IF_STATEMENT", 0);
PARSING_PRINT("IF");
if (allWords[nAllIndex].eType == LPAREN) {
PARSING_PRINT("LEFT_PAREN");
conditionParsing(nLayer+1);
if (allWords[nAllIndex].eType == RPAREN) {
PARSING_PRINT("RIGHT_PAREN");
statementParsing(nLayer+1);
if (allWords[nAllIndex].eType == ELSESYM) {
PARSING_PRINT("ELSE");
statementParsing(nLayer+1);
}
}
else {
parsing_error(NEED_RPAREN);
}
}
else {
parsing_error(NEED_LPAREN);
}
break;
case WHILESYM:
parsingPrintLn(nLayer-1, "WHILE_STATEMENT", 0);
PARSING_PRINT("WHILE");
conditionParsing(nLayer+1);
if (allWords[nAllIndex].eType == DOSYM) {
PARSING_PRINT("DO");
statementParsing(nLayer+1);
}
else {
parsing_error(NEED_DO);
}
break;
case READSYM:
parsingPrintLn(nLayer-1, "READ_STATEMENT", 0);
PARSING_PRINT("READ");
if (allWords[nAllIndex].eType == LPAREN) {
PARSING_PRINT("LEFT_PAREN");
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("IDENTIFY");
while (allWords[nAllIndex].eType == COMMA) {
PARSING_PRINT("COMMA");
if (allWords[nAllIndex].eType == IDENTIFY) {
PARSING_PRINT("IDENTIFY");
}
else {
parsing_error(NEED_IDENTIFY);
}
}
if (allWords[nAllIndex].eType == RPAREN) {
PARSING_PRINT("RIGHT_PAREN");
}
else {
parsing_error(NEED_RPAREN);
}
}
else {
parsing_error(NEED_IDENTIFY);
}
}
else {
parsing_error(NEED_LPAREN);
}
break;
case WRITESYM:
parsingPrintLn(nLayer-1, "WRITE_STATEMENT", 0);
PARSING_PRINT("WRITE");
if (allWords[nAllIndex].eType == LPAREN) {
PARSING_PRINT("LEFT_PAREN");
expressionParsing(nLayer+2);
while (allWords[nAllIndex].eType == COMMA) {
PARSING_PRINT("COMMA");
expressionParsing(nLayer+1);
}
if (allWords[nAllIndex].eType == RPAREN) {
PARSING_PRINT("RIGHT_PAREN");
}
else {
parsing_error(NEED_RPAREN);
}
}
else {
parsing_error(NEED_LPAREN);
}
break;
default:
break;
}
return 0;
}
sc::result ParseSectionHeaders::react( const EvNewData & ev )
{
(void) ev;
DEBUG_MSG(NOTIFY, "new data to offset: %d", availableOffset());
DEBUG_MSG(NOTIFY, "current offset : %d", currentOffset());
std::size_t numberOfSections = context<StreamingMelter>().numberOfSections();
if (current_ > numberOfSections + 1)
{
// we already processed all sections, send padding
if (availableOffset() > firstSectionDataOffset_) {
context<StreamingMelter>().complete( firstSectionDataOffset_ - currentOffset() );
return transit<ParseNativeSections>();
} else {
context<StreamingMelter>().complete( availableOffset() - currentOffset() );
return discard_event();
}
}
if (currentOffset() + sizeof(IMAGE_SECTION_HEADER) < availableOffset())
{
DEBUG_MSG(NOTIFY, "header %d", current_);
if (current_ < numberOfSections ) {
// original PE sections
PIMAGE_SECTION_HEADER header = (PIMAGE_SECTION_HEADER) context<StreamingMelter>().buffer()->data();
DEBUG_MSG(NOTIFY, "Section %s", string((PCHAR)header->Name));
if (header->PointerToRawData < firstSectionDataOffset_)
firstSectionDataOffset_ = header->PointerToRawData;
context<StreamingMelter>().addSection(header);
} else {
// added sections
if (current_ == (numberOfSections))
{
// dropper
DEBUG_MSG(NOTIFY, "Dropper section header.");
}
else if (current_ == (numberOfSections + 1))
{
// rebuilt resources
DEBUG_MSG(NOTIFY, "Rebuilt resources section header.");
}
else
{
// unknown ... we have a problem
throw parsing_error("Unknown non-original section found.");
}
}
context<StreamingMelter>().complete( sizeof(IMAGE_SECTION_HEADER) );
current_++;
}
DEBUG_MSG(NOTIFY, "number of sections: %d", context<StreamingMelter>().numberOfSections());
DEBUG_MSG(NOTIFY, "file alignment : %d", context<StreamingMelter>().fileAlignment());
// context<StreamingMelter>().complete( availableOffset() - currentOffset() );
return discard_event();
}
static bool_t
fpgnscan (FILE *fpgn, bool_t quiet, struct DATA *d)
{
#define MAX_MYLINE 40000
char myline[MAX_MYLINE];
const char *whitesep = "[White \"";
const char *whiteend = "\"]";
const char *blacksep = "[Black \"";
const char *blackend = "\"]";
const char *resulsep = "[Result \"";
const char *resulend = "\"]";
size_t whitesep_len, blacksep_len, resulsep_len;
char *x, *y;
struct pgn_result result;
long int line_counter = 0;
long int game_counter = 0;
int games_x_dot = 2000;
assert(d);
if (NULL == fpgn || NULL == d)
return FALSE;
if (!quiet)
printf("Loading data (%d games x dot): \n\n",games_x_dot); fflush(stdout);
pgn_result_reset (&result);
whitesep_len = strlen(whitesep);
blacksep_len = strlen(blacksep);
resulsep_len = strlen(resulsep);
while (NULL != fgets(myline, MAX_MYLINE, fpgn)) {
line_counter++;
if (NULL != (x = strstr (myline, whitesep))) {
x += whitesep_len;
if (NULL != (y = strstr (myline, whiteend))) {
*y = '\0';
strcpy (result.wtag, x);
result.wtag_present = TRUE;
} else {
parsing_error(line_counter);
}
}
if (NULL != (x = strstr (myline, blacksep))) {
x += blacksep_len;
if (NULL != (y = strstr (myline, blackend))) {
*y = '\0';
strcpy (result.btag, x);
result.btag_present = TRUE;
} else {
parsing_error(line_counter);
}
}
if (NULL != (x = strstr (myline, resulsep))) {
x += resulsep_len;
if (NULL != (y = strstr (myline, resulend))) {
*y = '\0';
result.result = res2int (x);
result.result_present = TRUE;
} else {
parsing_error(line_counter);
}
}
if (is_complete (&result)) {
if (!pgn_result_collect (&result, d)) {
fprintf (stderr, "\nCould not collect more games: Limits reached\n");
exit(EXIT_FAILURE);
}
pgn_result_reset (&result);
game_counter++;
if (!quiet) {
if ((game_counter%games_x_dot)==0) {
printf ("."); fflush(stdout);
}
if ((game_counter%100000)==0) {
printf ("| %4ldk\n", game_counter/1000); fflush(stdout);
}
}
}
} /* while */
if (!quiet) printf("|\n\n"); fflush(stdout);
return TRUE;
}