📄 graphviz_graph_parser.cpp
字号:
#define GRAPHVIZ_DIRECTED 0
/* A Bison parser, made from graphviz_parser.yy
by GNU Bison version 1.28 */
#define YYBISON 1 /* Identify Bison output. */
#define yyparse bgl_undir_parse
#define yylex bgl_undir_lex
#define yyerror bgl_undir_error
#define yylval bgl_undir_lval
#define yychar bgl_undir_char
#define yydebug bgl_undir_debug
#define yynerrs bgl_undir_nerrs
#define GRAPH_T 257
#define NODE_T 258
#define EDGE_T 259
#define DIGRAPH_T 260
#define EDGEOP_T 261
#define SUBGRAPH_T 262
#define ID_T 263
//=======================================================================
// Copyright 2001 University of Notre Dame.
// Author: Lie-Quan Lee
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <boost/config.hpp>
#include <boost/graph/graphviz.hpp>
#if defined BOOST_NO_STRINGSTREAM
//#include <strstream> //We cannot use it since there is a bug in strstream
#include <stdlib.h>
#else
#include <sstream>
#endif
using std::free;
using std::malloc;
#ifndef GRAPHVIZ_DIRECTED
#error Need to define the GRAPHVIZ_DIRECTED macro to either 0 or 1
#endif
#if GRAPHVIZ_DIRECTED == 0
#define GRAPHVIZ_GRAPH boost::GraphvizGraph
#define yyrestart bgl_undir_restart
#else
#define GRAPHVIZ_GRAPH boost::GraphvizDigraph
#define yyrestart bgl_dir_restart
#endif
#define YYPARSE_PARAM g
#include "yystype.h"
extern void yyerror(char* str);
extern void yyrestart(FILE* str);
extern int yylex(YYSTYPE* lvalp);
enum AttrState {GRAPH_GRAPH_A, GRAPH_NODE_A, GRAPH_EDGE_A, NODE_A, EDGE_A};
using boost::GraphvizAttrList;
namespace graphviz {
typedef boost::graph_traits<GRAPHVIZ_GRAPH>::vertex_descriptor Vertex;
typedef boost::graph_traits<GRAPHVIZ_GRAPH>::edge_descriptor Edge;
typedef GRAPHVIZ_GRAPH Subgraph;
static Vertex current_vertex;
static Edge current_edge;
static Subgraph* current_graph = NULL;
static Subgraph* previous_graph = NULL;
static std::vector< std::pair<void*, bool>* > vlist;//store a list of rhs
static std::map<std::string,std::string> attributes;//store attributes temporarily
static AttrState attribute_state;
static std::map<std::string, Subgraph*> subgraphs; //store the names of subgraphs
static std::map<std::string, Vertex> nodes; //store the names of nodes
typedef std::map<std::string, Subgraph*>::iterator It;
typedef std::map<std::string, Vertex>::iterator Iter;
static const std::string& get_graph_name(const Subgraph& g) {
const boost::graph_property<Subgraph, boost::graph_name_t>::type&
name = boost::get_property(g, boost::graph_name);
return name;
}
static std::pair<Iter, bool> lookup(const std::string& name) {
//lookup in the top level
Iter it = nodes.find(name);
bool found = (it != nodes.end() );
return std::make_pair(it, found);
}
static Vertex add_name(const std::string& name, GRAPHVIZ_GRAPH& g) {
Vertex v = boost::add_vertex(*current_graph);
v = current_graph->local_to_global(v);
//set the label of vertex, it could be overwritten later.
boost::property_map<GRAPHVIZ_GRAPH, boost::vertex_attribute_t>::type
va = boost::get(boost::vertex_attribute, g);
va[v]["label"] = name;
//add v into the map so next time we will find it.
nodes[name] = v;
return v;
}
static std::pair<It, bool> lookup_subgraph(const std::string& name) {
It it = subgraphs.find(name);
bool found = (it != subgraphs.end() );
return std::make_pair(it, found);
}
static Subgraph* create_subgraph(const std::string& name) {
Subgraph* new_subgraph = &(current_graph->create_subgraph());
subgraphs[name] = new_subgraph;
return new_subgraph;
}
static void set_attribute(GraphvizAttrList& p,
const GraphvizAttrList& attr) {
GraphvizAttrList::const_iterator i, end;
for ( i=attr.begin(), end=attr.end(); i!=end; ++i)
p[i->first]=i->second;
}
static void set_attribute(Subgraph& g,
AttrState s, bool clear_attribute = true) {
typedef Subgraph Graph;
switch ( s ) {
case GRAPH_GRAPH_A:
{
boost::graph_property<Graph, boost::graph_graph_attribute_t>::type&
gga = boost::get_property(g, boost::graph_graph_attribute);
set_attribute(gga, attributes);
}
break;
case GRAPH_NODE_A:
{
boost::graph_property<Graph, boost::graph_vertex_attribute_t>::type&
gna = boost::get_property(g, boost::graph_vertex_attribute);
set_attribute(gna, attributes);
}
break;
case GRAPH_EDGE_A:
{
boost::graph_property<Graph, boost::graph_edge_attribute_t>::type&
gea = boost::get_property(g, boost::graph_edge_attribute);
set_attribute(gea, attributes);
}
break;
case NODE_A:
{
boost::property_map<Graph, boost::vertex_attribute_t>::type
va = boost::get(boost::vertex_attribute, g); //va[v]
set_attribute(va[current_vertex], attributes);
}
break;
case EDGE_A:
{
boost::property_map<Graph, boost::edge_attribute_t>::type
ea = boost::get(boost::edge_attribute, g); //ea[e]
set_attribute(ea[current_edge], attributes);
}
break;
}
if ( clear_attribute )
attributes.clear();
}
static void add_edges(const Vertex& u,
const Vertex& v, GRAPHVIZ_GRAPH& g) {
graphviz::current_edge = boost::add_edge(u, v, g).first;
graphviz::set_attribute(g, EDGE_A, false);
}
static void add_edges(Subgraph* G1, Subgraph* G2,
GRAPHVIZ_GRAPH& g) {
boost::graph_traits<Subgraph>::vertex_iterator i, j, m, n;
for ( boost::tie(i, j) = boost::vertices(*G1); i != j; ++i) {
for ( boost::tie(m, n) = boost::vertices(*G2); m != n; ++m) {
graphviz::add_edges(G1->local_to_global(*i),
G2->local_to_global(*m), g);
}
}
}
static void add_edges(Subgraph* G, const Vertex& v, GRAPHVIZ_GRAPH& g) {
boost::graph_traits<Subgraph>::vertex_iterator i, j;
for ( boost::tie(i, j) = boost::vertices(*G); i != j; ++i) {
graphviz::add_edges(G->local_to_global(*i), v, g);
}
}
static void add_edges(const Vertex& u, Subgraph* G, GRAPHVIZ_GRAPH& g) {
boost::graph_traits<Subgraph>::vertex_iterator i, j;
for ( boost::tie(i, j) = boost::vertices(*G); i != j; ++i) {
graphviz::add_edges(u, G->local_to_global(*i), g);
}
}
static std::string random_string() {
static int i=0;
#if defined BOOST_NO_STRINGSTREAM
//std::strstream out;
char buf[256];
sprintf(buf, "default%i\0", i);
++i;
return std::string(buf);
#else
std::stringstream out;
out << "default" << i;
++i;
return out.str();
#endif
}
static void set_graph_name(const std::string& name) {
boost::graph_property<Subgraph, boost::graph_name_t>::type&
gea = boost::get_property(*current_graph, boost::graph_name);
gea = name;
}
} //namespace detail {
#include <stdio.h>
#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif
#define YYFINAL 67
#define YYFLAG -32768
#define YYNTBASE 18
#define YYTRANSLATE(x) ((unsigned)(x) <= 263 ? yytranslate[x] : 46)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 16, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 17, 12, 2,
15, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
13, 2, 14, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 10, 2, 11, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
7, 8, 9
};
#if YYDEBUG != 0
static const short yyprhs[] = { 0,
0, 3, 7, 10, 12, 14, 16, 17, 20, 22,
24, 25, 28, 31, 36, 38, 40, 42, 44, 45,
47, 51, 55, 57, 59, 60, 62, 64, 66, 68,
70, 73, 77, 78, 80, 82, 86, 90, 93, 95,
98, 100, 102, 105, 106, 109, 112, 114
};
static const short yyrhs[] = { 20,
19, 0, 10, 23, 11, 0, 21, 22, 0, 3,
0, 6, 0, 9, 0, 0, 23, 25, 0, 25,
0, 12, 0, 0, 26, 24, 0, 32, 24, 0,
27, 13, 28, 14, 0, 3, 0, 4, 0, 5,
0, 29, 0, 0, 30, 0, 29, 31, 30, 0,
9, 15, 9, 0, 12, 0, 16, 0, 0, 34,
0, 38, 0, 33, 0, 42, 0, 30, 0, 36,
35, 0, 13, 28, 14, 0, 0, 9, 0, 37,
0, 9, 17, 9, 0, 41, 40, 35, 0, 7,
41, 0, 39, 0, 40, 39, 0, 36, 0, 42,
0, 44, 45, 0, 0, 43, 19, 0, 8, 9,
0, 19, 0, 0
};
#endif
#if YYDEBUG != 0
static const short yyrline[] = { 0,
239, 242, 245, 259, 259, 262, 262, 265, 265, 268,
268, 271, 271, 275, 282, 283, 284, 287, 287, 290,
290, 293, 303, 303, 303, 306, 306, 306, 306, 309,
317, 328, 328, 331, 346, 349, 368, 413, 417, 417,
420, 429, 440, 447, 457, 462, 483, 483
};
#endif
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
static const char * const yytname[] = { "$","error","$undefined.","GRAPH_T",
"NODE_T","EDGE_T","DIGRAPH_T","EDGEOP_T","SUBGRAPH_T","ID_T","'{'","'}'","';'",
"'['","']'","'='","','","':'","graph","graph_body","graph_header","graph_type",
"graph_name","stmt_list","semicolon","stmt","attr_stmt","attr_header","attr_list",
"nonempty_attr_list","attr","attr_separator","compound_stmt","graph_attr","node_stmt",
"opt_attr","node_id","node_port","edge_stmt","edge_rhs_one","edge_rhs","edge_endpoint",
"subgraph","@1","subgraph_header","opt_graph_body", NULL
};
#endif
static const short yyr1[] = { 0,
18, 19, 20, 21, 21, 22, 22, 23, 23, 24,
24, 25, 25, 26, 27, 27, 27, 28, 28, 29,
29, 30, 31, 31, 31, 32, 32, 32, 32, 33,
34, 35, 35, 36, 36, 37, 38, 39, 40, 40,
41, 41, 42, 43, 42, 44, 45, 45
};
static const short yyr2[] = { 0,
2, 3, 2, 1, 1, 1, 0, 2, 1, 1,
0, 2, 2, 4, 1, 1, 1, 1, 0, 1,
3, 3, 1, 1, 0, 1, 1, 1, 1, 1,
2, 3, 0, 1, 1, 3, 3, 2, 1, 2,
1, 1, 2, 0, 2, 2, 1, 0
};
static const short yydefact[] = { 0,
4, 5, 0, 7, 44, 1, 6, 3, 15, 16,
17, 0, 34, 44, 9, 11, 0, 30, 11, 28,
26, 33, 35, 27, 0, 29, 0, 48, 46, 0,
0, 2, 8, 10, 12, 19, 13, 19, 31, 44,
39, 33, 45, 47, 43, 22, 36, 0, 0, 18,
20, 0, 34, 41, 38, 42, 37, 40, 14, 23,
24, 0, 32, 21, 0, 0, 0
};
static const short yydefgoto[] = { 65,
6, 3, 4, 8, 14, 35, 15, 16, 17, 49,
50, 18, 62, 19, 20, 21, 39, 22, 23, 24,
41, 42, 25, 26, 27, 28, 45
};
static const short yypact[] = { 19,
-32768,-32768, -9, 9, 12,-32768,-32768,-32768,-32768,-32768,
-32768, 18, 13, 0,-32768, 17, 20,-32768, 17,-32768,
-32768, -1,-32768,-32768, 27, 28, -9, -9,-32768, 29,
30,-32768,-32768,-32768,-32768, 31,-32768, 31,-32768, 15,
-32768, 6,-32768,-32768,-32768,-32768,-32768, 21, 23, -2,
-32768, 32, 24,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768, 31,-32768,-32768, 42, 43,-32768
};
static const short yypgoto[] = {-32768,
4,-32768,-32768,-32768,-32768, 25, 33,-32768,-32768, 7,
-32768, -36,-32768,-32768,-32768,-32768, 8, 11,-32768,-32768,
10,-32768, 14, 16,-32768,-32768,-32768
};
#define YYLAST 56
static const short yytable[] = { 51,
5, 51, 9, 10, 11, -41, -25, 12, 13, 60,
32, 38, 40, 61, 9, 10, 11, 7, 38, 12,
13, 1, 12, 53, 2, 64, 29, 30, 34, 31,
43, 44, 36, 40, -42, 30, 59, 46, 47, 48,
31, 66, 67, 37, 52, 63, 33, 0, 0, 57,
54, 58, 0, 55, 0, 56
};
static const short yycheck[] = { 36,
10, 38, 3, 4, 5, 7, 9, 8, 9, 12,
11, 13, 7, 16, 3, 4, 5, 9, 13, 8,
9, 3, 8, 9, 6, 62, 9, 15, 12, 17,
27, 28, 13, 7, 7, 15, 14, 9, 9, 9,
17, 0, 0, 19, 38, 14, 14, -1, -1, 42,
40, 42, -1, 40, -1, 40
};
#define YYPURE 1
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
/* This file comes from bison-1.28. */
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
#ifndef YYSTACK_USE_ALLOCA
#ifdef alloca
#define YYSTACK_USE_ALLOCA
#else /* alloca not defined */
#ifdef __GNUC__
#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
#define YYSTACK_USE_ALLOCA
#include <alloca.h>
#else /* not sparc */
/* We think this test detects Watcom and Microsoft C. */
/* This used to test MSDOS, but that is a bad idea
since that symbol is in the user namespace. */
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
#if 0 /* No need for malloc.h, which pollutes the namespace;
instead, just don't use alloca. */
#include <malloc.h>
#endif
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
/* I don't know what this was needed for, but it pollutes the namespace.
So I turned it off. rms, 2 May 1997. */
/* #include <malloc.h> */
#pragma alloca
#define YYSTACK_USE_ALLOCA
#else /* not MSDOS, or __TURBOC__, or _AIX */
#if 0
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
and on HPUX 10. Eventually we can turn this on. */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -