]> granicus.if.org Git - graphviz/commitdiff
Add smyrna to main graphviz tree
authorellson <devnull@localhost>
Wed, 23 Jan 2008 20:52:43 +0000 (20:52 +0000)
committerellson <devnull@localhost>
Wed, 23 Jan 2008 20:52:43 +0000 (20:52 +0000)
lib/filter/Filter.c [new file with mode: 0644]
lib/filter/Makefile.am [new file with mode: 0644]
lib/filter/btree.c [new file with mode: 0644]
lib/filter/btree.h [new file with mode: 0644]
lib/filter/filter.h [new file with mode: 0644]

diff --git a/lib/filter/Filter.c b/lib/filter/Filter.c
new file mode 100644 (file)
index 0000000..c51da2a
--- /dev/null
@@ -0,0 +1,50 @@
+/* $Id$ $Revision$ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#include "filter.h"
+
+int clear_filter(tv_filter* f)
+{
+       delete_node(f->root);
+}
+
+int init_filters(tv_filters* filters)
+{
+       filters->filter_count=0;
+       filters->filters=0;
+}
+int add_filter_to_filters(tv_filters* filters,tv_filter* filter)
+{
+       filters->filters=realloc(filters->filters,sizeof(tv_filter*)*(filters->filter_count+1));
+       filters->filters[filters->filter_count]=filter;
+       filters->filter_count++;
+}
+int clear_filters(tv_filters* filters)
+{
+       //deep clear
+       int ind=0;
+       for (ind =0;ind < filters->filter_count ; ind ++)
+       {
+               clear_filter(filters->filters[ind]);
+               free(filters->filters[ind]);
+       }
+       filters->filter_count=0;
+}
+int union_filter(tv_filter* f1,tv_filter* f2)
+{
+               
+}
+int intersect_filter(tv_filter* f1,tv_filter* f2);
diff --git a/lib/filter/Makefile.am b/lib/filter/Makefile.am
new file mode 100644 (file)
index 0000000..82c2f7c
--- /dev/null
@@ -0,0 +1,23 @@
+# $Id$ $Revision$
+# ## Process this file with automake to produce Makefile.in
+#
+AM_CPPFLAGS = \
+       -I$(top_srcdir) \
+       -I$(top_srcdir)/lib/utilities \
+       -I$(top_srcdir)/lib/gui \
+       -I$(top_srcdir)/cmd/smyrna \
+       -I$(top_srcdir)/lib/xdot \
+       -I$(top_srcdir)/lib/cgraph \
+       -I$(top_srcdir)/lib/cdt \
+       $(GTK_CFLAGS) $(GTKGL_CFLAGS) $(GTKGLEXT_CFLAGS) $(GLADE_CFLAGS) $(FREETYPE2_CFLAGS)
+
+if WITH_SMYRNA
+noinst_HEADERS = \
+       btree.h filter.h 
+
+noinst_LTLIBRARIES = libfilter_C.la
+endif
+
+libfilter_C_la_SOURCES = \
+       Filter.c btree.c
+
diff --git a/lib/filter/btree.c b/lib/filter/btree.c
new file mode 100644 (file)
index 0000000..f68e57e
--- /dev/null
@@ -0,0 +1,369 @@
+/* $Id$ $Revision$ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#include "btree.h"
+#include "regex.h"
+#include "topview.h"
+btree_node* new_node(char* attribute,char* regex, float min, float max)
+{
+       btree_node* n;
+       n=malloc(sizeof(btree_node));
+       n->child_count=0;
+       n->childs=0;
+       n->rank=0;
+       n->attr_name=strdup(attribute);
+       n->regex=strdup(regex);
+       n->min=0;
+       n->max=0;
+       n->value=-1;
+       n->active=1;
+       return n;
+}
+int insert_node (btree_node* parent_n,btree_node* n)
+{
+       parent_n->child_count ++;
+       parent_n->childs=realloc(parent_n->childs,parent_n->child_count*sizeof(btree_node*));
+       parent_n->childs[parent_n->child_count-1]=n;
+       n->rank=parent_n->rank+1;
+       n->parent=parent_n;
+       return 1;
+}
+int delete_node_recursive(btree_node* n)
+{
+       int i=0;
+       int child_found=0;
+       //delete recursively
+       for (i=0;i < n->child_count;i++)
+       {
+               delete_node(n->childs[i]);
+       }
+       free(n->attr_name);
+       free(n->regex);
+       free(n->childs);
+
+       free(n);
+       return 1;
+}
+int delete_node(btree_node* n)
+{
+       int i=0;
+       int child_found=0;
+       //rmeove from parent's child list
+       if (n->parent)
+       {
+               n->parent->child_count--;
+               for (i=0;i < n->parent->child_count; i++)
+               {
+                       if (n->parent->childs[i]==n)
+                       {
+                               child_found=1;
+                       }
+                       if (child_found)
+                               n->parent->childs[i]=n->parent->childs[i+1];
+               }
+       }
+       n->parent->childs=realloc(n->parent->childs,sizeof(btree_node*)*n->parent->child_count);
+       delete_node_recursive(n);
+}
+
+btree_node* look_up_node_with_string(btree_node* n,char* string_to_lookup)
+{
+       int i=0;
+       btree_node* nn;
+       if (validate_lookup(n,string_to_lookup))
+               return n;
+       else
+       {
+               for (i=0;i < n->child_count;i++)
+               {
+                       nn=look_up_node_with_string(n->childs[i],string_to_lookup);
+                       if (nn)
+                               return nn;
+               }
+       }
+       return 0;
+
+}
+int validate_lookup(btree_node* n,char* string_to_lookup)      //it can be anything, in this case attr_name
+{
+       printf ("%s == %s\n",n->attr_name,string_to_lookup);
+       if (strcmp(n->attr_name,string_to_lookup)==0)
+               return 1;
+       return 0;
+}
+int print_tree(btree_node* root)
+{
+       static rank=0;
+       //printf("Node data:%s\n",
+}
+int print_children(btree_node* n)
+{
+       int i=0;
+       static int prev_rank=0;
+       if (n->node_type==2)
+               printf("      %*s=%s(%i)\n", n->rank*5+1,n->attr_name,n->regex,n->rank);
+       else
+               printf("%*s %c(%i)\n", n->rank*5+1,"",n->op,n->rank);
+       prev_rank=n->rank;
+       for (i=0;i < n->child_count;i++)
+       {
+               print_children(n->childs[i]);
+       }
+       return 1;
+
+}
+int sample_tree()
+{
+       btree_node* root;
+       btree_node* n;
+       btree_node* nn;
+       btree_node* kurbanlik;
+       root=new_node("A","R", 0, 0);
+       root->parent=0;
+       insert_node (root,new_node("B","R", 0, 0));
+       insert_node (root,new_node("C","R", 0, 0));
+
+       n=new_node("D","R", 0, 0);
+       kurbanlik=n;
+       insert_node (root,n);
+
+       nn=new_node("E","R", 0, 0);
+       insert_node (n,nn);
+       insert_node (n,new_node("X","R", 0, 0));
+       insert_node (n,new_node("Y","R", 0, 0));
+       insert_node (n,new_node("Z","R", 0, 0));
+       n=new_node("F","R", 0, 0);
+       insert_node (root,n);
+
+       print_children(root);
+       n=look_up_node_with_string(root,"F");
+       if(n)
+               printf("found   value-->%s \n",n->attr_name);
+
+       delete_node(kurbanlik);
+       print_children(root);
+    print_children(tree_from_filter_string("(()(())((())()))"));
+}
+
+btree_node* tree_from_filter_string(char* filter_string)
+{
+       btree_node* root;
+       btree_node* cursor;
+       btree_node* n;
+       btree_node* Nodes[2];
+       char buffer[512];
+       char* b_cursor=0;
+       char* c_cursor;
+       char op='\0';
+       char last_char;
+       int a=0;
+       root=new_node("R","", 0, 0);
+       cursor=root;
+       c_cursor=filter_string;
+       while (*c_cursor!='\0')
+       {
+               switch (*c_cursor)
+               {
+                       case '(' :
+                               n=new_node(".","", 0, 0);
+                               insert_node (cursor,n);
+                               last_char='(';
+                               cursor=n;
+                       break;
+                       case ')':
+                               last_char=')';
+                               cursor=cursor->parent;
+                       break;
+                       default:
+                               if (last_char=='(')
+                               {
+                                       b_cursor=buffer;
+                                       while (*c_cursor !=')')
+                                       {
+                                               *b_cursor=*c_cursor;
+                                               b_cursor++;
+                                               c_cursor++;
+                                       }
+                                       *b_cursor='\0';
+                                       evaluate_filter_atom(buffer,Nodes,&op);
+                                       if (Nodes[1] !=0)
+                                       {
+                                               insert_node(cursor,Nodes[0]);
+                                               insert_node(cursor,Nodes[1]);
+                                               cursor->op=op;
+                                       }
+                                       else    //only one expression in ()
+                                       {
+                                               insert_node(cursor->parent,Nodes[0]);
+                                               delete_node(cursor);
+                                               cursor=Nodes[0];
+                                       }
+
+
+                                       c_cursor--;
+                               }
+                               if (last_char == ')')
+                                       cursor->op=*c_cursor;
+                       break;
+               };
+               c_cursor ++;
+       }
+       return root;
+}
+int evaluate_filter_atom(char* string,btree_node* Nodes[],char* op)
+{
+       char* c_cursor;
+       char** attrs;
+       char buff_attr[512];
+       int c_buff_attr=0;
+       char buff_value[512];
+       int c_buff_value=0;
+       int attrs_count=0;
+       char** values;
+       int values_count=0;
+       int cc=0;
+       btree_node* n;
+       int kp_open=0;  //[ open
+       int qt_open=0; //" open?
+       int error=0;
+       int i=0;
+
+       attrs=0;
+       values=0;
+
+       c_cursor=string;
+       while ( *c_cursor !='\0')
+       {
+               if (kp_open)
+               {
+                       if ((*c_cursor == ',') || ((*c_cursor==']') && (!qt_open)))
+                       {
+                               attrs=realloc(attrs,(attrs_count+1)*sizeof(char*));
+                               attrs[attrs_count]=strdup(buff_attr);
+                               attrs_count++;
+                               values=realloc(values,(values_count+1)*sizeof(char*));
+                               values[values_count]=strdup(buff_value);
+                               values_count++;
+                               buff_attr[0]='/0';buff_value[0]='/0';
+                               c_buff_attr=0;c_buff_value=0;
+                       }
+                       if ( (*c_cursor != '=') &&(*c_cursor != ',')&&(*c_cursor != '\"'))
+                       {
+                               if(!qt_open && (*c_cursor != ']')&&(*c_cursor != '[')) 
+                               {
+                                       buff_attr[c_buff_attr]=*c_cursor;
+                                       buff_attr[c_buff_attr+1]='\0';
+                                       c_buff_attr++;
+                               }
+                               if (qt_open) 
+                               {
+                                       buff_value[c_buff_value]=*c_cursor;
+                                       buff_value[c_buff_value+1]='\0';
+                                       c_buff_value++;
+                               }
+                       }
+                       if ((*c_cursor == '\"')&&(qt_open))
+                               qt_open=0;
+                       else
+                               if ((*c_cursor == '\"')&&(!qt_open))
+                                       qt_open=1;
+                       if ((*c_cursor == ']') && !qt_open)
+                               kp_open=0;
+               }
+               if (*c_cursor == '[')
+                       kp_open=1;
+               if ( *c_cursor == '&')
+                       *op='&';
+               if ( *c_cursor == '|')
+                       *op='|';
+               c_cursor++;
+       }
+       
+       n=new_node(attrs[0],values[0],atof(values[1]),atof(values[2]));
+       n->node_type=2;
+       Nodes[0]=n;
+
+       if (attrs_count >5)
+       {
+               n=new_node(attrs[3],values[3],atof(values[4]),atof(values[5]));
+               n->node_type=2;
+               Nodes[1]=n;
+       }
+       else
+               Nodes[1]=0;
+    
+       for (i=0;i < attrs_count;i++)
+       {
+                       free(attrs[i]);
+                       free(values[i]);
+       }
+       free(attrs);
+       free(values);
+
+       return 1;
+}
+int  evaluate_expresions (tv_node* TV_Node,btree_node* n)
+{
+       regex_t preg;
+       char* data;
+       char buff1[1024];
+       char buff2[1024];
+       int i=0;
+       int ii=0;
+       if (!n)
+               return 1;
+       if(n->op=='&')
+               ii=1;
+       for (i=0;i < n->child_count;i++)
+       {
+               evaluate_expresions(TV_Node,n->childs[i]);
+                       if(n->op=='&')
+                               ii =ii && n->childs[i]->value;
+//                     if(n->op=='|')
+                       else
+                               ii =ii || n->childs[i]->value;
+
+       }
+       if (n->node_type==2)
+       {
+               data=agget(Topview.Nodes[TV_Node->index].Node,n->attr_name);
+               if (data)
+               {
+                               regcomp(&preg,n->regex,REG_NOSUB);
+                       if (regexec(&preg,data,0,0,0)==0)
+                               n->value=1;
+                       else
+                               n->value=0;
+               }
+               else
+                       n->value=1;     //no attribute return 1
+       }
+       else
+               n->value=ii;
+       regfree(&preg); 
+       return n->value;
+
+}
+
+
+
+
+
+
+
+
+
diff --git a/lib/filter/btree.h b/lib/filter/btree.h
new file mode 100644 (file)
index 0000000..84c1945
--- /dev/null
@@ -0,0 +1,32 @@
+/* $Id$ $Revision$ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef BTREE_H
+#define        BTREE_H
+#include "tvnodes.h"
+
+btree_node* new_node(char* attribute,char* regex, float min, float max);
+int insert_node (btree_node* parent_n,btree_node* n);
+int delete_node(btree_node* n);
+int delete_node_recursive(btree_node* n);      //internal function
+btree_node* look_up_node_with_string(btree_node* n,char* string_to_lookup);
+int validate_lookup(btree_node* n,char* string_to_lookup);     //it can be anything, in this case attr_name
+int print_tree(btree_node* root);
+int print_children(btree_node* n);
+btree_node* tree_from_filter_string(char* filter_string);
+int evaluate_filter_atom(char* string,btree_node* Nodes[],char* op);
+int evaluate_expresions(tv_node* Node,btree_node* root);
+#endif
diff --git a/lib/filter/filter.h b/lib/filter/filter.h
new file mode 100644 (file)
index 0000000..a39e82b
--- /dev/null
@@ -0,0 +1,34 @@
+/* $Id$ $Revision$ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef FILTER_H
+#define FILTER_H
+#include "btree.h"
+
+typedef struct _tv_filters
+{
+       tv_filter** filters;
+       int filter_count;
+}tv_filters;
+
+int clear_filter(tv_filter* f);
+int init_filters(tv_filters* filters);
+int add_filter_to_filters(tv_filters* filters,tv_filter* filter);
+int clear_filters(tv_filters* filters);
+int union_filter(tv_filter* f1,tv_filter* f2);
+int intersect_filter(tv_filter* f1,tv_filter* f2);
+
+#endif