389 lines
12 KiB
C++
389 lines
12 KiB
C++
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <pcre.h>
|
|
#include <ctype.h> /* toupper() */
|
|
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <map>
|
|
|
|
#include "Parser.h"
|
|
#include "TokenDefinition.h"
|
|
#include "RuleDefinition.h"
|
|
#include "tmpl.h"
|
|
|
|
using namespace std;
|
|
|
|
Parser::Parser()
|
|
: m_classname("Parser"), m_namespace(""), m_extension("cc")
|
|
{
|
|
}
|
|
|
|
static void writeDefine(ostream & out,
|
|
const string & defname, const string & definition)
|
|
{
|
|
out << "#ifdef " << defname << endl;
|
|
out << "#undef " << defname << endl;
|
|
out << "#endif" << endl;
|
|
out << "#define " << defname << " " << definition << endl;
|
|
}
|
|
|
|
bool Parser::write(const string & fname)
|
|
{
|
|
if (m_tokens.size() < 1 || m_rules.size() < 1)
|
|
return false;
|
|
|
|
string header_fname = fname + ".h";
|
|
string body_fname = fname + "." + m_extension;
|
|
|
|
ofstream header(header_fname.c_str());
|
|
ofstream body(body_fname.c_str());
|
|
|
|
/* write the header */
|
|
if (m_namespace != "")
|
|
{
|
|
writeDefine(header, "I_NAMESPACE", m_namespace);
|
|
}
|
|
writeDefine(header, "I_CLASSNAME", m_classname);
|
|
setReplacement("token_list", buildTokenList());
|
|
header << endl;
|
|
writeTmpl(header, (char *) tmpl_parser_h, tmpl_parser_h_len);
|
|
|
|
/* write the body */
|
|
setReplacement("header_name",
|
|
new string(string("\"") + header_fname + "\""));
|
|
body << endl;
|
|
writeTmpl(body, (char *) tmpl_parser_cc, tmpl_parser_cc_len);
|
|
|
|
header.close();
|
|
body.close();
|
|
return true;
|
|
}
|
|
|
|
bool Parser::writeTmpl(std::ostream & out, char * dat, int len)
|
|
{
|
|
char * newline;
|
|
char * data = dat;
|
|
const char * errptr;
|
|
int erroffset;
|
|
data[len-1] = '\n';
|
|
const int ovec_size = 6;
|
|
int ovector[ovec_size];
|
|
pcre * replace = pcre_compile("{%(\\w+)%}", 0, &errptr, &erroffset, NULL);
|
|
while (data < (dat + len) && (newline = strstr(data, "\n")) != NULL)
|
|
{
|
|
if (pcre_exec(replace, NULL, data, newline - data,
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
if (ovector[0] > 0)
|
|
{
|
|
out.write(data, ovector[0]);
|
|
}
|
|
out << *getReplacement(string(data, ovector[2],
|
|
ovector[3] - ovector[2]));
|
|
if (ovector[1] < newline - data)
|
|
{
|
|
out.write(data + ovector[1], newline - data - ovector[1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
out.write(data, newline - data);
|
|
}
|
|
out << '\n';
|
|
data = newline + 1;
|
|
}
|
|
}
|
|
|
|
refptr<std::string> Parser::getReplacement(const std::string & name)
|
|
{
|
|
if (m_replacements.find(name) != m_replacements.end())
|
|
{
|
|
return m_replacements[name];
|
|
}
|
|
return new string("");
|
|
}
|
|
|
|
refptr<string> Parser::buildTokenList()
|
|
{
|
|
refptr<string> tokenlist = new string();
|
|
for (list<TokenDefinitionRef>::const_iterator t = m_tokens.begin();
|
|
t != m_tokens.end();
|
|
t++)
|
|
{
|
|
if (t != m_tokens.begin())
|
|
*tokenlist += " ";
|
|
*tokenlist += "{ \"" + (*t)->getName() + "\", \""
|
|
+ (*t)->getCString() + "\", "
|
|
+ ((*t)->getProcessFlag() ? "true" : "false") + " }";
|
|
if (({typeof(t) tmp = t; ++tmp;}) != m_tokens.end())
|
|
*tokenlist += ", \\\n";
|
|
}
|
|
return tokenlist;
|
|
}
|
|
|
|
bool Parser::parseInputFile(char * buff, int size)
|
|
{
|
|
typedef pcre * pcre_ptr;
|
|
enum { none, tokens, rules };
|
|
pcre_ptr empty, comment, section_name, token, rule,
|
|
data_begin, data_end, code_begin, code_end;
|
|
struct { pcre_ptr * re; const char * pattern; } exprs[] = {
|
|
{&empty, "^\\s*$"},
|
|
{&comment, "^\\s*#"},
|
|
{§ion_name, "^\\s*\\[([^\\]]+?)\\]\\s*$"},
|
|
{&token, "^\\s*" /* possible leading ws */
|
|
"([a-zA-Z_][a-zA-Z_0-9]*)" /* 1: token name */
|
|
"\\s+" /* required whitespace */
|
|
"((?:[^\\\\\\s]|\\\\.)+)"}, /* 2: token RE */
|
|
{&rule, "^\\s*(\\S+)\\s*:=(.*)$"},
|
|
{&data_begin, "^\\s*\\${"},
|
|
{&data_end, "\\$}"},
|
|
{&code_begin, "^\\s*%{"},
|
|
{&code_end, "%}"}
|
|
};
|
|
const int ovec_size = 3 * 10;
|
|
int ovector[ovec_size];
|
|
int lineno = 0;
|
|
char * newline;
|
|
char * input = buff;
|
|
string current_section_name;
|
|
map<string, int> sections;
|
|
sections["none"] = none;
|
|
sections["tokens"] = tokens;
|
|
sections["rules"] = rules;
|
|
int section = none;
|
|
string line;
|
|
bool append_line = false;
|
|
bool gathering_data = false;
|
|
bool gathering_code = false;
|
|
string gather;
|
|
bool continue_line = false;
|
|
TokenDefinitionRef current_token;
|
|
|
|
for (int i = 0; i < sizeof(exprs)/sizeof(exprs[0]); i++)
|
|
{
|
|
const char * errptr;
|
|
int erroffset;
|
|
*exprs[i].re = pcre_compile(exprs[i].pattern, 0,
|
|
&errptr, &erroffset, NULL);
|
|
if (*exprs[i].re == NULL)
|
|
{
|
|
cerr << "Error compiling regex '" << exprs[i].pattern <<
|
|
"': " << errptr << " at position " << erroffset << endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
if (continue_line)
|
|
{
|
|
continue_line = false;
|
|
}
|
|
else
|
|
{
|
|
if ((newline = strstr(input, "\n")) == NULL)
|
|
break;
|
|
int line_length = newline - input;
|
|
if (line_length >= 1 && newline[-1] == '\r')
|
|
{
|
|
newline[-1] = '\n';
|
|
line_length--;
|
|
}
|
|
lineno++;
|
|
|
|
if (append_line)
|
|
{
|
|
line += string(input, line_length);
|
|
}
|
|
else
|
|
{
|
|
line = string(input, line_length);
|
|
}
|
|
input = newline + 1; /* set up for next loop iteration */
|
|
}
|
|
|
|
if ( (pcre_exec(empty, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
|| (pcre_exec(comment, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
)
|
|
{
|
|
/* skip empty or comment lines */;
|
|
continue;
|
|
}
|
|
|
|
if (! (gathering_code || gathering_data) )
|
|
{
|
|
if (line.size() > 0 && line[line.size()-1] == '\\')
|
|
{
|
|
line[line.size()-1] = ' ';
|
|
append_line = true;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
append_line = false;
|
|
}
|
|
|
|
if (pcre_exec(section_name, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
current_section_name
|
|
= string(line, ovector[2], ovector[3] - ovector[2]);
|
|
if (sections.find(current_section_name) != sections.end())
|
|
{
|
|
section = sections[current_section_name];
|
|
}
|
|
else
|
|
{
|
|
cerr << "Unknown section name '" << current_section_name
|
|
<< "'!" << endl;
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
switch (section)
|
|
{
|
|
case none:
|
|
cerr << "Unrecognized input on line " << lineno << endl;
|
|
return false;
|
|
case tokens:
|
|
if (gathering_data)
|
|
{
|
|
if (pcre_exec(data_end, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
gather += string(line, 0, ovector[0]) + "\n";
|
|
gathering_data = false;
|
|
line = string(line, ovector[1]);
|
|
continue_line = true;
|
|
if (current_token.isNull())
|
|
{
|
|
cerr << "Data section with no corresponding "
|
|
"token definition on line " << lineno << endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
current_token->addData(gather);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gather += line + "\n";
|
|
}
|
|
continue;
|
|
}
|
|
else if (gathering_code)
|
|
{
|
|
if (pcre_exec(code_end, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
gather += string(line, 0, ovector[0]) + "\n";
|
|
gathering_code = false;
|
|
line = string(line, ovector[1]);
|
|
continue_line = true;
|
|
if (current_token.isNull())
|
|
{
|
|
cerr << "Code section with no corresponding "
|
|
"token definition on line " << lineno << endl;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
current_token->addCode(gather);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gather += line + "\n";
|
|
}
|
|
continue;
|
|
}
|
|
else if (pcre_exec(data_begin, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
gathering_data = true;
|
|
gather = "";
|
|
line = string(line, ovector[1]);
|
|
continue_line = true;
|
|
continue;
|
|
}
|
|
else if (pcre_exec(code_begin, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
gathering_code = true;
|
|
gather = "";
|
|
line = string(line, ovector[1]);
|
|
continue_line = true;
|
|
continue;
|
|
}
|
|
else if (pcre_exec(token, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
string name(line, ovector[2], ovector[3] - ovector[2]);
|
|
string definition(line,
|
|
ovector[4], ovector[5] - ovector[4]);
|
|
current_token = new TokenDefinition();
|
|
if (current_token->create(name, definition))
|
|
{
|
|
addTokenDefinition(current_token);
|
|
}
|
|
else
|
|
{
|
|
cerr << "Error in token definition ending on line "
|
|
<< lineno << endl;
|
|
return false;
|
|
}
|
|
line = string(line, ovector[1]);
|
|
continue_line = true;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
cerr << "Unrecognized input on line " << lineno << endl;
|
|
return false;
|
|
}
|
|
break;
|
|
case rules:
|
|
if (pcre_exec(rule, NULL, line.c_str(), line.size(),
|
|
0, 0, ovector, ovec_size) >= 0)
|
|
{
|
|
string name(line, ovector[2], ovector[3] - ovector[2]);
|
|
string definition(line,
|
|
ovector[4], ovector[5] - ovector[4]);
|
|
refptr<RuleDefinition> rd = new RuleDefinition();
|
|
if (rd->create(name, definition))
|
|
{
|
|
addRuleDefinition(rd);
|
|
}
|
|
else
|
|
{
|
|
cerr << "Error in rule definition ending on line "
|
|
<< lineno << endl;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cerr << "Unrecognized input on line " << lineno << endl;
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < sizeof(exprs)/sizeof(exprs[0]); i++)
|
|
{
|
|
pcre_free(*exprs[i].re);
|
|
}
|
|
|
|
return true;
|
|
}
|