// Выводим контекст
void word_output(FILE *fp, int N, int diff, int nquery) {
int state = INIT;
int ch = ' ';
// printf ("diff = %d\n",diff);
parser1(fp, N, &diff, false, &ch);
// printf ("ch = %c\n;",ch);
// printf ("diff = %d\n",diff);
diff = diff+N+nquery; // N+
parser1(fp, 0, &diff, true, &ch);
}
/*----------------------------------------------------------------------
| TestWhitespace
+---------------------------------------------------------------------*/
static void
TestWhitespace()
{
const char* xml =
"<doc>\r\n"
" <clean> </clean>\r\n"
" <dirty> A B </dirty>\r\n"
" <mixed>\r\n"
" A\r\n"
" <clean> </clean>\r\n"
" B\r\n"
" <dirty> A B </dirty>\r\n"
" C\r\n"
" </mixed>\r\n"
"</doc>\r\n";
const char* expect1 =
"<doc><clean/><dirty> A B </dirty><mixed>\n"
" A\n"
" <clean/>\n"
" B\n"
" <dirty> A B </dirty>\n"
" C\n"
" </mixed></doc>";
const char* expect2 =
"<doc>\n"
" <clean> </clean>\n"
" <dirty> A B </dirty>\n"
" <mixed>\n"
" A\n"
" <clean> </clean>\n"
" B\n"
" <dirty> A B </dirty>\n"
" C\n"
" </mixed>\n"
"</doc>";
NPT_XmlParser parser1(false); // ignore whitespace
NPT_XmlNode* root;
CHECK(NPT_SUCCEEDED(parser1.Parse(xml, root)));
CHECK(root);
NPT_XmlWriter writer;
NPT_MemoryStream buffer;
writer.Serialize(*root, buffer);
CHECK(buffer.GetBuffer() == NPT_DataBuffer(expect1, NPT_StringLength(expect1)));
delete root;
NPT_XmlParser parser2(true); // keep whitespace
CHECK(NPT_SUCCEEDED(parser2.Parse(xml, root)));
CHECK(root);
buffer.SetSize(0);
writer.Serialize(*root, buffer);
CHECK(buffer.GetBuffer() == NPT_DataBuffer(expect2, NPT_StringLength(expect2)));
delete root;
}
int main(void)
{
char input_dir_name0[128];
char input_dir_name1[128];
char* num0=new char[3];
char* num1=new char[3];
cout<<"select number(circuit A): ";
cin>>num0;
cout<<"select number(circuit B): ";
cin>>num1;
//sprintf(input_dir_name0,"./test file/cadContest2012_ECO_test%s/g1.v",num0);
sprintf(input_dir_name0, "./testfile/ex%s.v", num0);
netlist_parser parser1(input_dir_name0);
Node node1(parser1);
Wire wire1(parser1);
BddBuilder * bddBuilder0 = new BddBuilder();
bddBuilder0->construct(wire1.list(), node1.list());
bddBuilder0->dotDump();
VerilogMaker* Maker=new VerilogMaker(node1.list(),"g1");
Maker->Function();
sprintf(input_dir_name1, "./testfile/ex%s.v", num1);
netlist_parser parser2(input_dir_name1);
Node node2(parser2);
Wire wire2(parser2);
BddBuilder * bddBuilder1 = new BddBuilder(bddBuilder0);
bddBuilder1->constructB(bddBuilder0, wire2.list(), node2.list());
bddBuilder1->dotDump();
DdNode ** xordlist = bddBuilder0->getXORdNodeList(bddBuilder1);
bddBuilder0->dotDumpC(xordlist);
DdNode ** xordA = bddBuilder0->getXORdNodeList(xordlist);
//bddBuilder0->dotDumpC(xordA);
if(bddBuilder1->checkEquality(xordA) == 0)
printf("Equality check succeed.\n");
delete Maker;
delete []xordA;
delete []xordlist;
delete bddBuilder0;
delete bddBuilder1;
delete []num0;
delete []num1;
return 0;
}
bool Version::operator < (Version ver) {
//Version string could have a wide variety of formats. Use regex to choose specific comparison types.
regex reg1("(\\d+\\.?)+"); //a.b.c.d.e.f.... where the letters are all integers, and 'a' is the shortest possible match.
//boost::regex reg2("(\\d+\\.?)+([a-zA-Z\\-]+(\\d+\\.?)*)+"); //Matches a mix of letters and numbers - from "0.99.xx", "1.35Alpha2", "0.9.9MB8b1", "10.52EV-D", "1.62EV" to "10.0EV-D1.62EV".
if (regex_match(verString, reg1) && regex_match(ver.AsString(), reg1)) {
//First type: numbers separated by periods. If two versions have a different number of numbers, then the shorter should be padded
//with zeros. An arbitrary number of numbers should be supported.
istringstream parser1(verString);
istringstream parser2(ver.AsString());
while (parser1.good() || parser2.good()) {
//Check if each stringstream is OK for i/o before doing anything with it. If not, replace its extracted value with a 0.
uint32_t n1, n2;
if (parser1.good()) {
parser1 >> n1;
parser1.get();
} else
bool
ClParserParser::
parse()
{
ClParserOperatorType op = CL_PARSER_OP_NONE;
error_code_ = 0;
bool expression = false;
parse_.skipSpace();
while (! parse_.eof()) {
/* <expression> := <inline_operator> <expression>
<expression> := <expression> <inline_operator> */
if (parse_.isString("++") || parse_.isString("--")) {
if (parse_.isChar('+'))
ClParserStackMgrInst->push(CL_PARSER_OP_INCREMENT);
else
ClParserStackMgrInst->push(CL_PARSER_OP_DECREMENT);
ClParserStackMgrInst->toNext();
parse_.skipChars(2);
if (! expression) {
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
if (parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
}
expression = true;
}
/* <expression> := <unary_operator> <expression> */
else if (! expression && parse_.isOneOf(parser_unary_operator_chars)) {
if (! readUnaryOperator(&op)) {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
ClParserStackMgrInst->push(op);
ClParserStackMgrInst->toNext();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
if (parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
expression = true;
}
/* <expression> := '(' <expression> ')' */
else if (! expression && parse_.isChar('(')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser(this);
/* TODO: set end char */
if (! parser.parse() &&
parser.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser.getErrorCode();
goto fail;
}
parse_.skipSpace();
if (! parse_.isChar(')')) {
error_code_ = int(ClErr::MISSING_CLOSE_ROUND_BRACKET);
goto fail;
}
ClParserStackMgrInst->push(CL_PARSER_OP_CLOSE_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
expression = true;
}
/* <expression> := <numeric_value> */
else if (! expression && (parse_.isDigit() || parse_.isChar('.'))) {
ClParserValuePtr value;
if (! readNumericValue(value))
goto fail;
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
expression = true;
}
/* <expression> := <string_value> */
else if (! expression && parse_.isOneOf(parser_string_chars)) {
ClParserValuePtr value;
if (! readStringValue(value))
goto fail;
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
expression = true;
}
/* <expression> := <array_value> */
else if (! expression && parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
expression = true;
}
/* <expression> := <dict_value> */
else if (! expression && parse_.isString("{{")) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_DICT);
ClParserStackMgrInst->toNext();
parse_.skipChars(2);
if (! readDictionary())
goto fail;
expression = true;
}
/* <expression> := <list_value> */
else if (! expression && parse_.isChar('{')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_BRACE);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readList())
goto fail;
expression = true;
}
/* <expression> := <expression> <binary_operator> <expression> */
else if (expression && parse_.isOneOf(parser_binary_operator_chars)) {
if (! readBinaryOperator(&op))
goto fail;
ClParserStackMgrInst->push(op);
ClParserStackMgrInst->toNext();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
ClParserOperatorPtr op1 = ClParserOperatorMgrInst->getOperator(op);
if (! op1->isAssignment() && parser.isAssign()) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
goto fail;
}
if (op1->isAssignment())
assign_ = true;
expression = true;
}
/* <expression> := <expression> '?' <expression> ':' <expression> */
else if (expression && parse_.isChar('?')) {
ClParserStackMgrInst->push(CL_PARSER_OP_QUESTION_MARK);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser1(this);
if (! parser1.parse() &&
parser1.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser1.getErrorCode();
goto fail;
}
parse_.skipSpace();
if (! parse_.isChar(':')) {
error_code_ = int(ClErr::MISSING_COLON_OPERATOR);
goto fail;
}
ClParserStackMgrInst->push(CL_PARSER_OP_COLON);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser2(this);
if (! parser2.parse() &&
parser2.getErrorCode() != int(ClErr::INVALID_CHARACTER)) {
error_code_ = parser2.getErrorCode();
goto fail;
}
assign_ = parser1.isAssign() | parser2.isAssign();
expression = true;
}
/* <expression> := <expression> '[' <expression> ',' .... ']' */
else if (expression && parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
expression = true;
}
/* <expression> := <expression> ',' <expression> */
else if (expression && parse_.isChar(',')) {
ClParserStackMgrInst->push(CL_PARSER_OP_COMMA);
ClParserStackMgrInst->toNext();
parse_.skipChar();
ClParserParser parser(this);
if (! parser.parse()) {
error_code_ = parser.getErrorCode();
goto fail;
}
expression = true;
}
/* <expression> := <variable> */
/* <expression> := <variable> '.' <variable> '.' <...> */
/* <expression> := <variable> '[' <expression> ',' .... ']' */
/* <expression> := <function> '(' <expression> ',' .... ')' */
/* <expression> := <type> '(' <expression> ',' .... ')' */
else if (! expression &&
((! ClParserInst->getDollarPrefix() && parse_.isIdentifier()) ||
( ClParserInst->getDollarPrefix() &&
parse_.isChar('$') && parse_.isIdentifier(1)))) {
if (ClParserInst->getDollarPrefix() && parse_.isChar('$'))
parse_.skipChar();
ClParserIdentifierPtr identifier;
if (! readIdentifier(identifier))
goto fail;
const std::string &name = identifier->getName();
ClParserScopePtr scope = identifier->getScope();
parse_.skipSpace();
if (parse_.isChar('(')) {
ClParserInternFnPtr internfn;
if (scope.isValid())
internfn = scope->getInternFn(name);
else
internfn = ClParserInst->getInternFn(name);
if (internfn.isValid()) {
ClParserStackMgrInst->push(internfn);
ClParserStackMgrInst->toNext();
}
else {
ClParserUserFnPtr userfn;
if (scope.isValid())
userfn = scope->getUserFn(name);
else
userfn = ClParserInst->getUserFn(name);
if (userfn.isValid()) {
ClParserStackMgrInst->push(userfn);
ClParserStackMgrInst->toNext();
}
else {
ClParserTypePtr type = ClParserInst->getType(name);
if (type.isValid()) {
ClParserStackMgrInst->push(type);
ClParserStackMgrInst->toNext();
}
else {
identifier->setFunction();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
}
}
}
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_R_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArgList())
goto fail;
expression = true;
}
else {
identifier->setVariable();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
if (parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
parse_.skipSpace();
}
while (parse_.isChar('.')) {
identifier->setStructPart();
ClParserStackMgrInst->push(CL_PARSER_OP_DOT);
ClParserStackMgrInst->toNext();
parse_.skipChar();
parse_.skipSpace();
if (! readIdentifier(identifier)) {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
identifier->setVariable();
ClParserStackMgrInst->push(identifier);
ClParserStackMgrInst->toNext();
if (parse_.isChar('[')) {
ClParserStackMgrInst->push(CL_PARSER_OP_OPEN_S_BRACKET);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! readArray())
goto fail;
parse_.skipSpace();
}
}
expression = true;
}
}
/* <expression> := <string_value> */
else if (! expression && ClParserInst->getDollarPrefix()) {
std::string str;
parse_.readNonSpace(str);
ClParserValuePtr value = ClParserValueMgrInst->createValue(str);
ClParserStackMgrInst->push(value);
ClParserStackMgrInst->toNext();
parse_.skipSpace();
expression = true;
}
else {
error_code_ = int(ClErr::INVALID_CHARACTER);
goto fail;
}
parse_.skipSpace();
}
if (error_code_ == 0 && ! expression) {
error_code_ = int(ClErr::NULL_EXPRESSION);
goto fail;
}
if (parent_)
parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos());
return true;
fail:
if (parent_)
parent_->parse_.setPos(parent_->parse_.getPos() + parse_.getPos());
return false;
}
void IC_device::load_devices(const target_deviceRef device)
{
/// Load default resources
const char * builtin_technology = {
#include "Nangate.data"
};
int output_level = Param->getOption<int>(OPT_output_level);
///creating the datastructure representing the target technology
target = target_technology::create_technology(target_technology::CMOS, Param);
try
{
XMLDomParser parser("builtin_technology", builtin_technology);
parser.Exec();
if (parser)
{
//Walk the tree:
const xml_element* node = parser.get_document()->get_root_node(); //deleted by DomParser.
xload(device, node);
}
///update with specified device information
if (Param->isOption(OPT_target_device_file))
{
const auto file_name = Param->getOption<std::string>(OPT_target_device_file);
if (!boost::filesystem::exists(file_name))
{
THROW_ERROR("Device information file " + file_name + " does not exist!");
}
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(target device) Loading information about the target device from file \"" + file_name + "\"");
XMLDomParser parser1(file_name);
parser1.Exec();
if (parser1)
{
//Walk the tree:
const xml_element* node = parser1.get_document()->get_root_node(); //deleted by DomParser.
xload(device, node);
}
}
}
catch (const char * msg)
{
std::cerr << msg << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch (const std::string & msg)
{
std::cerr << msg << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch (const std::exception& ex)
{
std::cout << "Exception caught: " << ex.what() << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
catch ( ... )
{
std::cerr << "unknown exception" << std::endl;
THROW_ERROR("Error during parsing of technology file");
}
}
