src/sn_network.c

   1 /**
   2  * libsortnetwork - src/sn_network.c
   3  * Copyright (C) 2008-2010  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <ff at octo.it>
  20  **/
  21
  22 #ifndef _ISOC99_SOURCE
  23 # define _ISOC99_SOURCE
  24 #endif
  25 #ifndef _POSIX_C_SOURCE
  26 # define _POSIX_C_SOURCE 200112L
  27 #endif
  28
  29 #if 0
  30 # define DPRINTF(...) fprintf (stderr, "sn_network: " __VA_ARGS__)
  31 #else
  32 # define DPRINTF(...) /**/
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <strings.h>
  39 #include <ctype.h>
  40 #include <assert.h>
  41 #include <errno.h>
  42
  43 #include "sn_network.h"
  44 #include "sn_random.h"
  45
  46 sn_network_t *sn_network_create (int inputs_num) /* {{{ */
  47 {
  48   sn_network_t *n;
  49
  50   n = (sn_network_t *) malloc (sizeof (sn_network_t));
  51   if (n == NULL)
  52     return (NULL);
  53   memset (n, '\0', sizeof (sn_network_t));
  54
  55   n->inputs_num = inputs_num;
  56
  57   return (n);
  58 } /* }}} sn_network_t *sn_network_create */
  59
  60 void sn_network_destroy (sn_network_t *n) /* {{{ */
  61 {
  62   if (n == NULL)
  63     return;
  64
  65   if (n->stages != NULL)
  66   {
  67     int i;
  68     for (i = 0; i < n->stages_num; i++)
  69     {
  70       sn_stage_destroy (n->stages[i]);
  71       n->stages[i] = NULL;
  72     }
  73     free (n->stages);
  74     n->stages = NULL;
  75   }
  76
  77   free (n);
  78 } /* }}} void sn_network_destroy */
  79
  80 sn_network_t *sn_network_create_odd_even_mergesort (int inputs_num) /* {{{ */
  81 {
  82   sn_network_t *n;
  83
  84   n = sn_network_create (inputs_num);
  85
  86   assert (inputs_num > 0);
  87   if (inputs_num == 1)
  88   {
  89     return (n);
  90   }
  91   if (inputs_num == 2)
  92   {
  93     sn_stage_t *s;
  94     sn_comparator_t c;
  95
  96     c.min = 0;
  97     c.max = 1;
  98
  99     s = sn_stage_create (/* depth = */ 0);
 100     sn_stage_comparator_add (s, &c);
 101     sn_network_stage_add (n, s);
 102
 103     return (n);
 104   }
 105   else
 106   {
 107     sn_network_t *n_left;
 108     sn_network_t *n_right;
 109     int inputs_left;
 110     int inputs_right;
 111
 112     inputs_left = inputs_num / 2;
 113     inputs_right = inputs_num - inputs_left;
 114
 115     n_left = sn_network_create_odd_even_mergesort (inputs_left);
 116     if (n_left == NULL)
 117       return (NULL);
 118
 119     n_right = sn_network_create_odd_even_mergesort (inputs_right);
 120     if (n_right == NULL)
 121     {
 122       sn_network_destroy (n_left);
 123       return (NULL);
 124     }
 125
 126     n = sn_network_combine_odd_even_merge (n_left, n_right);
 127
 128     sn_network_destroy (n_left);
 129     sn_network_destroy (n_right);
 130
 131     if (n != NULL)
 132       sn_network_compress (n);
 133
 134     return (n);
 135   }
 136 } /* }}} sn_network_t *sn_network_create_odd_even_mergesort */
 137
 138 int sn_network_stage_add (sn_network_t *n, sn_stage_t *s) /* {{{ */
 139 {
 140   sn_stage_t **temp;
 141
 142   if ((n == NULL) || (s == NULL))
 143     return (EINVAL);
 144
 145   temp = (sn_stage_t **) realloc (n->stages, (n->stages_num + 1)
 146       * sizeof (sn_stage_t *));
 147   if (temp == NULL)
 148     return (-1);
 149
 150   n->stages = temp;
 151   SN_STAGE_DEPTH (s) = n->stages_num;
 152   n->stages[n->stages_num] = s;
 153   n->stages_num++;
 154
 155   return (0);
 156 } /* }}} int sn_network_stage_add */
 157
 158 int sn_network_stage_remove (sn_network_t *n, int s_num) /* {{{ */
 159 {
 160   int nmemb = n->stages_num - (s_num + 1);
 161   sn_stage_t **temp;
 162
 163   if ((n == NULL) || (s_num >= n->stages_num))
 164     return (EINVAL);
 165
 166   sn_stage_destroy (n->stages[s_num]);
 167   n->stages[s_num] = NULL;
 168
 169   if (nmemb > 0)
 170   {
 171     memmove (n->stages + s_num, n->stages + (s_num + 1),
 172         nmemb * sizeof (sn_stage_t *));
 173     n->stages[n->stages_num - 1] = NULL;
 174   }
 175   n->stages_num--;
 176
 177   /* Free the unused memory */
 178   if (n->stages_num == 0)
 179   {
 180     free (n->stages);
 181     n->stages = NULL;
 182   }
 183   else
 184   {
 185     temp = (sn_stage_t **) realloc (n->stages,
 186         n->stages_num * sizeof (sn_stage_t *));
 187     if (temp == NULL)
 188       return (-1);
 189     n->stages = temp;
 190   }
 191
 192   return (0);
 193 } /* }}} int sn_network_stage_remove */
 194
 195 sn_network_t *sn_network_clone (const sn_network_t *n) /* {{{ */
 196 {
 197   sn_network_t *n_copy;
 198   int i;
 199
 200   n_copy = sn_network_create (n->inputs_num);
 201   if (n_copy == NULL)
 202     return (NULL);
 203
 204   for (i = 0; i < n->stages_num; i++)
 205   {
 206     sn_stage_t *s;
 207     int status;
 208
 209     s = sn_stage_clone (n->stages[i]);
 210     if (s == NULL)
 211       break;
 212
 213     status = sn_network_stage_add (n_copy, s);
 214     if (status != 0)
 215       break;
 216   }
 217
 218   if (i < n->stages_num)
 219   {
 220     sn_network_destroy (n_copy);
 221     return (NULL);
 222   }
 223
 224   return (n_copy);
 225 } /* }}} sn_network_t *sn_network_clone */
 226
 227 int sn_network_comparator_add (sn_network_t *n, /* {{{ */
 228     const sn_comparator_t *c)
 229 {
 230   sn_stage_t *s;
 231
 232   if ((n == NULL) || (c == NULL))
 233     return (EINVAL);
 234
 235   if (n->stages_num > 0)
 236   {
 237     s = n->stages[n->stages_num - 1];
 238
 239     if (sn_stage_comparator_check_conflict (s, c) == 0)
 240     {
 241       sn_stage_comparator_add (s, c);
 242       return (0);
 243     }
 244   }
 245
 246   s = sn_stage_create (n->stages_num);
 247   sn_stage_comparator_add (s, c);
 248   sn_network_stage_add (n, s);
 249
 250   return (0);
 251 } /* }}} int sn_network_comparator_add */
 252
 253 int sn_network_get_comparator_num (const sn_network_t *n) /* {{{ */
 254 {
 255   int num;
 256   int i;
 257
 258   if (n == NULL)
 259     return (-1);
 260
 261   num = 0;
 262   for (i = 0; i < n->stages_num; i++)
 263     num += n->stages[i]->comparators_num;
 264
 265   return (num);
 266 } /* }}} int sn_network_get_comparator_num */
 267
 268 int sn_network_show (sn_network_t *n) /* {{{ */
 269 {
 270   int i;
 271
 272   for (i = 0; i < n->stages_num; i++)
 273     sn_stage_show (n->stages[i]);
 274
 275   return (0);
 276 } /* }}} int sn_network_show */
 277
 278 int sn_network_invert (sn_network_t *n) /* {{{ */
 279 {
 280   int i;
 281
 282   if (n == NULL)
 283     return (EINVAL);
 284
 285   for (i = 0; i < n->stages_num; i++)
 286     sn_stage_invert (n->stages[i]);
 287
 288   return (0);
 289 } /* }}} int sn_network_invert */
 290
 291 int sn_network_shift (sn_network_t *n, int sw) /* {{{ */
 292 {
 293   int i;
 294
 295   if ((n == NULL) || (sw < 0))
 296     return (EINVAL);
 297
 298   if (sw == 0)
 299     return (0);
 300
 301   for (i = 0; i < n->stages_num; i++)
 302     sn_stage_shift (n->stages[i], sw, SN_NETWORK_INPUT_NUM (n));
 303
 304   return (0);
 305 } /* }}} int sn_network_shift */
 306
 307 int sn_network_compress (sn_network_t *n) /* {{{ */
 308 {
 309   int i;
 310   int j;
 311   int k;
 312
 313   for (i = 1; i < n->stages_num; i++)
 314   {
 315     sn_stage_t *s;
 316
 317     s = n->stages[i];
 318
 319     for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
 320     {
 321       sn_comparator_t *c = SN_STAGE_COMP_GET (s, j);
 322       int move_to = i;
 323
 324       for (k = i - 1; k >= 0; k--)
 325       {
 326         int conflict;
 327
 328         conflict = sn_stage_comparator_check_conflict (n->stages[k], c);
 329         if (conflict == 0)
 330         {
 331           move_to = k;
 332           continue;
 333         }
 334
 335         if (conflict == 2)
 336           move_to = -1;
 337         break;
 338       }
 339
 340       if (move_to < i)
 341       {
 342         if (move_to >= 0)
 343           sn_stage_comparator_add (n->stages[move_to], c);
 344         sn_stage_comparator_remove (s, j);
 345         j--;
 346       }
 347     }
 348   }
 349
 350   while ((n->stages_num > 0)
 351       && (SN_STAGE_COMP_NUM (n->stages[n->stages_num - 1]) == 0))
 352     sn_network_stage_remove (n, n->stages_num - 1);
 353
 354   return (0);
 355 } /* }}} int sn_network_compress */
 356
 357 int sn_network_normalize (sn_network_t *n) /* {{{ */
 358 {
 359   int i;
 360
 361   for (i = 0; i < n->stages_num; i++)
 362   {
 363     sn_stage_t *s;
 364     int j;
 365
 366     s = n->stages[i];
 367
 368     for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
 369     {
 370       sn_comparator_t *c;
 371       int min;
 372       int max;
 373
 374       c = SN_STAGE_COMP_GET (s, j);
 375
 376       min = c->min;
 377       max = c->max;
 378
 379       if (min > max)
 380       {
 381         int k;
 382
 383         for (k = i; k < n->stages_num; k++)
 384           sn_stage_swap (n->stages[k], min, max);
 385
 386         i = -1;
 387         break; /* for (j) */
 388       }
 389     } /* for (j = 0 .. #comparators) */
 390   } /* for (i = n->stages_num - 1 .. 0) */
 391
 392   return (0);
 393 } /* }}} int sn_network_normalize */
 394
 395 int sn_network_cut_at (sn_network_t *n, int input, /* {{{ */
 396     enum sn_network_cut_dir_e dir)
 397 {
 398   int i;
 399   int position = input;
 400
 401   for (i = 0; i < n->stages_num; i++)
 402   {
 403     sn_stage_t *s;
 404     int new_position;
 405
 406     s = n->stages[i];
 407     new_position = sn_stage_cut_at (s, position, dir);
 408
 409     if (position != new_position)
 410     {
 411       int j;
 412
 413       for (j = 0; j < i; j++)
 414         sn_stage_swap (n->stages[j], position, new_position);
 415     }
 416
 417     position = new_position;
 418   }
 419
 420   assert (((dir == DIR_MIN) && (position == 0))
 421       || ((dir == DIR_MAX) && (position == (n->inputs_num - 1))));
 422
 423   for (i = 0; i < n->stages_num; i++)
 424     sn_stage_remove_input (n->stages[i], position);
 425
 426   n->inputs_num--;
 427
 428   return (0);
 429 } /* }}} int sn_network_cut_at */
 430
 431 /* sn_network_concatenate
 432  *
 433  * `Glues' two networks together, resulting in a comparator network with twice
 434  * as many inputs but one that doesn't really sort anymore. It produces a
 435  * bitonic sequence, though, that can be used by the mergers below. */
 436 static sn_network_t *sn_network_concatenate (sn_network_t *n0, /* {{{ */
 437     sn_network_t *n1)
 438 {
 439   sn_network_t *n;
 440   int stages_num;
 441   int i;
 442   int j;
 443
 444   stages_num = (n0->stages_num > n1->stages_num)
 445     ? n0->stages_num
 446     : n1->stages_num;
 447
 448   n = sn_network_create (n0->inputs_num + n1->inputs_num);
 449   if (n == NULL)
 450     return (NULL);
 451
 452   for (i = 0; i < stages_num; i++)
 453   {
 454     sn_stage_t *s = sn_stage_create (i);
 455
 456     if (i < n0->stages_num)
 457       for (j = 0; j < SN_STAGE_COMP_NUM (n0->stages[i]); j++)
 458       {
 459         sn_comparator_t *c = SN_STAGE_COMP_GET (n0->stages[i], j);
 460         sn_stage_comparator_add (s, c);
 461       }
 462
 463     if (i < n1->stages_num)
 464       for (j = 0; j < SN_STAGE_COMP_NUM (n1->stages[i]); j++)
 465       {
 466         sn_comparator_t *c_orig = SN_STAGE_COMP_GET (n1->stages[i], j);
 467         sn_comparator_t  c_copy;
 468
 469         SN_COMP_MIN(&c_copy) = SN_COMP_MIN(c_orig) + n0->inputs_num;
 470         SN_COMP_MAX(&c_copy) = SN_COMP_MAX(c_orig) + n0->inputs_num;
 471
 472         sn_stage_comparator_add (s, &c_copy);
 473       }
 474
 475     sn_network_stage_add (n, s);
 476   }
 477
 478   return (n);
 479 } /* }}} sn_network_t *sn_network_concatenate */
 480
 481 static int sn_network_add_bitonic_merger_recursive (sn_network_t *n, /* {{{ */
 482     int low, int num)
 483 {
 484   sn_stage_t *s;
 485   int m;
 486   int i;
 487
 488   if (num == 1)
 489     return (0);
 490
 491   s = sn_stage_create (n->stages_num);
 492   if (s == NULL)
 493     return (-1);
 494
 495   m = num / 2;
 496
 497   for (i = low; i < (low + m); i++)
 498   {
 499     sn_comparator_t c;
 500
 501     c.min = i;
 502     c.max = i + m;
 503
 504     sn_stage_comparator_add (s, &c);
 505   }
 506
 507   sn_network_stage_add (n, s);
 508
 509   sn_network_add_bitonic_merger_recursive (n, low, m);
 510   sn_network_add_bitonic_merger_recursive (n, low + m, m);
 511
 512   return (0);
 513 } /* }}} int sn_network_add_bitonic_merger_recursive */
 514
 515 static int sn_network_add_bitonic_merger (sn_network_t *n) /* {{{ */
 516 {
 517 #if 0
 518   sn_stage_t *s;
 519   int m;
 520   int i;
 521
 522   s = sn_stage_create (n->stages_num);
 523   if (s == NULL)
 524     return (-1);
 525
 526   m = n->inputs_num / 2;
 527
 528   for (i = 0; i < m; i++)
 529   {
 530     sn_comparator_t c;
 531
 532     c.min = i;
 533     c.max = n->inputs_num - (i + 1);
 534
 535     sn_stage_comparator_add (s, &c);
 536   }
 537
 538   sn_network_stage_add (n, s);
 539
 540   sn_network_add_bitonic_merger_recursive (n, 0, m);
 541   sn_network_add_bitonic_merger_recursive (n, m, m);
 542 #else
 543   sn_network_add_bitonic_merger_recursive (n, 0, SN_NETWORK_INPUT_NUM (n));
 544 #endif
 545
 546   return (0);
 547 } /* }}} int sn_network_add_bitonic_merger */
 548
 549 static int sn_network_add_odd_even_merger (sn_network_t *n, /* {{{ */
 550     int *indizes_left, int indizes_left_num,
 551     int *indizes_right, int indizes_right_num)
 552 {
 553   int tmp_left[indizes_left_num];
 554   int tmp_left_num;
 555   int tmp_right[indizes_left_num];
 556   int tmp_right_num;
 557   int max_index;
 558   sn_stage_t *s;
 559   int i;
 560
 561   if ((indizes_left_num == 0) || (indizes_right_num == 0))
 562   {
 563     return (0);
 564   }
 565   else if ((indizes_left_num == 1) && (indizes_right_num == 1))
 566   {
 567     sn_comparator_t c;
 568     sn_stage_t *s;
 569
 570     c.min = *indizes_left;
 571     c.max = *indizes_right;
 572
 573     s = sn_stage_create (n->stages_num);
 574     if (s == NULL)
 575       return (-1);
 576
 577     sn_stage_comparator_add (s, &c);
 578     sn_network_stage_add (n, s);
 579
 580     return (0);
 581   }
 582
 583   /* Merge odd sequences */
 584   tmp_left_num = (indizes_left_num + 1) / 2;
 585   for (i = 0; i < tmp_left_num; i++)
 586     tmp_left[i] = indizes_left[2 * i];
 587
 588   tmp_right_num = (indizes_right_num + 1) / 2;
 589   for (i = 0; i < tmp_right_num; i++)
 590     tmp_right[i] = indizes_right[2 * i];
 591
 592   sn_network_add_odd_even_merger (n,
 593       tmp_left, tmp_left_num,
 594       tmp_right, tmp_right_num);
 595
 596   /* Merge even sequences */
 597   tmp_left_num = indizes_left_num / 2;
 598   for (i = 0; i < tmp_left_num; i++)
 599     tmp_left[i] = indizes_left[(2 * i) + 1];
 600
 601   tmp_right_num = indizes_right_num / 2;
 602   for (i = 0; i < tmp_right_num; i++)
 603     tmp_right[i] = indizes_right[(2 * i) + 1];
 604
 605   sn_network_add_odd_even_merger (n,
 606       tmp_left, tmp_left_num,
 607       tmp_right, tmp_right_num);
 608
 609   /* Apply ``comparison-interchange'' operations. */
 610   s = sn_stage_create (n->stages_num);
 611
 612   max_index = indizes_left_num + indizes_right_num;
 613   if ((max_index % 2) == 0)
 614     max_index -= 3;
 615   else
 616     max_index -= 2;
 617
 618   for (i = 1; i <= max_index; i += 2)
 619   {
 620     sn_comparator_t c;
 621
 622     if (i < indizes_left_num)
 623       c.min = indizes_left[i];
 624     else
 625       c.min = indizes_right[i - indizes_left_num];
 626
 627     if ((i + 1) < indizes_left_num)
 628       c.max = indizes_left[i + 1];
 629     else
 630       c.max = indizes_right[i + 1 - indizes_left_num];
 631
 632     sn_stage_comparator_add (s, &c);
 633   }
 634
 635   sn_network_stage_add (n, s);
 636
 637   return (0);
 638 } /* }}} int sn_network_add_odd_even_merger */
 639
 640 static sn_network_t *sn_network_combine_bitonic_shift (sn_network_t *n0, /* {{{ */
 641     sn_network_t *n1, int do_shift)
 642 {
 643   sn_network_t *n;
 644   sn_network_t *n1_clone;
 645   int shift;
 646
 647   n1_clone = sn_network_clone (n1);
 648   if (n1_clone == NULL)
 649     return (NULL);
 650
 651   sn_network_invert (n1_clone);
 652
 653   n = sn_network_concatenate (n0, n1_clone);
 654   if (n == NULL)
 655     return (NULL);
 656
 657   sn_network_destroy (n1_clone);
 658
 659   if (do_shift)
 660     shift = sn_bounded_random (0, SN_NETWORK_INPUT_NUM (n) - 1);
 661   else
 662     shift = 0;
 663
 664   if (shift > 0)
 665   {
 666     DPRINTF ("sn_network_combine_bitonic_shift: Shifting by %i.\n", shift);
 667     sn_network_shift (n, shift);
 668   }
 669
 670   sn_network_add_bitonic_merger (n);
 671
 672   return (n);
 673 } /* }}} sn_network_t *sn_network_combine_bitonic_shift */
 674
 675 sn_network_t *sn_network_combine_bitonic_merge (sn_network_t *n0, /* {{{ */
 676     sn_network_t *n1)
 677 {
 678   return (sn_network_combine_bitonic_shift (n0, n1, /* do_shift = */ 0));
 679 } /* }}} sn_network_t *sn_network_combine_bitonic_merge */
 680
 681 sn_network_t *sn_network_combine_odd_even_merge (sn_network_t *n0, /* {{{ */
 682     sn_network_t *n1)
 683 {
 684   sn_network_t *n;
 685   int indizes_left[n0->inputs_num];
 686   int indizes_left_num;
 687   int indizes_right[n1->inputs_num];
 688   int indizes_right_num;
 689   int status;
 690   int i;
 691
 692   indizes_left_num = n0->inputs_num;
 693   indizes_right_num = n1->inputs_num;
 694   for (i = 0; i < indizes_left_num; i++)
 695     indizes_left[i] = i;
 696   for (i = 0; i < indizes_right_num; i++)
 697     indizes_right[i] = indizes_left_num + i;
 698
 699   n = sn_network_concatenate (n0, n1);
 700   if (n == NULL)
 701     return (NULL);
 702
 703   status = sn_network_add_odd_even_merger (n,
 704       indizes_left, indizes_left_num,
 705       indizes_right, indizes_right_num);
 706   if (status != 0)
 707   {
 708     sn_network_destroy (n);
 709     return (NULL);
 710   }
 711
 712   sn_network_compress (n);
 713   return (n);
 714 } /* }}} sn_network_t *sn_network_combine_odd_even_merge */
 715
 716 sn_network_t *sn_network_combine (sn_network_t *n0, /* {{{ */
 717     sn_network_t *n1)
 718 {
 719   return (sn_network_combine_odd_even_merge (n0, n1));
 720 } /* }}} sn_network_t *sn_network_combine */
 721
 722 int sn_network_sort (sn_network_t *n, int *values) /* {{{ */
 723 {
 724   int status;
 725   int i;
 726
 727   status = 0;
 728   for (i = 0; i < n->stages_num; i++)
 729   {
 730     status = sn_stage_sort (n->stages[i], values);
 731     if (status != 0)
 732       return (status);
 733   }
 734
 735   return (status);
 736 } /* }}} int sn_network_sort */
 737
 738 int sn_network_brute_force_check (sn_network_t *n) /* {{{ */
 739 {
 740   int test_pattern[n->inputs_num];
 741   int values[n->inputs_num];
 742   int status;
 743   int i;
 744
 745   memset (test_pattern, 0, sizeof (test_pattern));
 746   while (42)
 747   {
 748     int previous;
 749     int overflow;
 750
 751     /* Copy the current pattern and let the network sort it */
 752     memcpy (values, test_pattern, sizeof (values));
 753     status = sn_network_sort (n, values);
 754     if (status != 0)
 755       return (status);
 756
 757     /* Check if the array is now sorted. */
 758     previous = values[0];
 759     for (i = 1; i < n->inputs_num; i++)
 760     {
 761       if (previous > values[i])
 762         return (1);
 763       previous = values[i];
 764     }
 765
 766     /* Generate the next test pattern */
 767     overflow = 1;
 768     for (i = 0; i < n->inputs_num; i++)
 769     {
 770       if (test_pattern[i] == 0)
 771       {
 772         test_pattern[i] = 1;
 773         overflow = 0;
 774         break;
 775       }
 776       else
 777       {
 778         test_pattern[i] = 0;
 779         overflow = 1;
 780       }
 781     }
 782
 783     /* Break out of the while loop if we tested all possible patterns */
 784     if (overflow == 1)
 785       break;
 786   } /* while (42) */
 787
 788   /* All tests successfull */
 789   return (0);
 790 } /* }}} int sn_network_brute_force_check */
 791
 792 sn_network_t *sn_network_read (FILE *fh) /* {{{ */
 793 {
 794   sn_network_t *n;
 795   char buffer[64];
 796
 797   int opt_inputs = 0;
 798
 799   while (fgets (buffer, sizeof (buffer), fh) != NULL)
 800   {
 801     char *str_key = buffer;
 802     char *str_value = NULL;
 803     int   buffer_len = strlen (buffer);
 804
 805     while ((buffer_len > 0) && ((buffer[buffer_len - 1] == '\n')
 806           || (buffer[buffer_len - 1] == '\r')))
 807     {
 808       buffer_len--;
 809       buffer[buffer_len] = '\0';
 810     }
 811     if (buffer_len == 0)
 812       break;
 813
 814     str_value = strchr (buffer, ':');
 815     if (str_value == NULL)
 816     {
 817       printf ("Cannot parse line: %s\n", buffer);
 818       continue;
 819     }
 820
 821     *str_value = '\0'; str_value++;
 822     while ((*str_value != '\0') && (isspace (*str_value) != 0))
 823       str_value++;
 824
 825     if (strcasecmp ("Inputs", str_key) == 0)
 826       opt_inputs = atoi (str_value);
 827     else
 828       printf ("Unknown key: %s\n", str_key);
 829   } /* while (fgets) */
 830
 831   if (opt_inputs < 2)
 832     return (NULL);
 833
 834   n = sn_network_create (opt_inputs);
 835
 836   while (42)
 837   {
 838     sn_stage_t *s;
 839
 840     s = sn_stage_read (fh);
 841     if (s == NULL)
 842       break;
 843
 844     sn_network_stage_add (n, s);
 845   }
 846
 847   if (SN_NETWORK_STAGE_NUM (n) < 1)
 848   {
 849     sn_network_destroy (n);
 850     return (NULL);
 851   }
 852
 853   return (n);
 854 } /* }}} sn_network_t *sn_network_read */
 855
 856 sn_network_t *sn_network_read_file (const char *file) /* {{{ */
 857 {
 858   sn_network_t *n;
 859   FILE *fh;
 860
 861   fh = fopen (file, "r");
 862   if (fh == NULL)
 863     return (NULL);
 864
 865   n = sn_network_read (fh);
 866
 867   fclose (fh);
 868
 869   return (n);
 870 } /* }}} sn_network_t *sn_network_read_file */
 871
 872 int sn_network_write (sn_network_t *n, FILE *fh) /* {{{ */
 873 {
 874   int i;
 875
 876   fprintf (fh, "Inputs: %i\n", n->inputs_num);
 877   fprintf (fh, "\n");
 878
 879   for (i = 0; i < n->stages_num; i++)
 880     sn_stage_write (n->stages[i], fh);
 881
 882   return (0);
 883 } /* }}} int sn_network_write */
 884
 885 int sn_network_write_file (sn_network_t *n, const char *file) /* {{{ */
 886 {
 887   int status;
 888   FILE *fh;
 889
 890   fh = fopen (file, "w");
 891   if (fh == NULL)
 892     return (-1);
 893
 894   status = sn_network_write (n, fh);
 895
 896   fclose (fh);
 897
 898   return (status);
 899 } /* }}} int sn_network_write_file */
 900
 901 int sn_network_serialize (sn_network_t *n, char **ret_buffer, /* {{{ */
 902     size_t *ret_buffer_size)
 903 {
 904   char *buffer;
 905   size_t buffer_size;
 906   int status;
 907   int i;
 908
 909   buffer = *ret_buffer;
 910   buffer_size = *ret_buffer_size;
 911
 912 #define SNPRINTF_OR_FAIL(...) \
 913   status = snprintf (buffer, buffer_size, __VA_ARGS__); \
 914   if ((status < 1) || (((size_t) status) >= buffer_size)) \
 915     return (-1); \
 916   buffer += status; \
 917   buffer_size -= status;
 918
 919   SNPRINTF_OR_FAIL ("Inputs: %i\r\n\r\n", n->inputs_num);
 920
 921   for (i = 0; i < n->stages_num; i++)
 922   {
 923     status = sn_stage_serialize (n->stages[i], &buffer, &buffer_size);
 924     if (status != 0)
 925       return (status);
 926   }
 927
 928   *ret_buffer = buffer;
 929   *ret_buffer_size = buffer_size;
 930   return (0);
 931 } /* }}} int sn_network_serialize */
 932
 933 sn_network_t *sn_network_unserialize (char *buffer, /* {{{ */
 934     size_t buffer_size)
 935 {
 936   sn_network_t *n;
 937   int opt_inputs = 0;
 938
 939   if (buffer_size == 0)
 940     return (NULL);
 941
 942   /* Read options first */
 943   while (buffer_size > 0)
 944   {
 945     char *endptr;
 946     char *str_key;
 947     char *str_value;
 948     char *line;
 949     int   line_len;
 950
 951     line = buffer;
 952     endptr = strchr (buffer, '\n');
 953     if (endptr == NULL)
 954       return (NULL);
 955
 956     *endptr = 0;
 957     endptr++;
 958     buffer = endptr;
 959     line_len = strlen (line);
 960
 961     if ((line_len > 0) && (line[line_len - 1] == '\r'))
 962     {
 963       line[line_len - 1] = 0;
 964       line_len--;
 965     }
 966
 967     if (line_len == 0)
 968       break;
 969
 970     str_key = line;
 971     str_value = strchr (line, ':');
 972     if (str_value == NULL)
 973     {
 974       printf ("Cannot parse line: %s\n", line);
 975       continue;
 976     }
 977
 978     *str_value = '\0'; str_value++;
 979     while ((*str_value != '\0') && (isspace (*str_value) != 0))
 980       str_value++;
 981
 982     if (strcasecmp ("Inputs", str_key) == 0)
 983       opt_inputs = atoi (str_value);
 984     else
 985       printf ("Unknown key: %s\n", str_key);
 986   } /* while (fgets) */
 987
 988   if (opt_inputs < 2)
 989     return (NULL);
 990
 991   n = sn_network_create (opt_inputs);
 992
 993   while (42)
 994   {
 995     sn_stage_t *s;
 996
 997     s = sn_stage_unserialize (&buffer, &buffer_size);
 998     if (s == NULL)
 999       break;
1000
1001     sn_network_stage_add (n, s);
1002   }
1003
1004   if (SN_NETWORK_STAGE_NUM (n) < 1)
1005   {
1006     sn_network_destroy (n);
1007     return (NULL);
1008   }
1009
1010   return (n);
1011 } /* }}} sn_network_t *sn_network_unserialize */
1012
1013 /* vim: set sw=2 sts=2 et fdm=marker : */