vpr: Remove 'using namespace std'

Author: kmurray

vpr/src/base/SetupGrid.cpp

@@ -11,7 +11,6 @@
 #include <algorithm>
 #include <regex>
 #include <limits>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_math.h"

vpr/src/base/SetupVPR.cpp

@@ -1,7 +1,6 @@
 #include <cstring>
 #include <vector>
 #include <sstream>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_util.h"
@@ -60,7 +59,7 @@ void SetupVPR(const t_options* Options,
               t_router_opts* RouterOpts,
               t_analysis_opts* AnalysisOpts,
               t_det_routing_arch* RoutingArch,
-              vector<t_lb_type_rr_node>** PackerRRGraphs,
+              std::vector<t_lb_type_rr_node>** PackerRRGraphs,
               std::vector<t_segment_inf>& Segments,
               t_timing_inf* Timing,
               bool* ShowGraphics,

vpr/src/base/check_netlist.cpp

@@ -4,7 +4,6 @@
 
 #include <cstdio>
 #include <cstring>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_log.h"

vpr/src/base/echo_files.cpp

@@ -1,6 +1,5 @@
 #include <cstdio>
 #include <cstring>
-using namespace std;
 
 #include "vtr_util.h"
 #include "vtr_memory.h"

vpr/src/base/place_and_route.cpp

@@ -5,7 +5,6 @@
 #include <climits>
 #include <cstdlib>
 #include <cmath>
-using namespace std;
 
 #include "vtr_util.h"
 #include "vtr_memory.h"
@@ -394,7 +393,7 @@ t_chan_width init_chan(int cfactor, t_chan_width_dist chan_width_dist) {
         for (size_t i = 0; i < grid.height(); ++i) {
             float y = float(i) / num_channels;
             chan_width.x_list[i] = (int)floor(cfactor * comp_width(&chan_x_dist, y, separation) + 0.5);
-            chan_width.x_list[i] = max(chan_width.x_list[i], 1); //Minimum channel width 1
+            chan_width.x_list[i] = std::max(chan_width.x_list[i], 1); //Minimum channel width 1
         }
     }
 
@@ -407,22 +406,22 @@ t_chan_width init_chan(int cfactor, t_chan_width_dist chan_width_dist) {
             float x = float(i) / num_channels;
 
             chan_width.y_list[i] = (int)floor(cfactor * comp_width(&chan_y_dist, x, separation) + 0.5);
-            chan_width.y_list[i] = max(chan_width.y_list[i], 1); //Minimum channel width 1
+            chan_width.y_list[i] = std::max(chan_width.y_list[i], 1); //Minimum channel width 1
         }
     }
 
     chan_width.max = 0;
     chan_width.x_max = chan_width.y_max = INT_MIN;
     chan_width.x_min = chan_width.y_min = INT_MAX;
     for (size_t i = 0; i < grid.height(); ++i) {
-        chan_width.max = max(chan_width.max, chan_width.x_list[i]);
-        chan_width.x_max = max(chan_width.x_max, chan_width.x_list[i]);
-        chan_width.x_min = min(chan_width.x_min, chan_width.x_list[i]);
+        chan_width.max = std::max(chan_width.max, chan_width.x_list[i]);
+        chan_width.x_max = std::max(chan_width.x_max, chan_width.x_list[i]);
+        chan_width.x_min = std::min(chan_width.x_min, chan_width.x_list[i]);
     }
     for (size_t i = 0; i < grid.width(); ++i) {
-        chan_width.max = max(chan_width.max, chan_width.y_list[i]);
-        chan_width.y_max = max(chan_width.y_max, chan_width.y_list[i]);
-        chan_width.y_min = min(chan_width.y_min, chan_width.y_list[i]);
+        chan_width.max = std::max(chan_width.max, chan_width.y_list[i]);
+        chan_width.y_max = std::max(chan_width.y_max, chan_width.y_list[i]);
+        chan_width.y_min = std::min(chan_width.y_min, chan_width.y_list[i]);
     }
 
 #ifdef VERBOSE

vpr/src/base/read_blif.cpp

@@ -21,7 +21,6 @@
 #include <sstream>
 #include <unordered_set>
 #include <cctype> //std::isdigit
-using namespace std;
 
 #include "blifparse.hpp"
 #include "atom_netlist.h"

vpr/src/base/read_netlist.cpp

@@ -9,7 +9,6 @@
 #include <cstring>
 #include <ctime>
 #include <map>
-using namespace std;
 
 #include "pugixml.hpp"
 #include "pugixml_loc.hpp"

vpr/src/base/read_route.cpp

@@ -17,7 +17,6 @@
 #include <sstream>
 #include <string>
 #include <unordered_set>
-using namespace std;
 
 #include "atom_netlist.h"
 #include "atom_netlist_utils.h"
@@ -43,13 +42,13 @@ using namespace std;
 #include "read_route.h"
 
 /*************Functions local to this module*************/
-static void process_route(ifstream& fp, const char* filename, int& lineno);
-static void process_nodes(ifstream& fp, ClusterNetId inet, const char* filename, int& lineno);
-static void process_nets(ifstream& fp, ClusterNetId inet, string name, std::vector<std::string> input_tokens, const char* filename, int& lineno);
-static void process_global_blocks(ifstream& fp, ClusterNetId inet, const char* filename, int& lineno);
-static void format_coordinates(int& x, int& y, string coord, ClusterNetId net, const char* filename, const int lineno);
-static void format_pin_info(string& pb_name, string& port_name, int& pb_pin_num, string input);
-static string format_name(string name);
+static void process_route(std::ifstream& fp, const char* filename, int& lineno);
+static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* filename, int& lineno);
+static void process_nets(std::ifstream& fp, ClusterNetId inet, std::string name, std::vector<std::string> input_tokens, const char* filename, int& lineno);
+static void process_global_blocks(std::ifstream& fp, ClusterNetId inet, const char* filename, int& lineno);
+static void format_coordinates(int& x, int& y, std::string coord, ClusterNetId net, const char* filename, const int lineno);
+static void format_pin_info(std::string& pb_name, std::string& port_name, int& pb_pin_num, std::string input);
+static std::string format_name(std::string name);
 
 /*************Global Functions****************************/
 bool read_route(const char* route_file, const t_router_opts& router_opts, bool verify_file_digests) {
@@ -61,9 +60,9 @@ bool read_route(const char* route_file, const t_router_opts& router_opts, bool v
     /* Begin parsing the file */
     VTR_LOG("Begin loading FPGA routing file.\n");
 
-    string header_str;
+    std::string header_str;
 
-    ifstream fp;
+    std::ifstream fp;
     fp.open(route_file);
 
     int lineno = 0;
@@ -73,7 +72,7 @@ bool read_route(const char* route_file, const t_router_opts& router_opts, bool v
                   "Cannot open %s routing file", route_file);
     }
 
-    getline(fp, header_str);
+    std::getline(fp, header_str);
     ++lineno;
 
     std::vector<std::string> header = vtr::split(header_str);
@@ -94,7 +93,7 @@ bool read_route(const char* route_file, const t_router_opts& router_opts, bool v
     init_route_structs(router_opts.bb_factor);
 
     /*Check dimensions*/
-    getline(fp, header_str);
+    std::getline(fp, header_str);
     ++lineno;
     header.clear();
     header = vtr::split(header_str);
@@ -127,11 +126,11 @@ bool read_route(const char* route_file, const t_router_opts& router_opts, bool v
     return is_feasible;
 }
 
-static void process_route(ifstream& fp, const char* filename, int& lineno) {
+static void process_route(std::ifstream& fp, const char* filename, int& lineno) {
     /*Walks through every net and add the routing appropriately*/
-    string input;
+    std::string input;
     std::vector<std::string> tokens;
-    while (getline(fp, input)) {
+    while (std::getline(fp, input)) {
         ++lineno;
         tokens.clear();
         tokens = vtr::split(input);
@@ -148,7 +147,7 @@ static void process_route(ifstream& fp, const char* filename, int& lineno) {
     tokens.clear();
 }
 
-static void process_nets(ifstream& fp, ClusterNetId inet, string name, std::vector<std::string> input_tokens, const char* filename, int& lineno) {
+static void process_nets(std::ifstream& fp, ClusterNetId inet, std::string name, std::vector<std::string> input_tokens, const char* filename, int& lineno) {
     /* Check if the net is global or not, and process appropriately */
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
 
@@ -190,7 +189,7 @@ static void process_nets(ifstream& fp, ClusterNetId inet, string name, std::vect
     return;
 }
 
-static void process_nodes(ifstream& fp, ClusterNetId inet, const char* filename, int& lineno) {
+static void process_nodes(std::ifstream& fp, ClusterNetId inet, const char* filename, int& lineno) {
     /* Not a global net. Goes through every node and add it into trace.head*/
 
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
@@ -201,14 +200,14 @@ static void process_nodes(ifstream& fp, ClusterNetId inet, const char* filename,
     t_trace* tptr = route_ctx.trace[inet].head;
 
     /*remember the position of the last line in order to go back*/
-    streampos oldpos = fp.tellg();
+    std::streampos oldpos = fp.tellg();
     int inode, x, y, x2, y2, ptc, switch_id, offset;
     int node_count = 0;
-    string input;
+    std::string input;
     std::vector<std::string> tokens;
 
     /*Walk through every line that begins with Node:*/
-    while (getline(fp, input)) {
+    while (std::getline(fp, input)) {
         ++lineno;
 
         tokens.clear();
@@ -292,7 +291,7 @@ static void process_nodes(ifstream& fp, ClusterNetId inet, const char* filename,
                     t_pb_graph_pin* pb_pin = get_pb_graph_node_pin_from_block_pin(iblock, pin_num);
                     t_pb_type* pb_type = pb_pin->parent_node->pb_type;
 
-                    string pb_name, port_name;
+                    std::string pb_name, port_name;
                     int pb_pin_num;
 
                     format_pin_info(pb_name, port_name, pb_pin_num, tokens[6 + offset]);
@@ -334,18 +333,18 @@ static void process_nodes(ifstream& fp, ClusterNetId inet, const char* filename,
 
 /*This function goes through all the blocks in a global net and verify it with the
  * clustered netlist and the placement */
-static void process_global_blocks(ifstream& fp, ClusterNetId inet, const char* filename, int& lineno) {
+static void process_global_blocks(std::ifstream& fp, ClusterNetId inet, const char* filename, int& lineno) {
     auto& cluster_ctx = g_vpr_ctx.mutable_clustering();
     auto& place_ctx = g_vpr_ctx.placement();
 
-    string block, bnum_str;
+    std::string block, bnum_str;
     int x, y;
     std::vector<std::string> tokens;
     int pin_counter = 0;
 
-    streampos oldpos = fp.tellg();
+    std::streampos oldpos = fp.tellg();
     /*Walk through every block line*/
-    while (getline(fp, block)) {
+    while (std::getline(fp, block)) {
         ++lineno;
         tokens.clear();
         tokens = vtr::split(block);
@@ -391,10 +390,10 @@ static void process_global_blocks(ifstream& fp, ClusterNetId inet, const char* f
     }
 }
 
-static void format_coordinates(int& x, int& y, string coord, ClusterNetId net, const char* filename, const int lineno) {
+static void format_coordinates(int& x, int& y, std::string coord, ClusterNetId net, const char* filename, const int lineno) {
     /*Parse coordinates in the form of (x,y) into correct x and y values*/
     coord = format_name(coord);
-    stringstream coord_stream(coord);
+    std::stringstream coord_stream(coord);
     if (!(coord_stream >> x)) {
         vpr_throw(VPR_ERROR_ROUTE, filename, lineno,
                   "Net %lu has coordinates that is not in the form (x,y)", size_t(net));
@@ -406,12 +405,12 @@ static void format_coordinates(int& x, int& y, string coord, ClusterNetId net, c
     }
 }
 
-static void format_pin_info(string& pb_name, string& port_name, int& pb_pin_num, string input) {
+static void format_pin_info(std::string& pb_name, std::string& port_name, int& pb_pin_num, std::string input) {
     /*Parse the pin info in the form of pb_name.port_name[pb_pin_num]
      *into its appropriate variables*/
-    stringstream pb_info(input);
-    getline(pb_info, pb_name, '.');
-    getline(pb_info, port_name, '[');
+    std::stringstream pb_info(input);
+    std::getline(pb_info, pb_name, '.');
+    std::getline(pb_info, port_name, '[');
     pb_info >> pb_pin_num;
     if (!pb_info) {
         VPR_FATAL_ERROR(VPR_ERROR_ROUTE,
@@ -421,7 +420,7 @@ static void format_pin_info(string& pb_name, string& port_name, int& pb_pin_num,
 }
 
 /*Return actual name by extracting it out of the form of (name)*/
-static string format_name(string name) {
+static std::string format_name(std::string name) {
     if (name.length() > 2) {
         name.erase(name.begin());
         name.erase(name.end() - 1);

vpr/src/base/stats.cpp

@@ -2,7 +2,6 @@
 #include <cstring>
 #include <cmath>
 #include <set>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_log.h"
@@ -122,13 +121,13 @@ void length_and_bends_stats() {
             get_num_bends_and_length(net_id, &bends, &length, &segments);
 
             total_bends += bends;
-            max_bends = max(bends, max_bends);
+            max_bends = std::max(bends, max_bends);
 
             total_length += length;
-            max_length = max(length, max_length);
+            max_length = std::max(length, max_length);
 
             total_segments += segments;
-            max_segments = max(segments, max_segments);
+            max_segments = std::max(segments, max_segments);
         } else if (cluster_ctx.clb_nlist.net_is_ignored(net_id)) {
             num_global_nets++;
         } else {
@@ -184,7 +183,7 @@ static void get_channel_occupancy_stats() {
         int max_occ = -1;
 
         for (size_t i = 1; i < device_ctx.grid.width(); ++i) {
-            max_occ = max(chanx_occ[i][j], max_occ);
+            max_occ = std::max(chanx_occ[i][j], max_occ);
             ave_occ += chanx_occ[i][j];
         }
         ave_occ /= device_ctx.grid.width();
@@ -201,7 +200,7 @@ static void get_channel_occupancy_stats() {
         int max_occ = -1;
 
         for (size_t j = 1; j < device_ctx.grid.height(); ++j) {
-            max_occ = max(chany_occ[i][j], max_occ);
+            max_occ = std::max(chany_occ[i][j], max_occ);
             ave_occ += chany_occ[i][j];
         }
         ave_occ /= device_ctx.grid.height();

vpr/src/base/vpr_api.cpp

@@ -13,7 +13,6 @@
 #include <chrono>
 #include <cmath>
 #include <sstream>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_math.h"
@@ -1043,7 +1042,7 @@ void vpr_setup_vpr(t_options* Options,
                    t_router_opts* RouterOpts,
                    t_analysis_opts* AnalysisOpts,
                    t_det_routing_arch* RoutingArch,
-                   vector<t_lb_type_rr_node>** PackerRRGraph,
+                   std::vector<t_lb_type_rr_node>** PackerRRGraph,
                    std::vector<t_segment_inf>& Segments,
                    t_timing_inf* Timing,
                    bool* ShowGraphics,

vpr/src/draw/buttons.cpp

@@ -18,7 +18,6 @@
 #    include "ezgl/point.hpp"
 #    include "ezgl/application.hpp"
 #    include "ezgl/graphics.hpp"
-using namespace std;
 
 //location of spin buttons, combo boxes, and labels on grid
 gint box_width = 1;
@@ -370,4 +369,4 @@ GtkWidget* find_button(const char* button_name) {
     return target_button;
 }
 
-#endif /* NO_GRAPHICS */
+#endif /* NO_GRAPHICS */

vpr/src/draw/draw.cpp

@@ -19,7 +19,6 @@
 #include <algorithm>
 #include <sstream>
 #include <array>
-using namespace std;
 
 #include "vtr_assert.h"
 #include "vtr_ndoffsetmatrix.h"
@@ -880,8 +879,8 @@ void init_draw_coords(float width_val) {
     for (const auto& type : device_ctx.physical_tile_types) {
         auto num_pins = type.num_pins;
         if (num_pins > 0) {
-            draw_coords->pin_size = min(draw_coords->pin_size,
-                                        (draw_coords->get_tile_width() / (4.0F * num_pins)));
+            draw_coords->pin_size = std::min(draw_coords->pin_size,
+                                             (draw_coords->get_tile_width() / (4.0F * num_pins)));
         }
     }