removed brackets around objs to be deleted

jmah76 · jmah76 · commit 5366e7618ce2 · 2022-07-07T14:14:18.000-04:00
diff --git a/libs/libarchfpga/src/arch_util.cpp b/libs/libarchfpga/src/arch_util.cpp
@@ -298,7 +298,7 @@ static void free_all_pb_graph_nodes(std::vector<t_logical_block_type>& type_desc
         if (type.pb_type) {
             if (type.pb_graph_head) {
                 free_pb_graph(type.pb_graph_head);
-                delete (type.pb_graph_head);
+                delete type.pb_graph_head;
             }
         }
     }
@@ -317,45 +317,45 @@ static void free_pb_graph(t_pb_graph_node* pb_graph_node) {
     for (i = 0; i < pb_graph_node->num_input_ports; i++) {
         for (j = 0; j < pb_graph_node->num_input_pins[i]; j++) {
             if (pb_graph_node->input_pins[i][j].parent_pin_class)
-                delete[](pb_graph_node->input_pins[i][j].parent_pin_class);
+                delete[] pb_graph_node->input_pins[i][j].parent_pin_class;
         }
         delete[] pb_graph_node->input_pins[i];
     }
     for (i = 0; i < pb_graph_node->num_output_ports; i++) {
         for (j = 0; j < pb_graph_node->num_output_pins[i]; j++) {
             if (pb_graph_node->output_pins[i][j].parent_pin_class)
-                delete[](pb_graph_node->output_pins[i][j].parent_pin_class);
+                delete[] pb_graph_node->output_pins[i][j].parent_pin_class;
 
             if (pb_graph_node->output_pins[i][j].list_of_connectable_input_pin_ptrs) {
                 for (k = 0; k < pb_graph_node->pb_type->depth; k++) {
-                    delete[](pb_graph_node->output_pins[i][j].list_of_connectable_input_pin_ptrs[k]);
+                    delete[] pb_graph_node->output_pins[i][j].list_of_connectable_input_pin_ptrs[k];
                 }
-                delete[](pb_graph_node->output_pins[i][j].list_of_connectable_input_pin_ptrs);
+                delete[]pb_graph_node->output_pins[i][j].list_of_connectable_input_pin_ptrs;
             }
 
             if (pb_graph_node->output_pins[i][j].num_connectable_primitive_input_pins)
-                delete[](pb_graph_node->output_pins[i][j].num_connectable_primitive_input_pins);
+                delete[] pb_graph_node->output_pins[i][j].num_connectable_primitive_input_pins;
         }
         delete[] pb_graph_node->output_pins[i];
     }
     for (i = 0; i < pb_graph_node->num_clock_ports; i++) {
         for (j = 0; j < pb_graph_node->num_clock_pins[i]; j++) {
             if (pb_graph_node->clock_pins[i][j].parent_pin_class)
-                delete[](pb_graph_node->clock_pins[i][j].parent_pin_class);
+                delete[] pb_graph_node->clock_pins[i][j].parent_pin_class;
         }
         delete[] pb_graph_node->clock_pins[i];
     }
 
-    delete[](pb_graph_node->input_pins);
-    delete[](pb_graph_node->output_pins);
-    delete[](pb_graph_node->clock_pins);
+    delete[] pb_graph_node->input_pins;
+    delete[] pb_graph_node->output_pins;
+    delete[] pb_graph_node->clock_pins;
 
-    delete[](pb_graph_node->num_input_pins);
-    delete[](pb_graph_node->num_output_pins);
-    delete[](pb_graph_node->num_clock_pins);
+    delete[] pb_graph_node->num_input_pins;
+    delete[] pb_graph_node->num_output_pins;
+    delete[] pb_graph_node->num_clock_pins;
 
-    delete[](pb_graph_node->input_pin_class_size);
-    delete[](pb_graph_node->output_pin_class_size);
+    delete[] pb_graph_node->input_pin_class_size;
+    delete[] pb_graph_node->output_pin_class_size;
 
     if (pb_graph_node->interconnect_pins) {
         for (i = 0; i < pb_graph_node->pb_type->num_modes; i++) {
@@ -371,19 +371,19 @@ static void free_pb_graph(t_pb_graph_node* pb_graph_node) {
 
                 t_interconnect_power* interconn_power = interconn->interconnect_power;
                 for (int iport = 0; iport < interconn_power->num_input_ports; ++iport) {
-                    delete[](pb_graph_node->interconnect_pins[i][j].input_pins[iport]);
+                    delete[] pb_graph_node->interconnect_pins[i][j].input_pins[iport];
                 }
                 for (int iport = 0; iport < interconn_power->num_output_ports; ++iport) {
-                    delete[](pb_graph_node->interconnect_pins[i][j].output_pins[iport]);
+                    delete[] pb_graph_node->interconnect_pins[i][j].output_pins[iport];
                 }
-                delete[](pb_graph_node->interconnect_pins[i][j].input_pins);
-                delete[](pb_graph_node->interconnect_pins[i][j].output_pins);
+                delete[] pb_graph_node->interconnect_pins[i][j].input_pins;
+                delete[] pb_graph_node->interconnect_pins[i][j].output_pins;
             }
-            delete[](pb_graph_node->interconnect_pins[i]);
+            delete[] pb_graph_node->interconnect_pins[i];
         }
     }
-    delete[](pb_graph_node->interconnect_pins);
-    delete (pb_graph_node->pb_node_power);
+    delete[] pb_graph_node->interconnect_pins;
+    delete pb_graph_node->pb_node_power;
 
     for (i = 0; i < pb_type->num_modes; i++) {
         for (j = 0; j < pb_type->modes[i].num_pb_type_children; j++) {
diff --git a/vpr/src/base/read_netlist.cpp b/vpr/src/base/read_netlist.cpp
@@ -751,10 +751,10 @@ static void processPorts(pugi::xml_node Parent, t_pb* pb, t_pb_routes& pb_route,
                         }
                     }
                     for (j = 0; j < num_sets; j++) {
-                        delete[](pin_node[j]);
+                        delete[] pin_node[j];
                     }
-                    delete[](pin_node);
-                    delete[](num_ptrs);
+                    delete[] pin_node;
+                    delete[] num_ptrs;
                     if (!found) {
                         vpr_throw(VPR_ERROR_NET_F, netlist_file_name, loc_data.line(Cur),
                                   "Unknown interconnect %s connecting to pin %s.\n",
@@ -820,10 +820,10 @@ static void processPorts(pugi::xml_node Parent, t_pb* pb, t_pb_routes& pb_route,
                         }
                     }
                     for (j = 0; j < num_sets; j++) {
-                        delete[](pin_node[j]);
+                        delete[] pin_node[j];
                     }
-                    delete[](pin_node);
-                    delete[](num_ptrs);
+                    delete[] pin_node;
+                    delete[] num_ptrs;
                     if (!found) {
                         vpr_throw(VPR_ERROR_NET_F, netlist_file_name, loc_data.line(Cur),
                                   "Unknown interconnect %s connecting to pin %s.\n",
diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h
@@ -284,7 +284,7 @@ struct ClusteringHelperContext : public Context {
     std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;
 
     ~ClusteringHelperContext() {
-        delete[](primitives_list);
+        delete[] primitives_list;
     }
 };
 
diff --git a/vpr/src/base/vpr_types.cpp b/vpr/src/base/vpr_types.cpp
@@ -236,31 +236,31 @@ void free_cluster_placement_stats(t_cluster_placement_stats* cluster_placement_s
         cur = cluster_placement_stats_list[index].tried;
         while (cur != nullptr) {
             next = cur->next_primitive;
-            delete (cur);
+            delete cur;
             cur = next;
         }
         cur = cluster_placement_stats_list[index].in_flight;
         while (cur != nullptr) {
             next = cur->next_primitive;
-            delete (cur);
+            delete cur;
             cur = next;
         }
         cur = cluster_placement_stats_list[index].invalid;
         while (cur != nullptr) {
             next = cur->next_primitive;
-            delete (cur);
+            delete cur;
             cur = next;
         }
         for (int j = 0; j < cluster_placement_stats_list[index].num_pb_types; j++) {
             cur = cluster_placement_stats_list[index].valid_primitives[j]->next_primitive;
             while (cur != nullptr) {
                 next = cur->next_primitive;
-                delete (cur);
+                delete cur;
                 cur = next;
             }
-            delete (cluster_placement_stats_list[index].valid_primitives[j]);
+            delete cluster_placement_stats_list[index].valid_primitives[j];
         }
-        delete[](cluster_placement_stats_list[index].valid_primitives);
+        delete[] cluster_placement_stats_list[index].valid_primitives;
     }
-    delete[](cluster_placement_stats_list);
+    delete[] cluster_placement_stats_list;
 }
diff --git a/vpr/src/pack/cluster_util.cpp b/vpr/src/pack/cluster_util.cpp
@@ -237,15 +237,15 @@ void free_clustering_data(const t_packer_opts& packer_opts,
     clustering_data.intra_lb_routing.clear();
 
     if (packer_opts.hill_climbing_flag)
-        delete[](clustering_data.hill_climbing_inputs_avail);
+        delete[] clustering_data.hill_climbing_inputs_avail;
 
     for (auto blk_id : cluster_ctx.clb_nlist.blocks())
         cluster_ctx.clb_nlist.remove_block(blk_id);
 
     cluster_ctx.clb_nlist = ClusteredNetlist();
 
-    delete[](clustering_data.unclustered_list_head);
-    delete[](clustering_data.memory_pool);
+    delete[] clustering_data.unclustered_list_head;
+    delete[] clustering_data.memory_pool;
 }
 
 //check the clustering and output it
@@ -545,7 +545,7 @@ void alloc_and_init_clustering(const t_molecule_stats& max_molecule_stats,
 
         next_ptr++;
     }
-    delete[](molecule_array);
+    delete[] molecule_array;
 
     /* load net info */
     auto& atom_ctx = g_vpr_ctx.atom();
diff --git a/vpr/src/pack/lb_type_rr_graph.cpp b/vpr/src/pack/lb_type_rr_graph.cpp
@@ -86,13 +86,13 @@ void free_all_lb_type_rr_graph(std::vector<t_lb_type_rr_node>* lb_type_rr_graphs
                 if (node->outedges != nullptr) {
                     for (int imode = 0; imode < node->num_modes; imode++) {
                         if (node->outedges[imode] != nullptr) {
-                            delete[](node->outedges[imode]);
+                            delete[] node->outedges[imode];
                         }
                     }
-                    delete[](node->outedges);
+                    delete[] node->outedges;
                 }
                 if (node->num_fanout != nullptr) {
-                    delete[](node->num_fanout);
+                    delete[] node->num_fanout;
                 }
             }
         }
diff --git a/vpr/src/pack/output_clustering.cpp b/vpr/src/pack/output_clustering.cpp
@@ -130,9 +130,9 @@ static void print_stats() {
     }
     VTR_LOG("Absorbed logical nets %d out of %d nets, %d nets not absorbed.\n",
             total_nets_absorbed, (int)atom_ctx.nlist.nets().size(), (int)atom_ctx.nlist.nets().size() - total_nets_absorbed);
-    delete[](num_clb_types);
-    delete[](num_clb_inputs_used);
-    delete[](num_clb_outputs_used);
+    delete[] num_clb_types;
+    delete[] num_clb_inputs_used;
+    delete[] num_clb_outputs_used;
     /* TODO: print more stats */
 }
 
diff --git a/vpr/src/pack/pb_type_graph.cpp b/vpr/src/pack/pb_type_graph.cpp
@@ -356,20 +356,20 @@ void free_pb_graph_edges() {
         cur_num = num_edges_head;
         edges = (t_pb_graph_edge*)cur->data_vptr;
         for (int i = 0; i < (intptr_t)cur_num->data_vptr; i++) {
-            delete[](edges[i].input_pins);
-            delete[](edges[i].output_pins);
+            delete[] edges[i].input_pins;
+            delete[] edges[i].output_pins;
             if (edges[i].pack_pattern_indices) {
-                delete[](edges[i].pack_pattern_indices);
+                delete[] edges[i].pack_pattern_indices;
             }
             // if (edges[i].pack_pattern_names) {
             // vtr::free(edges[i].pack_pattern_names);
             // }
         }
         edges_head = edges_head->next;
         num_edges_head = num_edges_head->next;
-        delete[](edges);
-        delete (cur_num);
-        delete (cur);
+        delete[] edges;
+        delete cur_num;
+        delete cur;
     }
 }
 
@@ -579,15 +579,15 @@ static void alloc_and_load_mode_interconnect(t_pb_graph_node* pb_graph_parent_no
                           mode->interconnect[i].output_string);
         }
         for (j = 0; j < num_input_pb_graph_node_sets; j++) {
-            delete[](input_pb_graph_node_pins[j]);
+            delete[] input_pb_graph_node_pins[j];
         }
         delete[](input_pb_graph_node_pins);
         for (j = 0; j < num_output_pb_graph_node_sets; j++) {
-            delete[](output_pb_graph_node_pins[j]);
+            delete[] output_pb_graph_node_pins[j];
         }
-        delete[](output_pb_graph_node_pins);
-        delete[](num_input_pb_graph_node_pins);
-        delete[](num_output_pb_graph_node_pins);
+        delete[] output_pb_graph_node_pins;
+        delete[] num_input_pb_graph_node_pins;
+        delete[] num_output_pb_graph_node_pins;
     }
 }
 
diff --git a/vpr/src/pack/pb_type_graph_annotations.cpp b/vpr/src/pack/pb_type_graph_annotations.cpp
@@ -166,17 +166,17 @@ static void load_pack_pattern_annotations(const int line_num, t_pb_graph_node* p
 
     if (in_port != nullptr) {
         for (i = 0; i < num_in_sets; i++) {
-            delete[](in_port[i]);
+            delete[] in_port[i];
         }
-        delete[](in_port);
-        delete[](num_in_ptrs);
+        delete[] in_port;
+        delete[] num_in_ptrs;
     }
     if (out_port != nullptr) {
         for (i = 0; i < num_out_sets; i++) {
-            delete[](out_port[i]);
+            delete[] out_port[i];
         }
-        delete[](out_port);
-        delete[](num_out_ptrs);
+        delete[] out_port;
+        delete[] num_out_ptrs;
     }
 }
 
@@ -456,22 +456,22 @@ static void load_delay_annotations(const int line_num,
     //Clean-up
     if (in_port != nullptr) {
         for (i = 0; i < num_in_sets; i++) {
-            delete[](in_port[i]);
+            delete[] in_port[i];
         }
-        delete[](in_port);
-        delete[](num_in_ptrs);
+        delete[] in_port;
+        delete[] num_in_ptrs;
     }
     if (out_port != nullptr) {
         for (i = 0; i < num_out_sets; i++) {
-            delete[](out_port[i]);
+            delete[] out_port[i];
         }
-        delete[](out_port);
-        delete[](num_out_ptrs);
+        delete[] out_port;
+        delete[] num_out_ptrs;
     }
     for (i = 0; i < num_inputs; i++) {
-        delete[](delay_matrix[i]);
+        delete[] delay_matrix[i];
     }
-    delete[](delay_matrix);
+    delete[] delay_matrix;
 }
 
 static void inferr_unspecified_pb_graph_node_delays(t_pb_graph_node* pb_graph_node) {
diff --git a/vpr/src/pack/prepack.cpp b/vpr/src/pack/prepack.cpp
@@ -357,12 +357,12 @@ void free_pack_pattern(t_pack_patterns* pack_pattern) {
             pattern_block_list[i] = nullptr;
 
         free(pack_pattern->name);
-        delete[](pack_pattern->is_block_optional);
+        delete[] pack_pattern->is_block_optional;
         free_pack_pattern_block(pack_pattern->root_block, pattern_block_list);
         for (int j = 0; j < num_pack_pattern_blocks; j++) {
-            delete (pattern_block_list[j]);
+            delete pattern_block_list[j];
         }
-        delete[](pattern_block_list);
+        delete[] pattern_block_list;
     }
 }
 
@@ -848,7 +848,7 @@ t_pack_molecule* alloc_and_load_pack_molecules(t_pack_patterns* list_of_pack_pat
             }
         }
     }
-    delete[](is_used);
+    delete[] is_used;
 
     /* List all atom blocks as a molecule for blocks that do not belong to any molecules.
      * This allows the packer to be consistent as it now packs molecules only instead of atoms and molecules
@@ -917,7 +917,7 @@ static void free_pack_pattern_block(t_pack_pattern_block* pattern_block, t_pack_
         free_pack_pattern_block(connection->from_block, pattern_block_list);
         free_pack_pattern_block(connection->to_block, pattern_block_list);
         next = connection->next;
-        delete (connection);
+        delete connection;
         connection = next;
     }
 }
diff --git a/vpr/src/util/vpr_utils.cpp b/vpr/src/util/vpr_utils.cpp
@@ -1401,7 +1401,7 @@ void free_pb_stats(t_pb* pb) {
         pb->pb_stats->num_pins_of_net_in_pb.clear();
 
         if (pb->pb_stats->feasible_blocks) {
-            delete[](pb->pb_stats->feasible_blocks);
+            delete[] pb->pb_stats->feasible_blocks;
         }
         if (!pb->parent_pb) {
             pb->pb_stats->transitive_fanout_candidates.clear();

Original file line number	Diff line number	Diff line change
`@@ -751,10 +751,10 @@ static void processPorts(pugi::xml_node Parent, t_pb* pb, t_pb_routes& pb_route,`
`751`	`751`	`}`
`752`	`752`	`}`
`753`	`753`	`for (j = 0; j < num_sets; j++) {`
`754`		`- delete[](pin_node[j]);`
	`754`	`+ delete[] pin_node[j];`
`755`	`755`	`}`
`756`		`- delete[](pin_node);`
`757`		`- delete[](num_ptrs);`
	`756`	`+ delete[] pin_node;`
	`757`	`+ delete[] num_ptrs;`
`758`	`758`	`if (!found) {`
`759`	`759`	`vpr_throw(VPR_ERROR_NET_F, netlist_file_name, loc_data.line(Cur),`
`760`	`760`	`"Unknown interconnect %s connecting to pin %s.\n",`
`@@ -820,10 +820,10 @@ static void processPorts(pugi::xml_node Parent, t_pb* pb, t_pb_routes& pb_route,`
`820`	`820`	`}`
`821`	`821`	`}`
`822`	`822`	`for (j = 0; j < num_sets; j++) {`
`823`		`- delete[](pin_node[j]);`
	`823`	`+ delete[] pin_node[j];`
`824`	`824`	`}`
`825`		`- delete[](pin_node);`
`826`		`- delete[](num_ptrs);`
	`825`	`+ delete[] pin_node;`
	`826`	`+ delete[] num_ptrs;`
`827`	`827`	`if (!found) {`
`828`	`828`	`vpr_throw(VPR_ERROR_NET_F, netlist_file_name, loc_data.line(Cur),`
`829`	`829`	`"Unknown interconnect %s connecting to pin %s.\n",`
Original file line number	Diff line number	Diff line change
`@@ -284,7 +284,7 @@ struct ClusteringHelperContext : public Context {`
`284`	`284`	`std::vector<t_lb_type_rr_node>* lb_type_rr_graphs;`
`285`	`285`
`286`	`286`	`~ClusteringHelperContext() {`
`287`		`- delete[](primitives_list);`
	`287`	`+ delete[] primitives_list;`
`288`	`288`	`}`
`289`	`289`	`};`
`290`	`290`
Original file line number	Diff line number	Diff line change
`@@ -236,31 +236,31 @@ void free_cluster_placement_stats(t_cluster_placement_stats* cluster_placement_s`
`236`	`236`	`cur = cluster_placement_stats_list[index].tried;`
`237`	`237`	`while (cur != nullptr) {`
`238`	`238`	`next = cur->next_primitive;`
`239`		`- delete (cur);`
	`239`	`+ delete cur;`
`240`	`240`	`cur = next;`
`241`	`241`	`}`
`242`	`242`	`cur = cluster_placement_stats_list[index].in_flight;`
`243`	`243`	`while (cur != nullptr) {`
`244`	`244`	`next = cur->next_primitive;`
`245`		`- delete (cur);`
	`245`	`+ delete cur;`
`246`	`246`	`cur = next;`
`247`	`247`	`}`
`248`	`248`	`cur = cluster_placement_stats_list[index].invalid;`
`249`	`249`	`while (cur != nullptr) {`
`250`	`250`	`next = cur->next_primitive;`
`251`		`- delete (cur);`
	`251`	`+ delete cur;`
`252`	`252`	`cur = next;`
`253`	`253`	`}`
`254`	`254`	`for (int j = 0; j < cluster_placement_stats_list[index].num_pb_types; j++) {`
`255`	`255`	`cur = cluster_placement_stats_list[index].valid_primitives[j]->next_primitive;`
`256`	`256`	`while (cur != nullptr) {`
`257`	`257`	`next = cur->next_primitive;`
`258`		`- delete (cur);`
	`258`	`+ delete cur;`
`259`	`259`	`cur = next;`
`260`	`260`	`}`
`261`		`- delete (cluster_placement_stats_list[index].valid_primitives[j]);`
	`261`	`+ delete cluster_placement_stats_list[index].valid_primitives[j];`
`262`	`262`	`}`
`263`		`- delete[](cluster_placement_stats_list[index].valid_primitives);`
	`263`	`+ delete[] cluster_placement_stats_list[index].valid_primitives;`
`264`	`264`	`}`
`265`		`- delete[](cluster_placement_stats_list);`
	`265`	`+ delete[] cluster_placement_stats_list;`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,13 +86,13 @@ void free_all_lb_type_rr_graph(std::vector<t_lb_type_rr_node>* lb_type_rr_graphs`
`86`	`86`	`if (node->outedges != nullptr) {`
`87`	`87`	`for (int imode = 0; imode < node->num_modes; imode++) {`
`88`	`88`	`if (node->outedges[imode] != nullptr) {`
`89`		`- delete[](node->outedges[imode]);`
	`89`	`+ delete[] node->outedges[imode];`
`90`	`90`	`}`
`91`	`91`	`}`
`92`		`- delete[](node->outedges);`
	`92`	`+ delete[] node->outedges;`
`93`	`93`	`}`
`94`	`94`	`if (node->num_fanout != nullptr) {`
`95`		`- delete[](node->num_fanout);`
	`95`	`+ delete[] node->num_fanout;`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,9 +130,9 @@ static void print_stats() {`
`130`	`130`	`}`
`131`	`131`	`VTR_LOG("Absorbed logical nets %d out of %d nets, %d nets not absorbed.\n",`
`132`	`132`	`total_nets_absorbed, (int)atom_ctx.nlist.nets().size(), (int)atom_ctx.nlist.nets().size() - total_nets_absorbed);`
`133`		`- delete[](num_clb_types);`
`134`		`- delete[](num_clb_inputs_used);`
`135`		`- delete[](num_clb_outputs_used);`
	`133`	`+ delete[] num_clb_types;`
	`134`	`+ delete[] num_clb_inputs_used;`
	`135`	`+ delete[] num_clb_outputs_used;`
`136`	`136`	`/* TODO: print more stats */`
`137`	`137`	`}`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -356,20 +356,20 @@ void free_pb_graph_edges() {`
`356`	`356`	`cur_num = num_edges_head;`
`357`	`357`	`edges = (t_pb_graph_edge*)cur->data_vptr;`
`358`	`358`	`for (int i = 0; i < (intptr_t)cur_num->data_vptr; i++) {`
`359`		`- delete[](edges[i].input_pins);`
`360`		`- delete[](edges[i].output_pins);`
	`359`	`+ delete[] edges[i].input_pins;`
	`360`	`+ delete[] edges[i].output_pins;`
`361`	`361`	`if (edges[i].pack_pattern_indices) {`
`362`		`- delete[](edges[i].pack_pattern_indices);`
	`362`	`+ delete[] edges[i].pack_pattern_indices;`
`363`	`363`	`}`
`364`	`364`	`// if (edges[i].pack_pattern_names) {`
`365`	`365`	`// vtr::free(edges[i].pack_pattern_names);`
`366`	`366`	`// }`
`367`	`367`	`}`
`368`	`368`	`edges_head = edges_head->next;`
`369`	`369`	`num_edges_head = num_edges_head->next;`
`370`		`- delete[](edges);`
`371`		`- delete (cur_num);`
`372`		`- delete (cur);`
	`370`	`+ delete[] edges;`
	`371`	`+ delete cur_num;`
	`372`	`+ delete cur;`
`373`	`373`	`}`
`374`	`374`	`}`
`375`	`375`
`@@ -579,15 +579,15 @@ static void alloc_and_load_mode_interconnect(t_pb_graph_node* pb_graph_parent_no`
`579`	`579`	`mode->interconnect[i].output_string);`
`580`	`580`	`}`
`581`	`581`	`for (j = 0; j < num_input_pb_graph_node_sets; j++) {`
`582`		`- delete[](input_pb_graph_node_pins[j]);`
	`582`	`+ delete[] input_pb_graph_node_pins[j];`
`583`	`583`	`}`
`584`	`584`	`delete[](input_pb_graph_node_pins);`
`585`	`585`	`for (j = 0; j < num_output_pb_graph_node_sets; j++) {`
`586`		`- delete[](output_pb_graph_node_pins[j]);`
	`586`	`+ delete[] output_pb_graph_node_pins[j];`
`587`	`587`	`}`
`588`		`- delete[](output_pb_graph_node_pins);`
`589`		`- delete[](num_input_pb_graph_node_pins);`
`590`		`- delete[](num_output_pb_graph_node_pins);`
	`588`	`+ delete[] output_pb_graph_node_pins;`
	`589`	`+ delete[] num_input_pb_graph_node_pins;`
	`590`	`+ delete[] num_output_pb_graph_node_pins;`
`591`	`591`	`}`
`592`	`592`	`}`
`593`	`593`
Original file line number	Diff line number	Diff line change
`@@ -166,17 +166,17 @@ static void load_pack_pattern_annotations(const int line_num, t_pb_graph_node* p`
`166`	`166`
`167`	`167`	`if (in_port != nullptr) {`
`168`	`168`	`for (i = 0; i < num_in_sets; i++) {`
`169`		`- delete[](in_port[i]);`
	`169`	`+ delete[] in_port[i];`
`170`	`170`	`}`
`171`		`- delete[](in_port);`
`172`		`- delete[](num_in_ptrs);`
	`171`	`+ delete[] in_port;`
	`172`	`+ delete[] num_in_ptrs;`
`173`	`173`	`}`
`174`	`174`	`if (out_port != nullptr) {`
`175`	`175`	`for (i = 0; i < num_out_sets; i++) {`
`176`		`- delete[](out_port[i]);`
	`176`	`+ delete[] out_port[i];`
`177`	`177`	`}`
`178`		`- delete[](out_port);`
`179`		`- delete[](num_out_ptrs);`
	`178`	`+ delete[] out_port;`
	`179`	`+ delete[] num_out_ptrs;`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`@@ -456,22 +456,22 @@ static void load_delay_annotations(const int line_num,`
`456`	`456`	`//Clean-up`
`457`	`457`	`if (in_port != nullptr) {`
`458`	`458`	`for (i = 0; i < num_in_sets; i++) {`
`459`		`- delete[](in_port[i]);`
	`459`	`+ delete[] in_port[i];`
`460`	`460`	`}`
`461`		`- delete[](in_port);`
`462`		`- delete[](num_in_ptrs);`
	`461`	`+ delete[] in_port;`
	`462`	`+ delete[] num_in_ptrs;`
`463`	`463`	`}`
`464`	`464`	`if (out_port != nullptr) {`
`465`	`465`	`for (i = 0; i < num_out_sets; i++) {`
`466`		`- delete[](out_port[i]);`
	`466`	`+ delete[] out_port[i];`
`467`	`467`	`}`
`468`		`- delete[](out_port);`
`469`		`- delete[](num_out_ptrs);`
	`468`	`+ delete[] out_port;`
	`469`	`+ delete[] num_out_ptrs;`
`470`	`470`	`}`
`471`	`471`	`for (i = 0; i < num_inputs; i++) {`
`472`		`- delete[](delay_matrix[i]);`
	`472`	`+ delete[] delay_matrix[i];`
`473`	`473`	`}`
`474`		`- delete[](delay_matrix);`
	`474`	`+ delete[] delay_matrix;`
`475`	`475`	`}`
`476`	`476`
`477`	`477`	`static void inferr_unspecified_pb_graph_node_delays(t_pb_graph_node* pb_graph_node) {`
Original file line number	Diff line number	Diff line change
`@@ -357,12 +357,12 @@ void free_pack_pattern(t_pack_patterns* pack_pattern) {`
`357`	`357`	`pattern_block_list[i] = nullptr;`
`358`	`358`
`359`	`359`	`free(pack_pattern->name);`
`360`		`- delete[](pack_pattern->is_block_optional);`
	`360`	`+ delete[] pack_pattern->is_block_optional;`
`361`	`361`	`free_pack_pattern_block(pack_pattern->root_block, pattern_block_list);`
`362`	`362`	`for (int j = 0; j < num_pack_pattern_blocks; j++) {`
`363`		`- delete (pattern_block_list[j]);`
	`363`	`+ delete pattern_block_list[j];`
`364`	`364`	`}`
`365`		`- delete[](pattern_block_list);`
	`365`	`+ delete[] pattern_block_list;`
`366`	`366`	`}`
`367`	`367`	`}`
`368`	`368`
`@@ -848,7 +848,7 @@ t_pack_molecule* alloc_and_load_pack_molecules(t_pack_patterns* list_of_pack_pat`
`848`	`848`	`}`
`849`	`849`	`}`
`850`	`850`	`}`
`851`		`- delete[](is_used);`
	`851`	`+ delete[] is_used;`
`852`	`852`
`853`	`853`	`/* List all atom blocks as a molecule for blocks that do not belong to any molecules.`
`854`	`854`	`* This allows the packer to be consistent as it now packs molecules only instead of atoms and molecules`
`@@ -917,7 +917,7 @@ static void free_pack_pattern_block(t_pack_pattern_block* pattern_block, t_pack_`
`917`	`917`	`free_pack_pattern_block(connection->from_block, pattern_block_list);`
`918`	`918`	`free_pack_pattern_block(connection->to_block, pattern_block_list);`
`919`	`919`	`next = connection->next;`
`920`		`- delete (connection);`
	`920`	`+ delete connection;`
`921`	`921`	`connection = next;`
`922`	`922`	`}`
`923`	`923`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1401,7 +1401,7 @@ void free_pb_stats(t_pb* pb) {`
`1401`	`1401`	`pb->pb_stats->num_pins_of_net_in_pb.clear();`
`1402`	`1402`
`1403`	`1403`	`if (pb->pb_stats->feasible_blocks) {`
`1404`		`- delete[](pb->pb_stats->feasible_blocks);`
	`1404`	`+ delete[] pb->pb_stats->feasible_blocks;`
`1405`	`1405`	`}`
`1406`	`1406`	`if (!pb->parent_pb) {`
`1407`	`1407`	`pb->pb_stats->transitive_fanout_candidates.clear();`