Remove all malloc and new

Author: james-d-mitchell

.gitignore

@@ -1,3 +1,4 @@
 *.o
 bliss
 *.a
+*.lo

bignum.hh

@@ -4,9 +4,9 @@
 /*
   Copyright (c) 2003-2015 Tommi Junttila
   Released under the GNU Lesser General Public License version 3.
-  
+
   This file is part of bliss.
-  
+
   bliss is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation, version 3 of the License.
@@ -28,7 +28,7 @@
 #include <cstdio>
 #include "defs.hh"
 
-namespace bliss {
+namespace bliss_digraphs {
 
 /**
  * \brief A very simple class for big integers (or approximation of them).
@@ -100,6 +100,6 @@ public:
 
 #endif
 
-} //namespace bliss
+} //namespace bliss_digraphs
 
 #endif

bliss.cc

@@ -10,9 +10,9 @@
 /*
   Copyright (c) 2003-2015 Tommi Junttila
   Released under the GNU Lesser General Public License version 3.
-  
+
   This file is part of bliss.
-  
+
   bliss is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation, version 3 of the License.
@@ -52,13 +52,14 @@ static void
 usage(FILE* const fp, const char* argv0)
 {
   const char* program_name;
-  
+
   program_name = rindex(argv0, '/');
-  
+
   if(program_name) program_name++;
-  else program_name = argv0;  
+  else program_name = argv0;
   if(!program_name or *program_name == 0) program_name = "bliss";
 
+  fprintf(fp, "bliss version %s (compiled "__DATE__")\n", bliss_digraphs::version);
   fprintf(fp, "Copyright 2003-2015 Tommi Junttila\n");
   fprintf(fp,
 "\n"
@@ -119,7 +120,7 @@ parse_options(const int argc, const char** argv)
 	}
       else if(strcmp(argv[i], "-version") == 0)
 	{
-	  fprintf(stdout, "bliss version %s\n", bliss::version);
+	  fprintf(stdout, "bliss version %s\n", bliss_digraphs::version);
 	  exit(0);
 	}
       else if(strcmp(argv[i], "-help") == 0)
@@ -160,7 +161,7 @@ report_aut(void* param, const unsigned int n, const unsigned int* aut)
 {
   assert(param);
   fprintf((FILE*)param, "Generator: ");
-  bliss::print_permutation((FILE*)param, n, aut, 1);
+  bliss_digraphs::print_permutation((FILE*)param, n, aut, 1);
   fprintf((FILE*)param, "\n");
 }
 
@@ -182,45 +183,45 @@ _fatal(const char* fmt, ...)
 int
 main(const int argc, const char** argv)
 {
-  bliss::Timer timer;
-  bliss::AbstractGraph* g = 0;
+  bliss_digraphs::Timer timer;
+  bliss_digraphs::AbstractGraph* g = 0;
 
   parse_options(argc, argv);
-  
+
   /* Parse splitting heuristics */
-  bliss::Digraph::SplittingHeuristic shs_directed = bliss::Digraph::shs_fsm;
-  bliss::Graph::SplittingHeuristic shs_undirected = bliss::Graph::shs_fsm;
+  bliss_digraphs::Digraph::SplittingHeuristic shs_directed = bliss_digraphs::Digraph::shs_fsm;
+  bliss_digraphs::Graph::SplittingHeuristic shs_undirected = bliss_digraphs::Graph::shs_fsm;
   if(opt_directed)
     {
       if(strcmp(opt_splitting_heuristics, "f") == 0)
-	shs_directed = bliss::Digraph::shs_f;
+	shs_directed = bliss_digraphs::Digraph::shs_f;
       else if(strcmp(opt_splitting_heuristics, "fs") == 0)
-	shs_directed = bliss::Digraph::shs_fs;
+	shs_directed = bliss_digraphs::Digraph::shs_fs;
       else if(strcmp(opt_splitting_heuristics, "fl") == 0)
-	shs_directed = bliss::Digraph::shs_fl;
+	shs_directed = bliss_digraphs::Digraph::shs_fl;
       else if(strcmp(opt_splitting_heuristics, "fm") == 0)
-	shs_directed = bliss::Digraph::shs_fm;
+	shs_directed = bliss_digraphs::Digraph::shs_fm;
       else if(strcmp(opt_splitting_heuristics, "fsm") == 0)
-	shs_directed = bliss::Digraph::shs_fsm;
+	shs_directed = bliss_digraphs::Digraph::shs_fsm;
       else if(strcmp(opt_splitting_heuristics, "flm") == 0)
-	shs_directed = bliss::Digraph::shs_flm;
+	shs_directed = bliss_digraphs::Digraph::shs_flm;
       else
 	_fatal("Illegal option -sh=%s, aborting", opt_splitting_heuristics);
     }
   else
     {
       if(strcmp(opt_splitting_heuristics, "f") == 0)
-	shs_undirected = bliss::Graph::shs_f;
+	shs_undirected = bliss_digraphs::Graph::shs_f;
       else if(strcmp(opt_splitting_heuristics, "fs") == 0)
-	shs_undirected = bliss::Graph::shs_fs;
+	shs_undirected = bliss_digraphs::Graph::shs_fs;
       else if(strcmp(opt_splitting_heuristics, "fl") == 0)
-	shs_undirected = bliss::Graph::shs_fl;
+	shs_undirected = bliss_digraphs::Graph::shs_fl;
       else if(strcmp(opt_splitting_heuristics, "fm") == 0)
-	shs_undirected = bliss::Graph::shs_fm;
+	shs_undirected = bliss_digraphs::Graph::shs_fm;
       else if(strcmp(opt_splitting_heuristics, "fsm") == 0)
-	shs_undirected = bliss::Graph::shs_fsm;
+	shs_undirected = bliss_digraphs::Graph::shs_fsm;
       else if(strcmp(opt_splitting_heuristics, "flm") == 0)
-	shs_undirected = bliss::Graph::shs_flm;
+	shs_undirected = bliss_digraphs::Graph::shs_flm;
       else
 	_fatal("Illegal option -sh=%s, aborting", opt_splitting_heuristics);
     }
@@ -238,34 +239,34 @@ main(const int argc, const char** argv)
   if(opt_directed)
     {
       /* Read directed graph in the DIMACS format */
-      g = bliss::Digraph::read_dimacs(infile);
+      g = bliss_digraphs::Digraph::read_dimacs(infile);
     }
   else
     {
       /* Read undirected graph in the DIMACS format */
-      g = bliss::Graph::read_dimacs(infile);
+      g = bliss_digraphs::Graph::read_dimacs(infile);
     }
-  
+
   if(infile != stdin)
     fclose(infile);
 
   if(!g)
     _fatal("Failed to read the graph, aborting");
-  
+
   if(verbose_level >= 2)
     {
       fprintf(verbstr, "Graph read in %.2f seconds\n", timer.get_duration());
       fflush(verbstr);
     }
 
 
-  bliss::Stats stats;
+  bliss_digraphs::Stats stats;
 
   /* Set splitting heuristics and verbose level */
   if(opt_directed)
-    ((bliss::Digraph*)g)->set_splitting_heuristic(shs_directed);
+    ((bliss_digraphs::Digraph*)g)->set_splitting_heuristic(shs_directed);
   else
-    ((bliss::Graph*)g)->set_splitting_heuristic(shs_undirected);
+    ((bliss_digraphs::Graph*)g)->set_splitting_heuristic(shs_undirected);
   g->set_verbose_level(verbose_level);
   g->set_verbose_file(verbstr);
   g->set_failure_recording(opt_use_failure_recording);
@@ -283,12 +284,12 @@ main(const int argc, const char** argv)
       const unsigned int* cl = g->canonical_form(stats, &report_aut, stdout);
 
       fprintf(stdout, "Canonical labeling: ");
-      bliss::print_permutation(stdout, g->get_nof_vertices(), cl, 1);
+      bliss_digraphs::print_permutation(stdout, g->get_nof_vertices(), cl, 1);
       fprintf(stdout, "\n");
 
       if(opt_output_can_file)
 	{
-	  bliss::AbstractGraph* cf = g->permute(cl);
+	  bliss_digraphs::AbstractGraph* cf = g->permute(cl);
 	  FILE* const fp = fopen(opt_output_can_file, "w");
 	  if(!fp)
 	    _fatal("Cannot open '%s' for outputting the canonical form, aborting", opt_output_can_file);

bliss_C.cc

@@ -25,42 +25,59 @@ extern "C" {
   along with bliss.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-struct bliss_graph_struct {
-  bliss::Graph* g;
+struct bliss_digraphs_graph_struct {
+  bliss_digraphs::Graph* g;
 };
 
 extern "C"
-BlissGraph *bliss_new(const unsigned int n)
+BlissGraph *bliss_digraphs_new(const unsigned int n)
 {
-  BlissGraph *graph = new bliss_graph_struct;
+  BlissGraph *graph = new bliss_digraphs_graph_struct;
   assert(graph);
-  graph->g = new bliss::Graph(n);
+  graph->g = new bliss_digraphs::Graph(n);
   assert(graph->g);
   return graph;
 }
 
 extern "C"
-BlissGraph *bliss_read_dimacs(FILE *fp)
+BlissGraph *bliss_digraphs_read_dimacs(FILE *fp)
 {
-  bliss::Graph *g = bliss::Graph::read_dimacs(fp);
+  bliss_digraphs::Graph *g = bliss_digraphs::Graph::read_dimacs(fp);
   if(!g)
     return 0;
-  BlissGraph *graph = new bliss_graph_struct;
+  BlissGraph *graph = new bliss_digraphs_graph_struct;
   assert(graph);
   graph->g = g;
   return graph;
 }
 
 extern "C"
-void bliss_write_dimacs(BlissGraph *graph, FILE *fp)
+void bliss_digraphs_write_dimacs(BlissGraph *graph, FILE *fp)
 {
   assert(graph);
   assert(graph->g);
   graph->g->write_dimacs(fp);
 }
 
 extern "C"
-void bliss_release(BlissGraph *graph)
+void bliss_digraphs_clear(BlissGraph *graph)
+{
+  assert(graph);
+  assert(graph->g);
+  graph->g->clear();
+}
+
+  extern "C"
+void bliss_digraphs_change_color(BlissGraph* graph, const unsigned int vertex, const unsigned int color)
+{
+  assert(graph);
+  assert(graph->g);
+  graph->g->change_color(vertex, color);
+}
+
+
+extern "C"
+void bliss_digraphs_release(BlissGraph *graph)
 {
   assert(graph);
   assert(graph->g);
@@ -69,39 +86,39 @@ void bliss_release(BlissGraph *graph)
 }
 
 extern "C"
-void bliss_write_dot(BlissGraph *graph, FILE *fp)
+void bliss_digraphs_write_dot(BlissGraph *graph, FILE *fp)
 {
   assert(graph);
   assert(graph->g);
   graph->g->write_dot(fp);
 }
 
 extern "C"
-unsigned int bliss_get_nof_vertices(BlissGraph *graph)
+unsigned int bliss_digraphs_get_nof_vertices(BlissGraph *graph)
 {
   assert(graph);
   assert(graph->g);
   return graph->g->get_nof_vertices();
 }
 
 extern "C"
-unsigned int bliss_add_vertex(BlissGraph *graph, unsigned int l)
+unsigned int bliss_digraphs_add_vertex(BlissGraph *graph, unsigned int l)
 {
   assert(graph);
   assert(graph->g);
   return graph->g->add_vertex(l);
 }
 
 extern "C"
-void bliss_add_edge(BlissGraph *graph, unsigned int v1, unsigned int v2)
+void bliss_digraphs_add_edge(BlissGraph *graph, unsigned int v1, unsigned int v2)
 {
   assert(graph);
   assert(graph->g);
   graph->g->add_edge(v1, v2);
 }
 
 extern "C"
-int bliss_cmp(BlissGraph *graph1, BlissGraph *graph2)
+int bliss_digraphs_cmp(BlissGraph *graph1, BlissGraph *graph2)
 {
   assert(graph1);
   assert(graph1->g);
@@ -111,35 +128,35 @@ int bliss_cmp(BlissGraph *graph1, BlissGraph *graph2)
 }
 
 extern "C"
-unsigned int bliss_hash(BlissGraph *graph)
+unsigned int bliss_digraphs_hash(BlissGraph *graph)
 {
   assert(graph);
   assert(graph->g);
   return graph->g->get_hash();
 }
 
 extern "C"
-BlissGraph *bliss_permute(BlissGraph *graph, const unsigned int *perm)
+BlissGraph *bliss_digraphs_permute(BlissGraph *graph, const unsigned int *perm)
 {
   assert(graph);
   assert(graph->g);
   assert(graph->g->get_nof_vertices() == 0 || perm);
-  BlissGraph *permuted_graph = new bliss_graph_struct;
+  BlissGraph *permuted_graph = new bliss_digraphs_graph_struct;
   assert(permuted_graph);
   permuted_graph->g = graph->g->permute(perm);
   return permuted_graph;
 }
 
 extern "C"
 void
-bliss_find_automorphisms(BlissGraph *graph,
+bliss_digraphs_find_automorphisms(BlissGraph *graph,
 			 void (*hook)(void *user_param,
 				      unsigned int n,
 				      const unsigned int *aut),
 			 void *hook_user_param,
 			 BlissStats *stats)
 {
-  bliss::Stats s;
+  bliss_digraphs::Stats s;
   assert(graph);
   assert(graph->g);
   graph->g->find_automorphisms(s, hook, hook_user_param);
@@ -159,14 +176,14 @@ bliss_find_automorphisms(BlissGraph *graph,
 
 extern "C"
 const unsigned int *
-bliss_find_canonical_labeling(BlissGraph *graph,
+bliss_digraphs_find_canonical_labeling(BlissGraph *graph,
 			      void (*hook)(void *user_param,
 					   unsigned int n,
 					   const unsigned int *aut),
 			      void *hook_user_param,
 			      BlissStats *stats)
 {
-  bliss::Stats s;
+  bliss_digraphs::Stats s;
   const unsigned int *canonical_labeling = 0;
   assert(graph);
   assert(graph->g);