14 files changed, 747 insertions, 829 deletions

diff --git a/dis/Field/DISstressmarkRNG.h b/dis/Field/DISstressmarkRNG.h
index 4aa2620..6243606 100644
--- a/dis/Field/DISstressmarkRNG.h
+++ b/dis/Field/DISstressmarkRNG.h
@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <math.h>
 
 #define IA 16807
diff --git a/dis/Field/field.c b/dis/Field/field.c
index f83a403..248f779 100644
--- a/dis/Field/field.c
+++ b/dis/Field/field.c
@@ -1,28 +1,27 @@
 /*
  *  Sample code for the DIS Field Stressmark
  *
- * This source code is the completely correct source code based on 
- * the example codes provided by Atlantic Aerospace Division, Titan 
+ * This source code is the completely correct source code based on
+ * the example codes provided by Atlantic Aerospace Division, Titan
  * Systems Corporation, 2000.
- * 
- * If you just compile and generate the executables from this source 
- * code, this code would be enough. However, if you wish to get a complete 
+ *
+ * If you just compile and generate the executables from this source
+ * code, this code would be enough. However, if you wish to get a complete
  * understanding of this stressmark, it is strongly suggested that you
  * read the Benchmark Analysis and Specifications Document Version 1.0
  * before going on since the detailed comments are given in this documents.
  * the comments are not repeated here.
  */
 
-#include <stdio.h>
-#include <time.h>
-#include <assert.h>
-#include <stdlib.h>
 #include "DISstressmarkRNG.h"
 #include "extra.h"
-
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
 
 #define MIN_FIELD_SIZE 16
-#define MAX_FIELD_SIZE (16777216*4) // This has been quadrupled from original
+#define MAX_FIELD_SIZE (16777216 * 4) // This has been quadrupled from original
 #define MIN_SEED -2147483647
 #define MAX_SEED -1
 #define MIN_MOD_OFFSET 0
@@ -39,7 +38,7 @@
  * main()
  */
 
-int main(int argc, char** argv){
+int main(int argc, char **argv) {
   SET_UP
   unsigned char *field;
   unsigned int f;
@@ -48,17 +47,17 @@ int main(int argc, char** argv){
   unsigned int n;
 
   time_t startTime, endTime;
- 
-  struct tokenS{
-  unsigned char delimiter[MAX_TOKEN_LENGTH];
-  unsigned char length; 
-    struct statisticS{
+
+  struct tokenS {
+    unsigned char delimiter[MAX_TOKEN_LENGTH];
+    unsigned char length;
+    struct statisticS {
       unsigned int count;
       unsigned char min;
       unsigned char sum;
-    }stat[MAX_SUBFIELDS];
+    } stat[MAX_SUBFIELDS];
     unsigned char subfields;
-  }token[MAX_TOKENS];
+  } token[MAX_TOKENS];
 
   unsigned int l;
 
@@ -68,91 +67,92 @@ int main(int argc, char** argv){
   assert((seed >= MIN_SEED) && (seed <= MAX_SEED));
   assert((mod_offset >= MIN_MOD_OFFSET) && (mod_offset <= MAX_MOD_OFFSET));
   assert((n >= MIN_TOKENS) && (n <= MAX_TOKENS));
-    for (l=0; l<n; l++){
-      int x;
-      int index;
-      index = 0;
-      assert(fscanf(stdin,"%x", &x) == 1);
-      while(x!=0){
-        assert((x >= MIN_TOKEN_VALUE) && (x <= MAX_TOKEN_VALUE));
-          token[l].delimiter[index] = (unsigned char )x;
-        index++;
-        assert(fscanf(stdin,"%x", &x) == 1);
-      }
-      assert((index >= MIN_TOKEN_LENGTH) && (index <= MAX_TOKEN_LENGTH));
-        token[l].length = index;
+  for (l = 0; l < n; l++) {
+    int x;
+    int index;
+    index = 0;
+    assert(fscanf(stdin, "%x", &x) == 1);
+    while (x != 0) {
+      assert((x >= MIN_TOKEN_VALUE) && (x <= MAX_TOKEN_VALUE));
+      token[l].delimiter[index] = (unsigned char)x;
+      index++;
+      assert(fscanf(stdin, "%x", &x) == 1);
     }
+    assert((index >= MIN_TOKEN_LENGTH) && (index <= MAX_TOKEN_LENGTH));
+    token[l].length = index;
+  }
 
-  if ((field = (unsigned char*)malloc(f*sizeof(unsigned char))) == NULL)
+  if ((field = (unsigned char *)malloc(f * sizeof(unsigned char))) == NULL)
     return (-1);
 
   randInit(seed);
-  for (l =0; l<f; l++){
+  for (l = 0; l < f; l++) {
     field[l] = randInt(MIN_TOKEN_VALUE, MAX_TOKEN_VALUE);
   }
-  
+
   startTime = time(NULL);
   START_LOOP
 
-  for (l =0; l<n; l++){
+  for (l = 0; l < n; l++) {
     unsigned int index;
-    
+
     token[l].subfields = 0;
     token[l].stat[0].count = 0;
     token[l].stat[0].sum = 0;
     token[l].stat[0].min = MAX_TOKEN_VALUE;
 
     index = 0;
-    while ((index < f) && (token[l].subfields < MAX_SUBFIELDS)){
+    while ((index < f) && (token[l].subfields < MAX_SUBFIELDS)) {
       unsigned char offset;
       offset = 0;
-      while ((field[index+offset] == token[l].delimiter[offset]) &&
-             (offset < token[l].length)){
-        offset++;
+      while ((field[index + offset] == token[l].delimiter[offset]) &&
+             (offset < token[l].length)) {
+        offset++;
       }
 
-      if (offset == token[l].length){
-        for (offset=0; offset<token[l].length; offset++){
-          field[index+offset] = (field[index+offset] + 
-                                 field[(index+offset+mod_offset) % f])
-                                 %(MAX_TOKEN_VALUE+1);
-        }
-        index += token[l].length-1;
-        token[l].subfields++;
-        token[l].stat[token[l].subfields].count = 0;
-        token[l].stat[token[l].subfields].sum = 0;
-        token[l].stat[token[l].subfields].min = MAX_TOKEN_VALUE;
-      }                        
-                    
-        else{
-        token[l].stat[token[l].subfields].count++;
+      if (offset == token[l].length) {
+        for (offset = 0; offset < token[l].length; offset++) {
+          field[index + offset] = (field[index + offset] +
+                                   field[(index + offset + mod_offset) % f]) %
+                                  (MAX_TOKEN_VALUE + 1);
+        }
+        index += token[l].length - 1;
+        token[l].subfields++;
+        token[l].stat[token[l].subfields].count = 0;
+        token[l].stat[token[l].subfields].sum = 0;
+        token[l].stat[token[l].subfields].min = MAX_TOKEN_VALUE;
+      }
+
+      else {
+        token[l].stat[token[l].subfields].count++;