WebSVN – wimsdev – Diff – /trunk/wims/src/Misc/checkmol/checkmolc.c

+}
 static void
 init_globals ()
+{
-  int i;
+  /*int i;*/
   opt_verbose = false;
   opt_debug = false;
   opt_exact = false;
   opt_stdin = false;
    */
   memset (mstat, 0, sizeof (molstat_rec));      /* v0.3k */
+}
+#if 0
 static void
 debugoutput (dstr)
      char *dstr;
+{
   if (opt_debug)
     printf ("%s\n", dstr);
+}
+#endif
 static void
 left_trim (trimstr)
      char *trimstr;
+{
      char *trimstr;
+{
   char numstr[256];
   char auxstr[256];
   int auxint = 0;
-  int code;
+ /* int code;*/
   char STR1[256];
   strcpy (numstr, "-+0123456789");
   *auxstr = '\0';
   while (*trimstr != '\0' && (trimstr[0] == ' ' || trimstr[0] == TAB))
          (strpos2 (numstr, (sprintf (STR1, "%c", trimstr[0]), STR1), 1) > 0))
+    {
       sprintf (auxstr + strlen (auxstr), "%c", trimstr[0]);
       strdelete (trimstr, 1, 1);
+    }
-  code = (sscanf (auxstr, "%d", &auxint) == 0);
+ /* code = (sscanf (auxstr, "%d", &auxint) == 0);*/
   return auxint;
+}
 static int
 path_pos (int id, int *a_path)
   if (n_bonds <= 0)
     return b_id;
   FORLIM = n_bonds;
   for (i = 1; i <= FORLIM; i++)
+    {
-      if (bond[i - 1].a1 == ba1 && bond[i - 1].a2 == ba2 ||
+      if ((bond[i - 1].a1 == ba1 && bond[i - 1].a2 == ba2) ||
-          bond[i - 1].a1 == ba2 && bond[i - 1].a2 == ba1)
+          (bond[i - 1].a1 == ba2 && bond[i - 1].a2 == ba1))
         b_id = i;
+    }
   return b_id;
 }
 static void
 clear_atom_tags ()
 {
   int i, FORLIM;
   if (n_atoms > 0)
     {
       FORLIM = n_atoms;
       for (i = 0; i < FORLIM; i++)
         atom[i].tag = false;
     }
+}
+#if 0
 static void
 set_atom_tags ()
+{
   int i, FORLIM;
   if (n_atoms > 0)
+    {
       FORLIM = n_atoms;
       for (i = 0; i < FORLIM; i++)
         atom[i].tag = true;
+    }
+}
+#endif
 static void
 order_ringpath (int *r_path)
+{
   /* order should be: array starts with atom of lowest number, followed by neighbor atom with lower number */
   int i, pl, a_ref, a_left, a_right, a_tmp;
   p.y = p1.y + p2.y;
   p.z = p1.z + p2.z;
   return p;
+}
+#if 0
 static void
 vec2origin (p1, p2)
      p_3d *p1, *p2;
+{
   p_3d p;
   p = subtract_3d (*p2, *p1);
   *p2 = p;
   p1->x = 0.0;
   p1->y = 0.0;
   p1->z = 0.0;
 }
+#endif
 static double
 scalar_prod (p1, p2, p3)
      p_3d p1, p2, p3;
+{
   p_3d p;
   double res;
   p = subtract_3d (p2, p1);
   p2 = p;
   p = subtract_3d (p3, p1);
   p3 = p;
   p1.x = 0.0;
   p1.y = 0.0;
+}
 static p_3d
 cross_prod (p1, p2, p3)
      p_3d p1, p2, p3;
 {
   p_3d p, orig_p1;
   orig_p1 = p1;
   p = subtract_3d (p2, p1);
   p2 = p;
      p_3d p1, p2, p3;
+{
   p_3d lp1, lp2, lp3, p;
   double res = 0.0;
   double magn_1, magn_2, cos_phi;
   lp1 = p1;
   lp2 = p2;
   lp3 = p3;
   p = subtract_3d (lp2, lp1);
   lp2 = p;
   printf ("n_rad:      number of radicals\n");
   /*$ENDIF */
+}
+#if 0
-/*static void parse_args()
+static void parse_args()
+{
   int p;
   char parstr[256];
   char tmpstr[256];
   int l;
   *tmpstr = '\0';
   opt_none = true;
   if (progmode == pmCheckMol) {
     for (p = 1; p < P_argc; p++) {
       strcpy(parstr, P_argv[p]);
-      if (!strcmp(parstr, "-l")) {   /* new in v0.3l
+      if (!strcmp(parstr, "-l")) {   /* new in v0.3l */
         list_molstat_codes();
         _Escape(0);
+      }
       if (p < P_argc - 1) {
         if (strpos2(parstr, "-", 1) == 1 && p < P_argc - 1) {
             l++;
           if (strpos2(tmpstr, "D", 1) > 0)
             l++;
           if (strpos2(tmpstr, "r", 1) > 0)
             l++;
-          if (strpos2(tmpstr, "M", 1) > 0)   /* new in v0.3
+          if (strpos2(tmpstr, "M", 1) > 0)   /* new in v0.3 */
             l++;
           if (strlen(tmpstr) > l + 2) {
             show_usage();
             _Escape(1);
+          }
           if (strpos2(tmpstr, "M", 1) > 0)
             opt_metalrings = true;
           if (strpos2(tmpstr, "v", 1) > 0)
             opt_verbose = true;
 /* p2c: checkmol.pas, line 1261:
- * Note: Turbo Pascal conditional compilation directive was ignored [218]
+ * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug
           if (strpos2(tmpstr, "D", 1) > 0)
             opt_debug = true;
-          /*$ENDIF
+          $ENDIF*/
           if (strpos2(tmpstr, "e", 1) > 0)
             opt_text = true;
           else {
             if (strpos2(tmpstr, "d", 1) > 0)
               opt_text_de = true;
 /* p2c: checkmol.pas, line 1329:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
           /*$IFDEF debug
              if (strpos2(parstr, "D", 1) > 1)
              opt_debug = true;
-             /*$ENDIF
+             $ENDIF*/
              if (strpos2(parstr, "x", 1) > 1)
              opt_exact = true;
-             if (strpos2(parstr, "s", 1) > 1)   /* new in v0.2f
+             if (strpos2(parstr, "s", 1) > 1)   /* new in v0.2f */
              opt_strict = true;
              if (strpos2(parstr, "m", 1) > 1)
              opt_molout = true;
              if (strpos2(parstr, "r", 1) > 1)
              opt_rs = rs_ssr;
-             if (strpos2(parstr, "M", 1) > 0)   /* new in v0.3
+             if (strpos2(parstr, "M", 1) > 0)   /* new in v0.3 */
              opt_metalrings = true;
-             if (strpos2(parstr, "g", 1) > 0)   /* new in v0.3d
+             if (strpos2(parstr, "g", 1) > 0)   /* new in v0.3d */
              opt_geom = true;
-             if (strpos2(parstr, "G", 1) > 0)   /* new in v0.3f
+             if (strpos2(parstr, "G", 1) > 0)   /* new in v0.3f */
              opt_chiral = true;
-             if (strpos2(parstr, "f", 1) > 0) {   /* new in v0.3m
+             if (strpos2(parstr, "f", 1) > 0) {   /* new in v0.3m */
              opt_fp = true;
              fpformat = fpf_boolean;
+             }
-             if (strpos2(parstr, "F", 1) > 0) {   /* new in v0.3m
+             if (strpos2(parstr, "F", 1) > 0) {   /* new in v0.3m */
              opt_fp = true;
              fpformat = fpf_decimal;
+             }
              if (strpos2(parstr, "h", 1) > 1) {
              show_usage();
              if (p == P_argc - 1) {
              if (strcmp(parstr, "-"))
              strcpy(molfilename, parstr);
              else
              opt_stdin = true;
              }
              }
-             if (opt_geom)   /* v0.3d
+             if (opt_geom)   /* v0.3d */
              ez_search = true;
-             if (opt_chiral)   /* v0.3f
+             if (opt_chiral)   /* v0.3f */
              rs_search = true;
              if (opt_chiral && opt_strict && (opt_exact || opt_fp))
-             /* new in v0.3j, v0.3m
+             /* new in v0.3j, v0.3m */
              rs_strict = true;
-             if (opt_fp) {   /* v0.3m
+             if (opt_fp) {   /* v0.3m */
              opt_molout = false;
              opt_exact = false;
+             }
-             }  /* progmode = pmMatchMol
+             }  /* progmode = pmMatchMol */
-             ringsearch_mode = opt_rs;   /* v0.3i
+             ringsearch_mode = opt_rs;   /* v0.3i */
              }
-           */
+#endif
 static void
 parse_args (int argc, char *argv[])
+{
   short p;
   *tmpstr = '\0';
   opt_none = true;
   *molfilename = '\0';
   *ndl_molfilename = '\0';
   if (progmode == pmCheckMol)
     {
       for (p = 1; p <= argc - 1; p++)
         {
           strcpy (parstr, argv[p]);
           if (!strcmp (parstr, "-l"))
             {                   /* new in v0.3l */
               list_molstat_codes ();
               exit (0);
+            }
                     l++;
                   if (strpos2 (tmpstr, "D", 1) > 0)
                     l++;
                   if (strpos2 (tmpstr, "r", 1) > 0)
                     l++;
-                  /*if (strpos2 (tmpstr, "a", 1) > 0)   /* 0.3x
+                  /*if (strpos2 (tmpstr, "a", 1) > 0)   // 0.3x
                      l++; */
                   if (strpos2 (tmpstr, "M", 1) > 0)     /* new in v0.3 */
                     l++;
                   if (strlen (tmpstr) > l + 2)
                     {
                       show_usage ();
                       exit (1);
                     }
                   opt_none = false;
                   if (strpos2 (tmpstr, "M", 1) > 0)
                     opt_metalrings = true;
                   if (strpos2 (tmpstr, "v", 1) > 0)
                     opt_verbose = true;
                       if (strpos2 (tmpstr, "x", 1) > 0)
                         opt_molstat = true;
                       if (strpos2 (tmpstr, "r", 1) > 0)
                         opt_rs = rs_ssr;
                       /* if (strpos2 (tmpstr, "a", 1) > 0)
-                         opt_chg = true; /* 0.3x  */
+                         opt_chg = true; */ /* 0.3x  */
                       if (strpos2 (tmpstr, "X", 1) > 0)
+                        {
                           opt_molstat = true;
                           opt_molstat_X = true;
+                        }
                           opt_molstat = false;
                           opt_xmdlout = true;
+                        }
+                    }
                   strcpy (molfilename, tmpstr);
                 }
             }
           else
+            {
               if (strpos2 (parstr, "-", 1) == 1)
+                {
                   if (strlen (parstr) > 1)
+                }
               else
                 strcpy (ndl_molfilename, parstr);
+            }
           if (p == argc - 2)
             {
               if (strpos2 (parstr, "-", 1) != 1)
                 strcpy (ndl_molfilename, parstr);
+            }
           if (p == argc - 1)
+            {
           opt_molout = false;
           opt_exact = false;
+        }
     }                           /* progmode = pmMatchMol */
   ringsearch_mode = opt_rs;     /* v0.3i */
 }
 /*============== input-related functions & procedures ===================== */
 static char *
 get_filetype (Result, f)
+    {
       free (ndl_atom);
       ndl_atom = NULL;          /* added in v0.3j */
+    }
   if (ndl_bond != NULL)
     {
       free (ndl_bond);
       ndl_bond = NULL;          /* added in v0.3j */
+    }
   if (ndl_ring != NULL)
+    {
   ndl_n_atoms = 0;
   ndl_n_bonds = 0;
   ndl_n_rings = 0;
+}
+#if 0
 static void
 zap_tmp ()
+{
   /* try */
   if (tmp_atom != NULL)
     {
       free (tmp_atom);
       tmp_atom = NULL;          /* added in v0.3j */
     }
   if (tmp_bond != NULL)
+    {
       free (tmp_bond);
       tmp_bond = NULL;          /* added in v0.3j */
+    }
      on e:Einvalidpointer do begin end;
      end; */
   tmp_n_atoms = 0;
   tmp_n_bonds = 0;
   tmp_n_rings = 0;
 }
+#endif
 static boolean
 is_heavyatom (id)
      int id;
+{
   if (!strcmp (el, "DU") || !strcmp (el, "LP"))
     return false;
   /*if (progmode == pmCheckMol && !strcmp (el, "H ")
      && atom[id - 1].nucleon_number < 2)
-     return false;              /* 0.3x  */
+     return false;               0.3x  */
   if (!strcmp (el, "H "))       /* 0.3 p */
+    {
       if (progmode == pmMatchMol && !opt_iso)
+        {
           return false;
           if (!strcmp (ndl_atom[ba - 1].atype, "C2 ") &&
               !strcmp (ndl_atom[ba2 - 1].atype, "C2 ")
               && ndl_bond[i].btype == 'D' && ndl_bond[i].arom == false)
             res = true;
+        }
     }
   return res;
+}
 static boolean
   /* preliminary version; should be extended to element/atomtype */
   int res = 1;
   if (!strcmp (a_el, "H "))
     res = 1;
-  /*if (!strcmp (a_el, "D "))   /* v0.3n
+  /*if (!strcmp (a_el, "D "))   // v0.3n
      res = 1; */
   if (!strcmp (a_el, "C "))
     res = 4;
   if (!strcmp (a_el, "N "))
     res = 3;
+{
   char elemstr[256];
   if (!strcmp (oldtype, "H   "))
     strcpy (elemstr, "H ");
-  /* if (!strcmp (oldtype, "D   "))      /* v0.3n
+  /* if (!strcmp (oldtype, "D   "))  // v0.3n
      strcpy (elemstr, "D "); */
   if (!strcmp (oldtype, "CAR "))
     strcpy (elemstr, "C ");
   if (!strcmp (oldtype, "C2  "))
     strcpy (elemstr, "C ");
     strcpy (elemstr, "??");
   if (elemstr[0] == '*')
     strcpy (elemstr, "??");
   return strcpy (Result, elemstr);
+}
 static void
 read_molfile (mfilename)
      char *mfilename;
+{
   char rline[256], tmpstr[256];
   char xstr[256], ystr[256], zstr[256], chgstr[256];
   float xval, yval, zval, chgval;
   char a1str[256], a2str[256], elemstr[256];
   int a1val, a2val, ri;
   char STR1[256];
   int FORLIM;
   atom_rec *WITH;
   bond_rec *WITH1;
   if (n_atoms > 0)
     zap_molecule ();
   ri = li;
   strcpy (rline, molbuf[ri - 1]);
   sprintf (tmpstr, "%.5s", rline);
 static void
 read_charges (chgstring_)
      char *chgstring_;
+{
   char chgstring[256];
-  int a_id, a_chg, n_chrg;
+  int a_id, a_chg;
+  /* int n_chrg;*/
   /* typical example: a molecule with 2 cations + 1 anion */
   /* M  CHG  3   8   1  10   1  11  -1 */
   strcpy (chgstring, chgstring_);
   if (strpos2 (chgstring, "M  CHG", 1) <= 0)
     return;
   strdelete (chgstring, 1, 6);
   left_trim (chgstring);
-  n_chrg = left_int (chgstring);
+ /* n_chrg = left_int (chgstring);*/
   /* this assignment must be kept also in non-debug mode! */
 /* p2c: checkmol.pas, line 2077:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /*if (n_chrg == 0)
 static void
 read_isotopes (char *isotopestring_)
+{
   char isotopestring[256];
-  int a_id, a_nucleon_number, n_isotopes;
+  int a_id, a_nucleon_number;
+  /* int n_isotopes;*/
   /* typical example: a molecule with 2 cations + 1 anion */
   /* M  CHG  3   8   1  10   1  11  -1 */
   strcpy (isotopestring, isotopestring_);
   if (strpos2 (isotopestring, "M  ISO", 1) <= 0)
     return;
   strdelete (isotopestring, 1, 6);
   left_trim (isotopestring);
-  n_isotopes = left_int (isotopestring);
+  /*n_isotopes = left_int (isotopestring);*/
   /* this assignment must be kept also in non-debug mode! */
 /* p2c: checkmol.pas, line 2077:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   /*if (n_chrg == 0)
   int a1val, a2val, ri, rc, bt, bs;
   int sepcount = 0;
   int i;                        /* v0.3j */
   boolean clearcharges = true;  /* v0.3j */
   char STR1[256];
-  int FORLIM;
+/*  int FORLIM;*/
   atom_rec *WITH;
   bond_rec *WITH1;
   /* v0.3j */
   if (n_atoms > 0)
   char wline[256];
   int a_chg;
   int a_iso;
   int a_rad;
   char tmflabel[256];           /* v0.3m */
-  char STR1[256], STR7[256];
+  char STR1[256];
+  /*char STR7[256];*/
   int FORLIM;
   sprintf (tmflabel, "%d", (int) tweaklevel);   /* v0.3m */
   while (strlen (tmflabel) < 2) /* v0.3m */
     sprintf (tmflabel, "0%s", strcpy (STR1, tmflabel));
+        }
       if (bond[i].a2 == id && atom[bond[i].a1 - 1].heavy
           && nb_count < max_neighbors)
+        {
           Result[nb_count++] = bond[i].a1;
         }
     }
   //return memcpy (Result, nb_tmp, sizeof (neighbor_rec));
+}
 static void
   FORLIM = n_bonds;
   for (i = 0; i < FORLIM; i++)
+    {
       if (bond[i].a1 == id && bond[i].a2 != prev_id &&
           nb_count < max_neighbors && atom[bond[i].a2 - 1].heavy)
         {
           nb_count++;
           nb_tmp[nb_count - 1] = bond[i].a2;
+        }
       if (bond[i].a2 == id && bond[i].a1 != prev_id &&
           nb_count < max_neighbors && atom[bond[i].a1 - 1].heavy)
+        {
+        }
+    }
   return memcpy (Result, nb_tmp, sizeof (neighbor_rec));
+}
+#if 0
-  /*static int path_pos (id, a_path) int id;
+static int path_pos (id, a_path) int id;
      int *a_path;
+     {
-     /* new version in v0.3l
+     /* new version in v0.3l */
      int i;
      int pp = 0;
      for (i = 1; i <= max_ringsize; i++)
+     {
      if (a_path[i - 1] == id)
+     {
      pp = i;
      /* p2c: checkmol.pas, line 2620:
-     * Warning: Expected a '(', found a semicolon [227]
+     * Warning: Expected a '(', found a semicolon [227]  */
      /* p2c: checkmol.pas, line 2620:
-     * Warning: Expected an expression, found a semicolon [227]
+     * Warning: Expected an expression, found a semicolon [227] */
      fflush (0);
      P_ioresult = 0;
+     }
+     }
      return pp;
-     } */
+     }
+#endif
 static int
 matchpath_pos (int id, int *a_path)
+{
   int i;
   if (ndl_n_bonds <= 0)
     return b_id;
   FORLIM = ndl_n_bonds;
   for (i = 1; i <= FORLIM; i++)
+    {
-      if (ndl_bond[i - 1].a1 == ba1 && ndl_bond[i - 1].a2 == ba2 ||
+      if ((ndl_bond[i - 1].a1 == ba1 && ndl_bond[i - 1].a2 == ba2) ||
-          ndl_bond[i - 1].a1 == ba2 && ndl_bond[i - 1].a2 == ba1)
+          (ndl_bond[i - 1].a1 == ba2 && ndl_bond[i - 1].a2 == ba1))
         b_id = i;
+    }
   return b_id;
+}
 static int
 ringcompare (int *rp1, int *rp2)
 {
   int i, j;
   int rc = 0;
   int rs1, rs2;
   int n_common = 0;
   int max_cra;
+}
 static boolean
 rc_1in2 (int rc_int)
 {
   if (rc_int & 1)
     return true;
   else
     return false;
 }
 static boolean
 rc_2in1 (int rc_int)
+{
   rc_int /= 2;
   if (rc_int & 1)
     return true;
   else
     return false;
 }
+#if 0
 static boolean
 rc_different (int rc_int)
+{
   rc_int /= 4;
   if (rc_int & 1)
     return true;
   else
     return false;
+}
+#endif
+#if 0
 static boolean
 rc_independent (int rc_int)
+{
   rc_int /= 8;
   if (rc_int & 1)
     return true;
   else
     return false;
+}
+#endif
 static boolean
 is_newring (int *n_path)
+{
   int i, j;
   int j = 0;
   int k, s, pl;
 /* p2c: checkmol.pas, line 2862:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
-  char dstr[256];
+  /*char dstr[256];*/
   int FORLIM;
   /*$ENDIF */
   pl = path_length (n_path);
 /* p2c: checkmol.pas, line 2906:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug
          debugoutput ("max_rings exceeded!");
-         /*$ENDIF */
+         $ENDIF */
       return;
+    }
   n_rings++;
 /* p2c: checkmol.pas, line 2871:
       /*inc(atom^[(n_path[i])].ring_count); */
+    }
+}
+#if 0
-  /* static boolean is_ringpath (s_path) int *s_path;
+ static boolean is_ringpath (s_path) int *s_path;
+     {
      boolean Result;
      int i, j;
      neighbor_rec nb;
      boolean rp = false;
      boolean new_atom;
      int a_last, pl;
      ringpath_type l_path;
      int FORLIM;
-     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338]
+     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
      memset (nb, 0, sizeof (neighbor_rec));
      memset (l_path, 0, sizeof (ringpath_type));
      pl = path_length (s_path);
      if (pl < 1)
+     {
      /* p2c: checkmol.pas, line 2928:
-     * Note: Turbo Pascal conditional compilation directive was ignored [218]
+     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
      /*$IFDEF debug
      debugoutput ("Oops! Got zero-length s_path!");
-     /*$ENDIF
+     $ENDIF */
      return Result;
+     }
      for (i = 0; i < pl; i++)
      l_path[i] = s_path[i];
-     /* check if the last atom is a metal and stop if opt_metalrings is not set (v0.3)
+     /* check if the last atom is a metal and stop if opt_metalrings is not set (v0.3) */
      if (opt_metalrings == false)
+     {
      if (atom[l_path[pl - 1] - 1].metal)
+     {
      /* p2c: checkmol.pas, line 2942:
-     * Note: Turbo Pascal conditional compilation directive was ignored [218]
+     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
      /*$IFDEF debug
      debugoutput ("skipping metal in ring search");
-     /*$ENDIF
+     $ENDIF */
      return false;
+     }
+     }
-     /* check if ring is already closed
+     /* check if ring is already closed */
      if (pl > 2 && l_path[pl - 1] == l_path[0])
+     {
-     l_path[pl - 1] = 0;        /* remove last entry (redundant!)
+     l_path[pl - 1] = 0;        /* remove last entry (redundant!) */
      order_ringpath (l_path);
      if (is_newring (l_path))
+     {
      if (n_rings >= max_rings)
+     {
      /* p2c: checkmol.pas, line 2958:
-     * Note: Turbo Pascal conditional compilation directive was ignored [218]
+     * Note: Turbo Pascal conditional compilation directive was ignored [218] */
      /*$IFDEF debug
      debugoutput ("maximum number of rings exceeded!");
-     /*$ENDIF
+     $ENDIF */
      return false;
+     }
      add_ring (l_path);
+     }
-     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338]
+     /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
      return true;
+     }
-     /* any other case: ring is not (yet) closed
+     /* any other case: ring is not (yet) closed */
      a_last = l_path[pl - 1];
      get_neighbors (nb, a_last);
      if (atom[a_last - 1].neighbor_count <= 1)
      return false;
      if (n_rings >= max_rings)
-     /* added in v0.2: check if max_rings is reached *
+     /* added in v0.2: check if max_rings is reached **/
-     {                          /* if ring is not closed, continue searching
+     {                          /* if ring is not closed, continue searching */
      return false;
+     }
      FORLIM = atom[a_last - 1].neighbor_count;
      for (i = 0; i < FORLIM; i++)
+     {
      new_atom = true;
      for (j = 1; j < pl; j++)
+     {
      if (nb[i] == l_path[j])
-     {                    /* v0.3k
+     {                    /* v0.3k */
      new_atom = false;
      /* p2c: checkmol.pas, line 2982:
-     * Warning: Expected a '(', found a semicolon [227] *
+     * Warning: Expected a '(', found a semicolon [227] */
      /* p2c: checkmol.pas, line 2982:
-     * Warning: Expected an expression, found a semicolon [227]
+     * Warning: Expected an expression, found a semicolon [227] */
      fflush (0);
-     P_ioresult = 0;      /* v0.3k *
+     P_ioresult = 0;      /* v0.3k */
+     }
+     }
-     /* added in v0.1a: check if max_rings not yet reached
+     /* added in v0.1a: check if max_rings not yet reached */
-     /* added in v0.2:  limit ring size to max_vringsize instead of max_ringsize
+     /* added in v0.2:  limit ring size to max_vringsize instead of max_ringsize */
      if (new_atom && pl < max_vringsize && n_rings < max_rings)
+     {
      l_path[pl] = nb[i];
-     if (pl < max_ringsize - 1)   /* just to be sure
+     if (pl < max_ringsize - 1)   /* just to be sure */
      l_path[pl + 1] = 0;
      if (is_ringpath (l_path))
      rp = true;
+     }
+     }
      return rp;
-     } */
+     }
+#endif
 static boolean
 is_ringpath (int *s_path)
+{
   int i, j;
   boolean rp = false;
   boolean new_atom;
   int a_last, pl;
   ringpath_type l_path;
   int FORLIM, pl_prev, pl_next, max_ringsize_dec;
 /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
   memset ((void *) nb, 0, sizeof (neighbor_rec));
   memset ((void *) l_path, 0, sizeof (ringpath_type));
   pl = path_length (s_path);
   if (pl < 1)
                    max_ringpath_recursion_depth);
               n_rings = max_rings;
               return false;
+            }
-          //printf("%i\n",recursion_depth);
+          /*printf("%i\n",recursion_depth);
-          //fflush(stdout);
+          fflush(stdout);*/
           if (is_ringpath (l_path))
             rp = true;
-          //return true;
+          /*return true;*/
+        }
+    }
   return rp;
+}
             rb = true;
           //return true;
+        }
+    }
   return rb;
 }
 static void
 chk_ringbonds ()
+{
   int i, a1rc, a2rc;
   if (n_bonds < 1)
     return;
   for (i = 0; i < n_bonds; i++)
+    {
       a1rc = atom[bond[i].a1 - 1].ring_count;
       a2rc = atom[bond[i].a2 - 1].ring_count;
-      if (n_rings == 0 || a1rc < n_rings && a2rc < n_rings)
+      if (n_rings == 0 || (a1rc < n_rings && a2rc < n_rings))
+        {
           is_ringbond (i + 1);
           /*inc(bond^[i].ring_count); */
+        }
+    }
+}
 /* v0.3d: moved procedure update_ringcount a bit down */
 static int
 raw_hetbond_count (int a)
+{
   /* new in v0.2j, ignores bond order */
   int i;
   str2 nb_el;
   int hbc = 0;
   int FORLIM;
   if (a <= 0 || a > n_atoms)
     return hbc;
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a);
   if (atom[a - 1].neighbor_count <= 0)
     return hbc;
   FORLIM = atom[a - 1].neighbor_count;
       strcpy (nb_el, atom[nb[i] - 1].element);
       if (strcmp (nb_el, "C ") && strcmp (nb_el, "A ") && strcmp (nb_el, "H ")  /* &&  strcmp (nb_el, "D ") */
           && strcmp (nb_el, "LP") && strcmp (nb_el, "DU"))
         /* added 'D ' in v0.3n */
         hbc++;
     }
   return hbc;
+}
 static int
         hac++;
+    }
   return hac;
+}
+#if 0
 static int
 ndl_hetbond_count (int a)
+{
   int i;
   neighbor_rec nb;
   str2 nb_el;
   float hbc = 0.0;
   int FORLIM;
   if (a <= 0 || a > n_atoms)
     return ((int) floor (hbc + 0.5));
   memset (nb, 0, sizeof (neighbor_rec));
   get_ndl_neighbors (nb, a);
   if (ndl_atom[a - 1].neighbor_count <= 0)
     return ((int) floor (hbc + 0.5));
   FORLIM = ndl_atom[a - 1].neighbor_count;
             hbc += 3.0;
+        }
+    }
   return ((int) floor (hbc + 0.5));
+}
+#endif
 static int
 ndl_hetatom_count (int a)
+{
   int i;
           && strcmp (nb_el, "LP") && strcmp (nb_el, "DU"))
         /* added 'D ' in v0.3n */
         hac++;
+    }
   return hac;
 }
 static boolean
 is_oxo_C (int id)
+{
   boolean Result;
         /* no N, amidines are different... */
         r = true;
       /* or
          (atom^[(nb[i])].element = 'S ')  or
          (atom^[(nb[i])].element = 'SE') */
     }
   return r;
+}
 static boolean
+    {
       if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
           (!strcmp (atom[nb[i] - 1].element, "S ") ||
            !strcmp (atom[nb[i] - 1].element, "SE")))
         /* no N, amidines are different... */
         r = true;
     }
   return r;
+}
 static boolean
 is_imino_C (int id)
 {
   boolean Result;
   int i;
   boolean r = false;
   neighbor_rec nb;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
     return Result;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
     return false;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++)
     {
       if (bond[get_bond (id, nb[i]) - 1].btype == 'D' &&
           !strcmp (atom[nb[i] - 1].element, "N "))
         r = true;
+    }
   return r;
+}
 static boolean
 is_true_imino_C (int id)
+{
   boolean Result;
   int i;
   int a_n = 0;
   int b;                        /* v0.3j */
   int FORLIM;
 /* p2c: checkmol.pas: Note: Eliminated unused assignment statement [338] */
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
     return Result;
   get_neighbors (nb, id);
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
     return false;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++)
+    {
       b = get_bond (id, nb[i]); /* v0.3j */
       if (bond[b - 1].btype == 'D' && bond[b - 1].arom == false &&
           !strcmp (atom[nb[i] - 1].element, "N "))
         /* v0.3j */
         a_n = nb[i];
     }
   if (a_n <= 0)
     return false;
   memset (nb, 0, sizeof (neighbor_rec));
   get_neighbors (nb, a_n);
   FORLIM = atom[a_n - 1].neighbor_count;
         r = false;
+    }
   return r;
+}
 static boolean
 is_true_exocyclic_imino_C (int id, int r_id)
 {
   /* v0.3j */
   boolean Result;
   int i, j;
   boolean r = false;
   neighbor_rec nb;
   FORLIM = atom[id - 1].neighbor_count;
   for (i = 0; i < FORLIM; i++)
+    {
       b = get_bond (id, nb[i]);
       if (bond[b - 1].btype == 'D' && bond[b - 1].arom == false &&
           !strcmp (atom[nb[i] - 1].element, "N "))
         {
           r = true;
           for (j = 0; j < ring_size; j++)
+            {
               if (nb[i] == ring[r_id - 1][j])
                 r = false;
+            }
+        }
+    }
   return r;
+}
 static boolean
 is_exocyclic_imino_C (int id, int r_id)
+{
   boolean Result;
   int i, j;
   int ring_size, FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (id < 1 || id > n_atoms)
     return Result;
   get_neighbors (nb, id);
   memset (testring, 0, sizeof (ringpath_type));
   ring_size = ringprop[r_id - 1].size;  /* v0.3j */
   for (j = 0; j < ring_size; j++)       /* v0.3j */
     testring[j] = ring[r_id - 1][j];
   if (strcmp (atom[id - 1].element, "C ") || atom[id - 1].neighbor_count <= 0)
     return false;
+}
 static boolean
 is_sulfanyl (int a_view, int a_ref)
 {
   boolean r = false;
   if (atom[a_view - 1].
       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
+    {
       if (!strcmp (atom[a_ref - 1].atype, "S3 ") &&
           atom[a_ref - 1].neighbor_count == 1)
         r = true;
+    }
   return r;
+}
 static boolean
 is_amino (int a_view, int a_ref)
+{
   boolean r = false;
+    {
       if ((!strcmp (atom[a_ref - 1].atype, "N3 ") ||
            !strcmp (atom[a_ref - 1].atype, "N3+")) &&
           atom[a_ref - 1].neighbor_count == 1)
         r = true;
     }
   return r;
+}
 static boolean
 is_alkyl (int a_view, int a_ref)
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   str2 nb_el;
   int het_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C3 ")
       || atom[a_ref - 1].arom != false)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
   for (i = 0; i <= FORLIM; i++)
     {
       strcpy (nb_el, atom[nb[i] - 1].element);
       if (strcmp (nb_el, "C ") && strcmp (nb_el, "H ")
           /*&&  strcmp (nb_el, "D ") */  && strcmp (nb_el, "DU")
           && strcmp (nb_el, "LP"))
         /* added 'D ' in v0.3n */
         het_count++;
   int i;
   boolean r = false;
   neighbor_rec nb;
   str2 nb_el;
   int het_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S'))
       || strcmp (atom[a_ref - 1].atype, "C3 ")
       || atom[a_ref - 1].arom != false)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   FORLIM = atom[a_ref - 1].neighbor_count - 2;
+}
 static boolean
 is_alkenyl (int a_view, int a_ref)
 {
   /* new in v0.3j */
   int i;
   boolean r = false;
   neighbor_rec nb;
   str2 nb_el;
   str3 nb_at;
   int c2_count = 0, het_count = 0;
   int FORLIM;
   return r;
+}
 static boolean
 is_alkoxy (int a_view, int a_ref)
+{
+  boolean r = false;
+  neighbor_rec nb;
+  memset (nb, 0, sizeof (neighbor_rec));
+  if (!
+      (atom[a_view - 1].
+       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
+    return false;
+  if (strcmp (atom[a_ref - 1].atype, "O3 ")
+      || atom[a_ref - 1].neighbor_count != 2)
+    return false;
+  get_nextneighbors (nb, a_ref, a_view);
+  if (is_alkyl (a_ref, nb[0]))
+    r = true;
+  return r;
+}
+static boolean
+is_siloxy (int a_view, int a_ref)
+{
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
-  if (is_alkyl (a_ref, nb[0]))
+  if (!strcmp (atom[nb[0] - 1].element, "SI"))
     r = true;
   return r;
 }
 static boolean
-is_siloxy (int a_view, int a_ref)
+is_true_alkoxy (int a_view, int a_ref)
+{
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
     return false;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
-  if (!strcmp (atom[nb[0] - 1].element, "SI"))
+  if (is_true_alkyl (a_ref, nb[0]))
     r = true;
   return r;
 }
 static boolean
-is_true_alkoxy (int a_view, int a_ref)
+is_aryloxy (int a_view, int a_ref)
+{
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
     return false;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
-  if (is_true_alkyl (a_ref, nb[0]))
+  if (is_aryl (a_ref, nb[0]))
     r = true;
   return r;
+}
-static boolean
-is_aryloxy (int a_view, int a_ref)
-{
-  boolean r = false;
-  neighbor_rec nb;
-  memset (nb, 0, sizeof (neighbor_rec));
-  if (!
-      (atom[a_view - 1].
-       heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
-    return false;
-  if (strcmp (atom[a_ref - 1].atype, "O3 ")
-      || atom[a_ref - 1].neighbor_count != 2)
-    return false;
-  get_nextneighbors (nb, a_ref, a_view);
-  if (is_aryl (a_ref, nb[0]))
-    r = true;
-  return r;
-}
 static boolean
 is_alkenyloxy (int a_view, int a_ref)
+{
   /* v0.3j */
   boolean r = false;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_alkenyl (a_ref, nb[0]))
     r = true;
   return r;
+}
 static boolean
 is_alkynyloxy (int a_view, int a_ref)
 {
   /* v0.3j */
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].atype, "O3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
+}
 static boolean
 is_alkylsulfanyl (int a_view, int a_ref)
 {
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (strcmp (atom[a_ref - 1].atype, "S3 ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_aryl (a_ref, nb[0]))
     r = true;
   return r;
 }
 static boolean
 is_alkenylsulfanyl (a_view, a_ref)
      int a_view, a_ref;
+{
   /* v0.3j */
+}
 static boolean
 is_alkylamino (a_view, a_ref)
      int a_view, a_ref;
 {
   boolean r = false;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
   if (alkyl_count == 1)
     r = true;
   return r;
+}
 static boolean
 is_dialkylamino (a_view, a_ref)
      int a_view, a_ref;
+{
   int i;
   boolean r = false;
   neighbor_rec nb;
   int alkyl_count = 0;
+    {
       if (is_alkyl (a_ref, nb[i]))
         alkyl_count++;
+    }
   if (alkyl_count == 2)
     r = true;
   return r;
 }
 static boolean
 is_arylamino (a_view, a_ref)
      int a_view, a_ref;
+{
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_aryl (a_ref, nb[0]))
     aryl_count++;
   if (aryl_count == 1)
     r = true;
   return r;
 }
 static boolean
 is_diarylamino (a_view, a_ref)
      int a_view, a_ref;
+{
   int i;
   boolean r = false;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 3)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++)
+    {
       if (is_aryl (a_ref, nb[i]))
         aryl_count++;
+    }
   if (aryl_count == 2)
     r = true;
   return r;
 }
 static boolean
 is_alkylarylamino (a_view, a_ref)
      int a_view, a_ref;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
-  if (strcmp (atom[a_ref - 1].atype, "N3 ")
+  if ((strcmp (atom[a_ref - 1].atype, "N3 ")
-      && strcmp (atom[a_ref - 1].atype, "NAM")
+      && strcmp (atom[a_ref - 1].atype, "NAM"))
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (!strcmp (atom[nb[0] - 1].element, "C "))
     c_count++;
   b = get_bond (a_view, a_ref);
   memset (nb, 0, sizeof (neighbor_rec));
   if (!(atom[a_view - 1].heavy && bond[b - 1].btype == 'S' &&
         bond[b - 1].arom == false))
     return false;
-  if (strcmp (atom[a_ref - 1].atype, "N3 ")
+  if ((strcmp (atom[a_ref - 1].atype, "N3 ")
-      && strcmp (atom[a_ref - 1].atype, "NAM")
+      && strcmp (atom[a_ref - 1].atype, "NAM"))
       || atom[a_ref - 1].neighbor_count != 3)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++)
+    {
+}
 static boolean
 is_true_alkylamino (a_view, a_ref)
      int a_view, a_ref;
 {
   boolean r = false;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
-  if (strcmp (atom[a_ref - 1].atype, "N3 ")
+  if ((strcmp (atom[a_ref - 1].atype, "N3 ")
-      && strcmp (atom[a_ref - 1].atype, "N3+")
+      && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_true_alkyl (a_ref, nb[0]))
     alkyl_count++;
   if (alkyl_count == 1)
     r = true;
   return r;
+}
 static boolean
 is_true_dialkylamino (a_view, a_ref)
      int a_view, a_ref;
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   int alkyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
-  if (strcmp (atom[a_ref - 1].atype, "N3 ")
+  if ((strcmp (atom[a_ref - 1].atype, "N3 ")
-      && strcmp (atom[a_ref - 1].atype, "N3+")
+      && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 3)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++)
     {
       if (is_true_alkyl (a_ref, nb[i]))
         alkyl_count++;
     }
   if (alkyl_count == 2)
     r = true;
   return r;
+}
+#if 0
 static boolean
 is_true_alkylarylamino (a_view, a_ref)
      int a_view, a_ref;
+{
   int i;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
-  if (strcmp (atom[a_ref - 1].atype, "N3 ")
+  if ((strcmp (atom[a_ref - 1].atype, "N3 ")
-      && strcmp (atom[a_ref - 1].atype, "N3+")
+      && strcmp (atom[a_ref - 1].atype, "N3+"))
       || atom[a_ref - 1].neighbor_count != 3)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   for (i = 0; i <= 1; i++)
+    {
+    }
   if (alkyl_count == 1 && aryl_count == 1)
     r = true;
   return r;
+}
+#endif
 static boolean
 is_hydroxylamino (a_view, a_ref)
      int a_view, a_ref;
+{
+}
 static boolean
 is_aryloxythiocarbonyl (a_view, a_ref)
      int a_view, a_ref;
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
         r = true;
+    }
   return r;
+}
 static boolean
 is_thiocarbamoyl (a_view, a_ref)
      int a_view, a_ref;
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
         r = true;
+    }
   return r;
+}
 static boolean
 is_alkanoyl (a_view, a_ref)
      int a_view, a_ref;
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
         r = true;
+    }
   return r;
+}
 static boolean
 is_aroyl (a_view, a_ref)
      int a_view, a_ref;
 {
   int i;
   boolean r = false;
   neighbor_rec nb;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (!(is_oxo_C (a_ref) && atom[a_ref - 1].neighbor_count == 3))
     return false;
   return r;
+}
 static boolean
 is_acyl_gen (a_view, a_ref)
+     int a_view, a_ref;
+{
+  /* new in v0.3j */
+  boolean r = false;
+  if (is_oxo_C (a_ref))
+    r = true;
+  return r;
+}
+static boolean
+is_acylamino (a_view, a_ref)
      int a_view, a_ref;
+{
-  /* new in v0.3j */
   boolean r = false;
+  neighbor_rec nb;
+  int acyl_count = 0;
-  if (is_oxo_C (a_ref))
-    r = true;
-  return r;
-}
-static boolean
-is_acylamino (a_view, a_ref)
-     int a_view, a_ref;
-{
-  boolean r = false;
-  neighbor_rec nb;
-  int acyl_count = 0;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count != 2)
     return false;
   get_nextneighbors (nb, a_ref, a_view);
   if (is_acyl (a_ref, nb[0]))
   /* may be substituted _or_ unsubstituted acylamino group! */
   int i;
   boolean r = false;
   neighbor_rec nb;
   int acyl_count = 0;
   int FORLIM;
   memset (nb, 0, sizeof (neighbor_rec));
   if (!
       (atom[a_view - 1].
        heavy && (bond[get_bond (a_view, a_ref) - 1].btype == 'S')))
     return false;
   if (strcmp (atom[a_ref - 1].element, "N ")
       || atom[a_ref - 1].neighbor_count < 2)
     return false;
+}
 static boolean
 is_nitroso (a_view, a_ref)
      int a_view, a_ref;
 {
   /* new in v0.3j */
   boolean r = false;
   neighbor_rec nb;
   int o_count = 0;
   int a2;
               if (total_bonds > 3)
+                {
                   if (O_count == 0)
+                    {
                       if (single_count > 3 ||
-                          single_count == 2 && double_count == 1
+                          (single_count == 2 && double_count == 1
-                          && C_count >= 2)
+                          && C_count >= 2))
                         atom[i].formal_charge = 1;
+                    }
                   else
+                    {
                       if (O_count == 1 && atom[i].formal_charge == 0)   /* v0.3m */
                       /* the rest is left empty, so far.... */
+                    }
+                }
               /* could be an N-oxide -> should be found elsewhere  */
               if (triple_count == 1 ||
-                  double_count == 2 && atom[i].neighbor_count == 2)
+                  (double_count == 2 && atom[i].neighbor_count == 2))
                 /* v0.3n */
                 strcpy (atom[i].atype, "N1 ");
               if (double_count == 1)
+                {
                   /*if NdC_count > 0 then atom^[i].atype := 'N2 '; */
                 n_ar++;
               if (bt_fw != 'A' && bt_bk == bt_fw)
                 cumul = true;
               a_prev = a_ref;
+            }
-          if (n_ar == 6 || n_sb == 3 && n_db == 3 && cumul == false)
+          if (n_ar == 6 || (n_sb == 3 && n_db == 3 && cumul == false))
             {                   /* this ring is aromatic */
               a_prev = testring[ring_size - 1];
               for (j = 0; j < ring_size; j++)
+                {
                   a_ref = testring[j];
+                    }
                   else
+                    {
                       pi_count++;       /* v0.3j; adjustment for bridgehead N: see below */
                       if (bt_bk == 'S' && bt_fw == 'S' &&
-                          (ar_bk == true && ar_fw == false ||
+                          ((ar_bk == true && ar_fw == false) ||
-                           ar_bk == false && ar_fw == true))
+                           (ar_bk == false && ar_fw == true)))
+                        {
                           /* v0.3j; if a bridgehead N were not aromatic, it could  */
                           /* contribute 2 pi electrons --> try also this variant */
                           /* (example: CAS 32278-54-9) */
                           if (!strcmp (atom[a_ref - 1].element, "N "))
     fg[fg_quart_ammonium - 1] = true;
   if (het_count != 1 || atom[a_ref - 1].neighbor_count < 3)
     return;
   if (o_count == 1 && or_count == 0 && bo_sum > 3)
     fg[fg_n_oxide - 1] = true;  /* finds only aliphatic N-oxides! */
-  if ((o_count == 1 && or_count == 1 || o_count == 0) &&
+  if (((o_count == 1 && or_count == 1) || o_count == 0) &&
       atom[a_ref - 1].arom == true)
     fg[fg_quart_ammonium - 1] = true;
+}
     fg[fg_hemiaminal - 1] = true;
   if (n_count == 2)
     fg[fg_aminal - 1] = true;
   if ((sh_count == 1 || sr_count == 1) && n_count == 1)
     fg[fg_thiohemiaminal - 1] = true;
-  if (sr_count == 2 || or_count == 1 && sr_count == 1)
+  if (sr_count == 2 || (or_count == 1 && sr_count == 1))
     fg[fg_thioacetal - 1] = true;
+}
 static void
     printf ("isocyanate\n");
   if (fg[fg_thiocyanate - 1])
     printf ("thiocyanate\n");
   if (fg[fg_isothiocyanate - 1])
     printf ("isothiocyanate\n");
   if (fg[fg_carbodiimide - 1])
     printf ("carbodiimide\n");
   if (fg[fg_nitroso_compound - 1])
     printf ("nitroso compound\n");
   if (fg[fg_nitro_compound - 1])
     printf ("nitro compound\n");
     printf ("Peroxid\n");
   if (fg[fg_hydroperoxide - 1])
     printf ("Hydroperoxid\n");
   if (fg[fg_hydrazine - 1])
     printf ("Hydrazin-Derivat\n");
   if (fg[fg_hydroxylamine - 1])
     printf ("Hydroxylamin\n");
   if (fg[fg_amine - 1] && amine_generic)
     printf ("Amin\n");
   if (fg[fg_prim_amine - 1])
     printf ("prim\344res Amin\n");
 #undef sc
 static void
 write_fg_binary ()
 {
   int i, n;
   char o;
   for (i = 1; i <= max_fg / 8; i++)
+    {
         n += 64;
       if (fg[i * 8 - 8])
         n += 128;
       o = (char) n;
       putchar (o);
     }
 }
 static void
 write_fg_bitstring ()
+{
   int i;
         putchar ('0');
+    }
+}
+#if 0
-  /*static void readinputfile (molfilename) char *molfilename;
+static void readinputfile (molfilename) char *molfilename;
+     {
-     /* new version in v0.2g
+     /* new version in v0.2g */
      char rline[256];
      char *TEMP;
      molbufindex = 0;
      if (!opt_stdin)
      {
      if (!rfile_is_open)
      {
      assign (rfile, molfilename);
      rewind (rfile);
      rfile_is_open = true;
+     }
      /* p2c: checkmol.pas, line 7733: Warning:
-     * Don't know how to ASSIGN to a non-explicit file variable [207]
+     * Don't know how to ASSIGN to a non-explicit file variable [207] */
      *rline = '\0';
      mol_in_queue = false;
      while ((!P_eof (rfile)) && (strpos2 (rline, "$$$$", 1) == 0))
+     {
      fgets (rline, 256, rfile);
      TEMP = strchr (rline, '\n');
      if (TEMP != NULL)
      *TEMP = 0;
-     /*mol_in_queue := false;
+     /*mol_in_queue := false; */
      if (molbufindex >= max_atoms + max_bonds + 64)
+     {
      printf ("Not enough memory for molfile! %12ld\n",
      molbufindex);
      if (rfile != NULL)
      fclose (rfile);
      rfile = NULL;
      _Escape (1);
      }
      molbufindex++;
      strcpy (molbuf[molbufindex - 1], rline);
      if (strpos2 (rline, "$$$$", 1) > 0)
      mol_in_queue = true;
+     }
      if (!P_eof (rfile))
      mol_in_queue = true;
      /* read from standard input
+     }
+     }
      } */
+#endif
 static void
 readinputfile (char *molfilename)
+{
   /* new version in v0.2g */
       if (!rfile_is_open)
+        {
           rfile = fopen (molfilename, "r");
           rewind (rfile);
           rfile_is_open = true;
         }
 /* p2c: checkmol.pas, line 7226: Warning:
  * Don't know how to ASSIGN to a non-explicit file variable [207] */
       *rline = '\0';
       mol_in_queue = false;
       while ((fgets (rline, 256, rfile) != NULL)
+        }
+    }
   while (strstr (rline, "$$$$") == NULL);
+}
+#if 0
-/* static void copy_mol_to_needle()
+static void copy_mol_to_needle()
+{
   int i, j, FORLIM;
   if (n_atoms == 0)
     return;
-  /* try
+  /* try */
   ndl_atom = (atom_rec *)safe_malloc(n_atoms * sizeof(atom_rec));
   ndl_bond = (bond_rec *)safe_malloc(n_bonds * sizeof(bond_rec));
   ndl_ring = (ringpath_type *)safe_malloc(sizeof(ringlist));
   ndl_ringprop = (ringprop_rec *)safe_malloc(sizeof(ringprop_type));
-  /* except
+  /* except*/
     on e:Eoutofmemory do
       begin
         writeln('Not enough memory');
         halt(4);
       end;
   end;
   ndl_n_atoms = n_atoms;
   ndl_n_bonds = n_bonds;
   ndl_n_rings = n_rings;
   ndl_n_heavyatoms = n_heavyatoms;
   ndl_n_heavybonds = n_heavybonds;
   strcpy(ndl_molname, molname);
   ndl_n_Ctot = n_Ctot;
   ndl_n_Otot = n_Otot;
   ndl_n_Ntot = n_Ntot;
     ndl_atom[i].Htot = atom[i].Htot;
     ndl_atom[i].neighbor_count = atom[i].neighbor_count;
     ndl_atom[i].ring_count = atom[i].ring_count;
     ndl_atom[i].arom = atom[i].arom;
     ndl_atom[i].stereo_care = atom[i].stereo_care;
-    ndl_atom[i].heavy = atom[i].heavy;   /* v0.3l
+    ndl_atom[i].heavy = atom[i].heavy;   /* v0.3l */
-    ndl_atom[i].metal = atom[i].metal;   /* v0.3l
+    ndl_atom[i].metal = atom[i].metal;   /* v0.3l */
-  ndl_atom[i].tag = atom[i].tag;        /* v0.3o
+    ndl_atom[i].tag = atom[i].tag;      /* v0.3o */
                                            }
                                            if (n_bonds > 0) {
                                            FORLIM = n_bonds;
                                            for (i = 0; i < FORLIM; i++) {
                                            ndl_bond[i].a1 = bond[i].a1;
                                            ndl_bond[i].a2 = bond[i].a2;
                                            ndl_bond[i].btype = bond[i].btype;
                                            ndl_bond[i].arom = bond[i].arom;
-                                           ndl_bond[i].ring_count = bond[i].ring_count;   /* new in v0.3d
+                                           ndl_bond[i].ring_count = bond[i].ring_count;   /* new in v0.3d */
-                                           ndl_bond[i].topo = bond[i].topo;   /* new in v0.3d
+                                           ndl_bond[i].topo = bond[i].topo;   /* new in v0.3d */
-                                           ndl_bond[i].stereo = bond[i].stereo;   /* new in v0.3d
+                                           ndl_bond[i].stereo = bond[i].stereo;   /* new in v0.3d */
+                                           }
+                                           }
                                            if (n_rings > 0) {
                                            FORLIM = n_rings;
                                            for (i = 0; i < FORLIM; i++) {
                                            for (j = 0; j < max_ringsize; j++)
                                            ndl_ring[i][j] = ring[i][j];
+                                           }
-                                           for (i = 0; i < max_rings; i++) {   /* new in v0.3
+                                           for (i = 0; i < max_rings; i++) {   /* new in v0.3 */
                                            ndl_ringprop[i].size = ringprop[i].size;
                                            ndl_ringprop[i].arom = ringprop[i].arom;
                                            ndl_ringprop[i].envelope = ringprop[i].envelope;
+                                           }
+                                           }
                                            ndl_molstat.n_rO1 = molstat.n_rO1;
                                            ndl_molstat.n_rO2p = molstat.n_rO2p;
                                            ndl_molstat.n_rS = molstat.n_rS;
                                            ndl_molstat.n_rX = molstat.n_rX;
                                            ndl_molstat.n_rAr = molstat.n_rAr;
-                                           ndl_molstat.n_rBz = molstat.n_rBz;   /* v0.3l
+                                           ndl_molstat.n_rBz = molstat.n_rBz;   /* v0.3l */
-                                           ndl_molstat.n_br2p = molstat.n_br2p;   /* v0.3n
+                                           ndl_molstat.n_br2p = molstat.n_br2p;   /* v0.3n */
                                            /* p2c: checkmol.pas, line 7875:
-                                           * Note: Turbo Pascal conditional compilation directive was ignored [218]
+                                           * Note: Turbo Pascal conditional compilation directive was ignored [218] */
                                            /*$IFDEF extended_molstat
-                                           /* v0.3m
+                                            v0.3m */
                                            ndl_molstat.n_psg01 = molstat.n_psg01;
                                            ndl_molstat.n_psg02 = molstat.n_psg02;
                                            ndl_molstat.n_psg13 = molstat.n_psg13;
                                            ndl_molstat.n_psg14 = molstat.n_psg14;
                                            ndl_molstat.n_psg15 = molstat.n_psg15;
                                            ndl_molstat.n_psg16 = molstat.n_psg16;
                                            ndl_molstat.n_psg17 = molstat.n_psg17;
                                            ndl_molstat.n_psg18 = molstat.n_psg18;
                                            ndl_molstat.n_pstm = molstat.n_pstm;
                                            ndl_molstat.n_psla = molstat.n_psla;
-                                           /*$ENDIF
+                                           $ENDIF*/
-                                           /* make sure some modes can be switched on only by the query file
+                                           /* make sure some modes can be switched on only by the query file *M*/
-                                           /* and not by subsequent haystack file(s)
+                                           /* and not by subsequent haystack file(s) */
-                                           if (ez_flag)   /* new in v0.3f
+                                           if (ez_flag)   /* new in v0.3f */
                                            ez_search = true;
-                                           if (chir_flag)   /* new in v0.3f
+                                           if (chir_flag)   /* new in v0.3f */
                                            rs_search = true;
-                                           } */
+                                           }
+#endif
 static void
 copy_mol_to_needle ()
 {
   //int i, j, FORLIM;
   /*if (n_atoms == 0)
      return; *///If a NoStruct is read, this leads to madness and illegal memory access
   ndl_atom = (atom_rec *) safe_calloc (n_atoms, sizeof (atom_rec));
   ndl_bond = (bond_rec *) safe_calloc (n_bonds, sizeof (bond_rec));
   ndl_ring = (ringpath_type *) safe_calloc (1, sizeof (ringlist));
   ndl_ringprop = (ringprop_rec *) safe_calloc (1, sizeof (ringprop_type));
+{
   //int i, j, FORLIM;
   /*if (n_atoms == 0)
      return; *///If a NoStruct is read, this leads to madness and illegal memory access
   tmp_atom = (atom_rec *) safe_calloc (n_atoms, sizeof (atom_rec));
   tmp_bond = (bond_rec *) safe_calloc (n_bonds, sizeof (bond_rec));
   tmp_ring = (ringpath_type *) safe_calloc (1, sizeof (ringlist));
   tmp_ringprop = (ringprop_rec *) safe_calloc (1, sizeof (ringprop_type));
   tmp_n_atoms = n_atoms;
   tmp_n_bonds = n_bonds;
   tmp_n_rings = n_rings;
   tmp_n_heavyatoms = n_heavyatoms;
   tmp_n_heavybonds = n_heavybonds;
   if (n_rings > 0)
+    {
       memcpy (tmp_ring, ring, sizeof (ringlist));
       memcpy (tmp_ringprop, ringprop, sizeof (ringprop_type));
     }
   memcpy (&tmp_molstat, &molstat, sizeof (molstat));
   // make sure some modes can be switched on only by the query file
   // and not by subsequent haystack file(s)
   if (ez_flag)                  // new in v0.3f
     ez_search = true;
-  if (chir_flag)                // new in v0.3f
-    rs_search = true;
-  ndl_querymol = found_querymol;        /* 0.3p */
+  if (chir_flag)                // new in v0.3f
+    rs_search = true;
-}
+  ndl_querymol = found_querymol;        /* 0.3p */
+}
+#if 0
-/* static void copy_mol_to_tmp()
+static void copy_mol_to_tmp()
+{
   int i, j, FORLIM;
   if (n_atoms == 0)
     return;
-  /* try
+  /* try */
   tmp_atom = (atom_rec *)safe_malloc(n_atoms * sizeof(atom_rec));
   tmp_bond = (bond_rec *)safe_malloc(n_bonds * sizeof(bond_rec));
   tmp_ring = (ringpath_type *)safe_malloc(sizeof(ringlist));
   tmp_ringprop = (ringprop_rec *)safe_malloc(sizeof(ringprop_type));
-  /* except
+  /* except */
     on e:Eoutofmemory do
       begin
         writeln('Not enough memory');
         halt(4);
       end;
     tmp_atom[i].Htot = atom[i].Htot;
     tmp_atom[i].neighbor_count = atom[i].neighbor_count;
     tmp_atom[i].ring_count = atom[i].ring_count;
     tmp_atom[i].arom = atom[i].arom;
     tmp_atom[i].stereo_care = atom[i].stereo_care;
-    tmp_atom[i].heavy = atom[i].heavy;   /* v0.3l
+    tmp_atom[i].heavy = atom[i].heavy;   /* v0.3l */
-    tmp_atom[i].metal = atom[i].metal;   /* v0.3l
+    tmp_atom[i].metal = atom[i].metal;   /* v0.3l */
-    tmp_atom[i].tag = atom[i].tag;   /* v0.3o
+    tmp_atom[i].tag = atom[i].tag;   /* v0.3o */
+  }
   if (n_bonds > 0) {
     FORLIM = n_bonds;
     for (i = 0; i < FORLIM; i++) {
       tmp_bond[i].a1 = bond[i].a1;
       tmp_bond[i].a2 = bond[i].a2;
       tmp_bond[i].btype = bond[i].btype;
       tmp_bond[i].arom = bond[i].arom;
-      tmp_bond[i].ring_count = bond[i].ring_count;   /* new in v0.3d
+      tmp_bond[i].ring_count = bond[i].ring_count;   /* new in v0.3d */
-      tmp_bond[i].topo = bond[i].topo;   /* new in v0.3d
+      tmp_bond[i].topo = bond[i].topo;   /* new in v0.3d */
-      tmp_bond[i].stereo = bond[i].stereo;   /* new in v0.3d
+      tmp_bond[i].stereo = bond[i].stereo;   /* new in v0.3d */
+    }
+  }
   if (n_rings > 0) {
     FORLIM = n_rings;
     for (i = 0; i < FORLIM; i++) {
       for (j = 0; j < max_ringsize; j++)
         tmp_ring[i][j] = ring[i][j];
+    }
-    for (i = 0; i < max_rings; i++) {   /* new in v0.3
+    for (i = 0; i < max_rings; i++) {   /* new in v0.3 */
       tmp_ringprop[i].size = ringprop[i].size;
       tmp_ringprop[i].arom = ringprop[i].arom;
       tmp_ringprop[i].envelope = ringprop[i].envelope;
+    }
+  }
   tmp_molstat.n_rO1 = molstat.n_rO1;
   tmp_molstat.n_rO2p = molstat.n_rO2p;
   tmp_molstat.n_rS = molstat.n_rS;
   tmp_molstat.n_rX = molstat.n_rX;
   tmp_molstat.n_rAr = molstat.n_rAr;
-  tmp_molstat.n_rBz = molstat.n_rBz;   /* v0.3l
+  tmp_molstat.n_rBz = molstat.n_rBz;   /* v0.3l */
-  tmp_molstat.n_br2p = molstat.n_br2p;   /* v0.3n
+  tmp_molstat.n_br2p = molstat.n_br2p;   /* v0.3n */
 /* p2c: checkmol.pas, line 8022:
- * Note: Turbo Pascal conditional compilation directive was ignored [218]
+ * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF extended_molstat
-  /* v0.3m
+   v0.3m
   tmp_molstat.n_psg01 = molstat.n_psg01;
   tmp_molstat.n_psg02 = molstat.n_psg02;
   tmp_molstat.n_psg13 = molstat.n_psg13;
   tmp_molstat.n_psg14 = molstat.n_psg14;
   tmp_molstat.n_psg15 = molstat.n_psg15;
   tmp_molstat.n_psg16 = molstat.n_psg16;
   tmp_molstat.n_psg17 = molstat.n_psg17;
   tmp_molstat.n_psg18 = molstat.n_psg18;
   tmp_molstat.n_pstm = molstat.n_pstm;
   tmp_molstat.n_psla = molstat.n_psla;
-  /*$ENDIF
+  $ENDIF*/
-  /* make sure some modes can be switched on only by the query file
+  /* make sure some modes can be switched on only by the query file */
-  /* and not by subsequent haystack file(s)
+  /* and not by subsequent haystack file(s) */
-  if (ez_flag)   /* new in v0.3f
+  if (ez_flag)   /* new in v0.3f */
     ez_search = true;
-  if (chir_flag)   /* new in v0.3f
+  if (chir_flag)   /* new in v0.3f */
     rs_search = true;
-} */
+}
+#endif
 static void
 copy_tmp_to_mol ()
+{
   //int i, j, FORLIM;
   /*if (n_atoms == 0)
      return; *///If a NoStruct is read, this leads to madness and illegal memory access
   atom = (atom_rec *) safe_calloc (n_atoms, sizeof (atom_rec));
   bond = (bond_rec *) safe_calloc (n_bonds, sizeof (bond_rec));
   ring = (ringpath_type *) safe_calloc (1, sizeof (ringlist));
   ringprop = (ringprop_rec *) safe_calloc (1, sizeof (ringprop_type));
   n_atoms = tmp_n_atoms;
   n_bonds = tmp_n_bonds;
   n_rings = tmp_n_rings;
   n_heavyatoms = tmp_n_heavyatoms;
   n_heavybonds = tmp_n_heavybonds;
   strcpy (molname, tmp_molname);
   n_Ctot = tmp_n_Ctot;
       memcpy (ringprop, tmp_ringprop, sizeof (ringprop_type));
+    }
   memcpy (&molstat, &tmp_molstat, sizeof (tmp_molstat));
   // make sure some modes can be switched on only by the query file
   // and not by subsequent haystack file(s)
   if (ez_flag)                  // new in v0.3f
     ez_search = true;
   if (chir_flag)                // new in v0.3f
     rs_search = true;
+}
+#if 0
-/*static void copy_tmp_to_mol()
+static void copy_tmp_to_mol()
+{
   int i, j, FORLIM;
   if (tmp_n_atoms == 0)
     return;
   n_heavybonds = tmp_n_heavybonds;
   strcpy(molname, tmp_molname);
   n_Ctot = tmp_n_Ctot;
   n_Otot = tmp_n_Otot;
   n_Ntot = tmp_n_Ntot;
-  /* try
+  /* try */
   atom = (atom_rec *)safe_malloc(n_atoms * sizeof(atom_rec));
   bond = (bond_rec *)safe_malloc(n_bonds * sizeof(bond_rec));
   ring = (ringpath_type *)safe_malloc(sizeof(ringlist));
   ringprop = (ringprop_rec *)safe_malloc(sizeof(ringprop_type));
   FORLIM = tmp_n_atoms;
-  /* except
+  /* except*/
     on e:Eoutofmemory do
       begin
         writeln('Not enough memory');
         halt(4);
       end;
     atom[i].Htot = tmp_atom[i].Htot;
     atom[i].neighbor_count = tmp_atom[i].neighbor_count;
     atom[i].ring_count = tmp_atom[i].ring_count;
     atom[i].arom = tmp_atom[i].arom;
     atom[i].stereo_care = tmp_atom[i].stereo_care;
-    atom[i].heavy = tmp_atom[i].heavy;   /* v0.3l
+    atom[i].heavy = tmp_atom[i].heavy;   /* v0.3l */
-    atom[i].metal = tmp_atom[i].metal;   /* v0.3l
+    atom[i].metal = tmp_atom[i].metal;   /* v0.3l */
-    atom[i].tag = tmp_atom[i].tag;   /* v0.3o
+    atom[i].tag = tmp_atom[i].tag;   /* v0.3o */
+  }
   if (tmp_n_bonds > 0) {
     FORLIM = tmp_n_bonds;
     for (i = 0; i < FORLIM; i++) {
       bond[i].a1 = tmp_bond[i].a1;
       bond[i].a2 = tmp_bond[i].a2;
       bond[i].btype = tmp_bond[i].btype;
       bond[i].arom = tmp_bond[i].arom;
-      bond[i].ring_count = tmp_bond[i].ring_count;   /* new in v0.3d
+      bond[i].ring_count = tmp_bond[i].ring_count;   /* new in v0.3d */
-      bond[i].topo = tmp_bond[i].topo;   /* new in v0.3d
+      bond[i].topo = tmp_bond[i].topo;   /* new in v0.3d */
-      bond[i].stereo = tmp_bond[i].stereo;   /* new in v0.3d
+      bond[i].stereo = tmp_bond[i].stereo;   /* new in v0.3d */
+    }
+  }
   if (tmp_n_rings > 0) {
     FORLIM = tmp_n_rings;
     for (i = 0; i < FORLIM; i++) {
       for (j = 0; j < max_ringsize; j++)
         ring[i][j] = tmp_ring[i][j];
+    }
-    for (i = 0; i < max_rings; i++) {   /* new in v0.3
+    for (i = 0; i < max_rings; i++) {   /* new in v0.3 */
       ringprop[i].size = tmp_ringprop[i].size;
       ringprop[i].arom = tmp_ringprop[i].arom;
       ringprop[i].envelope = tmp_ringprop[i].envelope;
+    }
+  }
   molstat.n_rO1 = tmp_molstat.n_rO1;
   molstat.n_rO2p = tmp_molstat.n_rO2p;
   molstat.n_rS = tmp_molstat.n_rS;
   molstat.n_rX = tmp_molstat.n_rX;
   molstat.n_rAr = tmp_molstat.n_rAr;
-  molstat.n_rBz = tmp_molstat.n_rBz;   /* v0.3l
+  molstat.n_rBz = tmp_molstat.n_rBz;   /* v0.3l */
-  molstat.n_br2p = tmp_molstat.n_br2p;   /* v0.3n
+  molstat.n_br2p = tmp_molstat.n_br2p;   /* v0.3n */
 /* p2c: checkmol.pas, line 8169:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF extended_molstat
      molstat.n_psg01 = tmp_molstat.n_psg01;
      molstat.n_psg02 = tmp_molstat.n_psg02;
      molstat.n_psg16 = tmp_molstat.n_psg16;
      molstat.n_psg17 = tmp_molstat.n_psg17;
      molstat.n_psg18 = tmp_molstat.n_psg18;
      molstat.n_pstm = tmp_molstat.n_pstm;
      molstat.n_psla = tmp_molstat.n_psla;
-     /*$ENDIF */
+     $ENDIF */
   /* make sure some modes can be switched on only by the query file */
-  /* and not by subsequent haystack file(s)
+  /* and not by subsequent haystack file(s) */
      if (ez_flag)
      ez_search = true;
      if (chir_flag)
      rs_search = true;
-     } */
+     }
+#endif
           if (!strcmp (atype, "O3 "))
             molstat.n_O3++;
           if (!strcmp (atype, "N1 "))
             molstat.n_N1++;
           if (!strcmp (atype, "N2 ") || !strcmp (atype, "NAR") ||
-              !strcmp (atype, "NAM") && atom[i].arom == true)
+              (!strcmp (atype, "NAM") && atom[i].arom == true))
             /* v0.3n */
             molstat.n_N2++;
           if (!strcmp (atype, "N3 ") || !strcmp (atype, "NPL") ||
               !strcmp (atype, "N3+") ||
-              !strcmp (atype, "NAM") && atom[i].arom == false)
+              (!strcmp (atype, "NAM") && atom[i].arom == false))
             /* v0.3n */
             molstat.n_N3++;
           if (!strcmp (elem, "A "))     /* query atom */
             molstat.n_QA++;
           if (!strcmp (elem, "Q "))     /* query atom */
                 molstat.n_b2++;
               if (btype == 'T')
                 molstat.n_b3++;
+            }
           /* v0.3n: ignore bonds to (explicit) hydrogens */
-          if (!strcmp (a1el, "C ") && !strcmp (a2el, "O ") ||
+          if ((!strcmp (a1el, "C ") && !strcmp (a2el, "O ")) ||
-              !strcmp (a1el, "O ") && !strcmp (a2el, "C "))
+              (!strcmp (a1el, "O ") && !strcmp (a2el, "C ")))
+            {
               if (btype == 'S')
                 molstat.n_C1O++;
               if (btype == 'D')
                 molstat.n_C2O++;
+            }
-          if (!strcmp (a1el, "C ") && !strcmp (a2el, "N ") ||
+          if ((!strcmp (a1el, "C ") && !strcmp (a2el, "N ")) ||
-              !strcmp (a1el, "N ") && !strcmp (a2el, "C "))
+              (!strcmp (a1el, "N ") && !strcmp (a2el, "C ")))
             molstat.n_CN++;
           if (strcmp (a1el, "C ") && atom[a1 - 1].heavy
               && strcmp (a2el, "C ") && atom[a2 - 1].heavy)
             molstat.n_XY++;
           /* new in v0.3n: number of bonds belonging to more than one ring */
   int ndl_btopo;                /* new in v0.3d */
   boolean res = false;
 /* p2c: checkmol.pas, line 8960:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
-  char na[256], ha[256];
+  /*char na[256]; char ha[256];*/
   char tstr[256];
   /*$ENDIF */
 /* p2c: checkmol.pas, line 8966:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   int ndl_btopo;                /* new in v0.3d */
   boolean res = false;
 /* p2c: checkmol.pas, line 9032:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
-  char na[256], ha[256];
+  /*char na[256], ha[256];*/
   char tstr[256];
   /*$ENDIF */
   int a1, a2;
   str2 a1_el, a2_el;
 quick_match ()
+{
   /* added in v0.2c */
   int i;
   boolean res = true;
-  str3 ndl_atype;
+ /* str3 ndl_atype;*/
   str2 ndl_el;                  /* v0.3l */
   int ndl_chg;                  /* v0.3l */
   int ndl_rad;                  /* v0.3x */
   int ndl_iso;                  /* v0.3x */
           if (opt_chg)
+            {
               if (ndl_atom[i].formal_charge != atom[i].formal_charge)
                 return false;
             }
 /*  else
+    {
       if (ndl_atom[i].formal_charge != 0 &&
           atom[i].formal_charge != 0 &&
           ndl_atom[i].formal_charge != atom[i].formal_charge)
         return false;
                 res=false;
+            }
+        }
+    }
 /* p2c: checkmol.pas, line 9828:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
   /*$IFDEF debug */
   //if (res)
   //  debugoutput (" ==> quick_match succeeded");
   //else
   //  debugoutput (" ==> quick_match failed (2)");
   /*$ENDIF */
+        }
+    }
   return res;                   /* v0.3m (return true if any change was made */
+}
+#if 0
 static void
 chk_wildcard_rings ()           // new in v0.3p
 // checks if there are any wildcard atom types or bond types
 // in a ring of the needle; if yes ==> set the q_arom flag in the
 // atom and bond record of all ring members in order to perform the
+        }
+    }
   // some further refinement would be necessary here in order to unflag everything
   // which contains a wildcard but which definitely cannot be aromatic
+}
+#endif
 #ifndef MAKE_SHARED_LIBRARY
 int
 main (int argc, char *argv[])
           show_usage ();
           exit (2);             /* new in v0.2k */
+        }
       if (!(file_exists (ndl_molfilename)) && !opt_stdin)
-        {                       /*not  fileexists(ndl_molfilename) REPLACE!!!
+        {                       /*not  fileexists(ndl_molfilename) REPLACE!!! */
                                    printf("2");
                                    /* p2c: checkmol.pas, line 10128:
                                    * Warning: Expected an expression, found a ')' [227] */
           if (strlen (ndl_molfilename) > 1 && ndl_molfilename[0] == '-')
             show_usage ();
          if (!found_arominfo)
          debugoutput
          ("no aromaticity information found - checking myself...");
          else
          debugoutput ("performing full aromaticity check");
-         /* new in v0.3d */
+         // new in v0.3d
-      /*$ENDIF */
+      $ENDIF */
       chk_ringbonds ();
       if (ringsearch_mode == rs_ssr)
         remove_redundant_rings ();
       if (n_rings >= max_rings)
+        {
     {                           /* v0.3k */
 /* p2c: checkmol.pas, line 10206:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
       /*$IFDEF debug
          debugoutput ("found aromaticity information in input file");
-         /*$ENDIF */
+         $ENDIF */
       if (!opt_xmdlout)
         normalize_ionic_bonds ();
       update_atypes ();         /* added in v0.2f */
       update_Htotal ();         /* end v0.2b snippet */
+    }
                 read_MDLmolfile (molfilename);
               mol_count++;
               fpindex++;
               count_neighbors ();
               /*if (not mol_OK) or (n_atoms < 1) then writeln(mol_count,':no valid structure found') else */
-              if (!mol_OK || n_atoms < 1
+              if (!mol_OK || (n_atoms < 1
-                  && !(opt_fp && fpformat == fpf_decimal))
+                  && !(opt_fp && fpformat == fpf_decimal)))
                 printf ("%i:F\n", mol_count);
               else
+                {
                   if (opt_exact
                       && (n_Ctot != ndl_n_Ctot || n_Otot != ndl_n_Otot
                       if (!opt_molout && !(opt_fp && fpformat == fpf_decimal))
                         printf ("%i:F\n", mol_count);
+                    }
                   else
+                    {
-                      if (!found_arominfo || opt_strict && tmfmismatch)
+                      if (!found_arominfo || (opt_strict && tmfmismatch))
                         {       /* added in v0.3m */
 /* p2c: checkmol.pas, line 10294:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
                           /*$IFDEF debug
                              debugoutput
                              ("no aromaticity information found (or tweak mismatch) - checking myself...");
-                             /*$ENDIF */
+                            *$ENDIF */
                           chk_ringbonds ();
                           if (ringsearch_mode == rs_ssr)
                             remove_redundant_rings ();
                           if (n_rings == max_rings)
+                            {
 /* p2c: checkmol.pas, line 10322:
  * Note: Turbo Pascal conditional compilation directive was ignored [218] */
                           /*$IFDEF debug
                              debugoutput
                              ("found aromaticity information in input file");
-                             /*$ENDIF */
+                             $ENDIF */
                           if (opt_strict)
                             update_atypes ();
                           update_Htotal ();
+                        }
                       init_molstat (&ndl_molstat);
+                            }
+                        }
                       else
+                        {
                           if (!
-                              (opt_molout || opt_fp
+                              (opt_molout || (opt_fp
-                               && fpformat == fpf_decimal))
+                               && fpformat == fpf_decimal)))
                             /* inttostr(mol_count), REPLACE!!! */
                             printf ("%i:F\n", mol_count);
+                        }
                       if (opt_fp && fpformat == fpf_decimal
                           && fpindex == fp_blocksize)
   fp_exactblock = false;        /* v0.3m */
   tmfcode = 0;                  /* v0.3m */
   tmfmismatch = false;          /* v0.3m */
   auto_ssr = false;
   recursion_depth = 0;
 }
 static void
 mm_init_mol (void)
+{
   if (strcmp (filetype, "sybyl") == 0)
     read_mol2file (ndl_molfilename);
   if (strcmp (filetype, "mdl") == 0)
     read_MDLmolfile (ndl_molfilename);
   if (checkmol_mode)
     {
       if (found_querymol)
+        {
           printf
             ("Warning: Input structure contains query atom or query bond.\n");
+        }
+    }
 //printf("mm_elab_mol\n");
 }
 DLLEXPORT void
 mm_set_current_mol_as_query (void)
+{
 //printf("mm_set_current_mol_as_query\n");
   else if (!ez_flag && ez_search)
     ez_search = false;          //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
   if (opt_chiral)
     {                           /* v0.3f */
       rs_search = true;
       //printf("%i\n",rs_search);
+    }
   else if (!chir_flag && rs_search)
+    {
       rs_search = false;        //chir_flag initialized in read_MDLmolfile, otherwise we lose that info
       //printf("%i\n",rs_search);
+    }
   if (opt_chiral && opt_strict && opt_exact)    /* new in v0.3j */
     rs_strict = true;
   else
     rs_strict = false;
-  /* if (rs_strict)              /* v0.3j
+  /* if (rs_strict)              // v0.3j
      ndl_ref_atom = find_ndl_ref_atom_cv ();
      //ndl_ref_atom = find_ndl_ref_atom ();
      else
      ndl_ref_atom = find_ndl_ref_atom (); */
   molbufindex = 0;
   mol_count = 0;
-//printf("mm_set_current_mol_as_query\n");
+/*printf("mm_set_current_mol_as_query\n");*/
+}
 DLLEXPORT int
 mm_get_rings (void)
+{

Subversion Repositories wimsdev

(root)/trunk/wims/src/Misc/checkmol/checkmolc.c – Rev 5505 → 6785