Subversion Repositories wimsdev

/*

   Modified to run w/o p2c libraries

   2007 Ernst-Georg Schmid

   Modified to run as shared library

   2007 Ernst-Georg Schmid

   pgchem@tuschehund.de

   compile with gcc without optimizations (except -march= -mcpu=) or it gets SLOWER!

   THIS VERSION HAS extended_molstat SWITCHED ON BY DEFAULT!

   This file is part of the xchem::tigress project.

   --- DUAL LICENSING ---

   If checkmol.c aka. pgchem::barsoi is compiled as a library, it is released under the terms of the

   lesser GNU General Public License. For the executable, the original GPL

   licensing applies!

   This program is free software; you can redistribute it and/or modify

   it under the terms of the lesser GNU General Public License as published by

   the Free Software Foundation version 2.1 of the License.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   lesser GNU General Public License for more details.

   --- DUAL LICENSING ---

   ORIGINAL HEADER:

checkmol/matchmol

Norbert Haider, University of Vienna, 2003-2007

norbert.haider@univie.ac.at

This software is published under the terms of the GNU General Public

License (GPL, see below). For a detailed description of this license,

see http://www.gnu.org/copyleft/gpl.html

If invoked as "checkmol", this program reads 2D and 3D molecular structure

files in various formats (Tripos Alchemy "mol", Tripos SYBYL "mol2", MDL "mol")

and describes the molecule either by its functional groups or by a set of

descriptors useful for database pre-screening (number of rings, sp2-hybridized

carbons, aromatic bonds, etc.; see definition of molstat_rec).

If invoked as "matchmol", the program reads two individual 2D or 3D molecular

structure files in various formats (see above) and checks if the first molecule

(the "needle") is a substructure of the second one (the "haystack").

"Haystack" can also be a MDL SD-file (containing multiple MOL files);

if invoked with "-" as file argument, both "needle" and "haystack" are

read as an SD-file from standard input, assuming the first entry in

the SDF to be the "needle"; output: entry number + ":F" (false) or ":T" (true)

Compile with fpc (Free Pascal, see http://www.freepascal.org), using

the -Sd or -S2 option (Delphi mode; IMPORTANT!)

example for compilation (with optimization) and installation:

fpc checkmol.pas -S2 -Xs -OG -Or -O2u -Op1

as "root", do the following:

cp checkmol /usr/local/bin

cd /usr/local/bin

ln checkmol matchmol

Version history

v0.1   extends "chkmol" utility (N. Haider, 2002), adds matching functionality;

v0.1a  minor bugfixes:

       stop ring search when max_rings is reached (function is_ringpath);

       fixed upper/lowercase of element symbol in MDL molfile output;

       added debug output for checkmol (-D option)

v0.2   added functionality to switch ring search from SAR (set of all rings) to

       SSR (set of small rings; see below) if number of rings exceeds max_rings

       (1024), e.g. with Buckminster-fullerenes (thanks to E.-G. Schmid for a hint);

       added -r command-line option to force ring search into SSR mode;

       as SSR, we regard the set of all rings with max. 10 ring members, and in

       which no ring is completely contained in another one

v0.2a  fixed a bug in function is_ringpath which could cause SAR ring search to

       overlook a few rings (e.g., the six 8-membered rings in cubane)

v0.2b  fixed unequal treatment of needle and haystack structures with respect

       to aromaticity check (trusting input file vs. full check)

v0.2c  modified the changes of v0.2b so that they affect only "matchmol" mode;

       added quick_match function

v0.2d  refined function bondtypes_OK so that it does not accept C=O fragments

       (and C=S, C=Se, C=Te) as equivalent to aromatic C-O (C-S, C-Se, C-Te);

       fixed function find_ndl_ref_atom to use only heavy atoms as "needle"

       reference atoms for atom-to-atom match; update function quick_match to

       handle queries with only one heavy atom (thanks to A. Barozza for a hint)

v0.2e  modified procedure get_molstat: adds 1 formal double bond for each aromatic

       ring to the "fingerprint" in order to allow an isolated double bond in the

       needle to be matched as a fragment of an aromatic ring

       ATTENTION: "fingerprints" (molecular statistics) generated with a previous

       version of checkmol(-x and -X option) must be updated for structure/

       substructure database searching with matchmaol.

v0.2f  modified procedures chk_ccx, chk_xccx, write_fg_text, write_fg_text_de,

       write_fg_code in order to report halogen derivatives other than alkyl halides,

       aryl halides and acyl halides (e.g., vinyl halides) and C=C compounds other

       than "true" alkenes, enols, enediols, enamines, etc. (e.g. vinyl halides);

       added "strict mode" (option -s) for matching: this uses a more thorough

       comparison of atom types and bond types (new functions atomtypes_OK_strict,

       bondtypes_OK_strict, several minor modifications in other subroutines).

v0.2g  changed procedure readinputfile (+ minor changes in main routine) in

       order to read very large SD input files without "not enough memory" error

       (the previous version attempted to read the entire SD file into a buffer,

       the new version reads only one molecule at once);

       fixed a minor bug in read_mol2file which led to undefined bond types;

       added definition of "debug" option as a compiler flag.

v0.2h  fixed a small bug which caused program hangs with (e.g.) some metal

       complexes: this was solved just by increasing the number of possible

       neighbor atoms from 8 to 16 (now defined in the constant max_neighbors).

v0.2i  introduced some more plausibility checking (number of directly connected

       atoms), result stored in variable mol_OK (set in count_neighbors);

       completely rewrote function matrix_OK which now can handle up to

       max_neighbors substituents per atom (previous versions were limited to

       4 substituents; larger numbers are required e.g. for ferrocenes and

       similar compounds).

v0.2j  new function raw_hetbond_count: ignores bond order (in contrast to function

       hetbond_count), this is better suitable for molecular statistics.

       ATTENTION: previously generated "fingerprints" in databases must be updated!

       improved recognition of non-conformant SD files (with missing "M  END" line)

v0.2k  changed quick_match routine to compare atom types only by element in

       order to avoid (rare) cases of non-matching identical input files;

       slightly changed error message for non-existant input files

v0.3   changed function update_Htotal in order to distinguish between 3-valent

       and 5-valent phosphorus (thanks to H. Feldman for this suggestion);

       added a table (array ringprop) to store ring sizes and aromaticity for

       faster lookup; changed aromaticity detection (chk_arom) to be fully

       independent of Kekule structures in condensed ring systems; changed add_ring

       to store new rings in ascending order (with respect to ring size): this

       will cause the aromaticity detection to start with smaller rings;

       added additional calls to chk_arom when in SSR ring search mode (to ensure

       that all aromatic rings are found); speeded up function is_newring;

       added option "-M": this restores the behavior of previous versions,

       i.e. metal atoms will be accepted as ring members (which costs a lot

       of performance for coordinate compounds like ferrocenes but gives

       only little useful information); when used in databases: use the _same_

       mode ("-M" or not) _both_ for checkmol (creation of fingerprints) and matchmol;

       fixed ugly linebreaks in show_usage;

v0.3a  fixed a bug in read_charges (which was introduced in the v0.3 code cleanup)

v0.3b  fixed recognition of ketenes, CO2, CS2, CSO, phosphines, boronic esters

v0.3c  fixed recognition of hydrazines, hydroxylamines, thiocarboxylic acids,

       orthocarboxylic acids; slightly changed textual output for a few functional

       groups

v0.3d  added bond topology feature ("any", "ring", "chain", as defined by MDL specs,

       plus "always_any", "excess-ringcount", "exact-ringcount") to bond properties

       and implemented its use for substructure searches, either as specified in the

       query MDL molfile or by using "strict" mode; added ring_count property to

       "bonds" section of Checkmol-tweaked molfiles (using an unused field in the MDL

       molfile specs);

       added option for E/Z isomer search, either globally (-g option) or per

       double bond: bstereo_xyz property, encoded either by a leading "0" in the

       bond block of a checkmol-tweaked molfile or by using the "stereo care" flag

       as defined in the MDL file specs (both atoms of a double bond must carry

       this flag)

v0.3e  fixed wrong position of "stereo care" flag expected in input molfile;

v0.3f  added option for enantiospecific search (R/S isomer search); this can be

       turned on either globally (-G option or using the "chiral" flag in the

       "counts line" of the query MDL molfile) or per atom (using - or abusing -

       the "stereo care" flag); enantiomers are compared using the 3D coordinates

       of the substituents at a chiral center, so we do not have to rely on the

       presence of correct "up" and "down" bond types in the candidate structures;

       nevertheless, "pseudo-3D" structures (i.e. flat 2D structures with "up"

       and "down" bond notation) can be also used, even in mixed mode both as

       query structure and candidate structure; added support for "up" and "down"

       bond notation in MDL molfile output (if -m option is used and these bond

       types were present in the input file); refined function find_ndl_ref_atom;

       fixed Alchemy atom type misinterpretation (upper/lower case mismatch);

v0.3g  minor fixes: recognition of sp2 nitrogen in N=N structures (function

       update_atypes); extended E/Z geometry check to C=N and N=N bonds; accelerated

       exact search by initial comparison of C,O,N counts; added meaningful error

       message for input structures with 0 (zero) atoms;

v0.3h  added a match matrix clean-up step to function is_matching in order to

       remove "impossible" multiple matches prior to chirality check; added

       function ndl_maybe_chiral as a plausibility check; added support for other

       atoms than carbon as chiral centers; changed function is_cis from a

       distance-based cis/trans check into a torsion-based check;

v0.3i  minor fixes in functions max_neighbors and chk_ammon;

       revert ringsearch_mode to its original value for each new molecule

       (main routine)

v0.3j  various improvements in checkmol: added alkenyl (vinyl) and alkynyl

       residues as possible substituents for amides, esters, ethers, etc.;

       extended recognition of orthocarboxylic acid derivatives; refined

       recognition of oxohetarenes and iminohetareenes, ureas, nitroso

       compounds; fixed reading of "old-style" charges from MDL files;

       refined aromaticity check; fixed a bug in procedure chk_arom and

       renamed function is_exocyclic_methylene_C into

       find_exocyclic_methylene_C; added assignment of pointers to "nil"

       after calling "freemem" in procedure zap_molecule and zap_needle;

       matchmol: refined selection of needle reference atom; added "strict

       chirality check" mode (if -x -s and -G options are used): returns

       "false" if a chiral or pseudochiral atom is matched against its

       counterpart with undefined or "flat" geometry; added an alternative

       selection mechanism for the needle reference atom, based on the

       Morgan algorithm;

v0.3k  improved matching of nitro compounds (ionic vs. non-ionic

       representation); some finetuning in recognition of N-oxides,

       hydroxylamines, etc.; modified get_molstat in order to ignore

       charges in nitro groups, N-oxides, sulfoxides, azides, etc. in

       ionic representation; added function normalize_ionic_bonds;

       fixed a bug in is_alkenyl; fixed a bug (introduced in v0.3j) in

       the treatment of "old-style" MDL charges;

v0.3l  minor adjustments in quick_match (for unknown atom types,

       opposite charges); some performance improvements, e.g. in function

       path_pos, reduced extensive calls to is_heavyatom and is_metal

       by extending atom_rec with boolean fields 'heavy' and 'metal'

       (thanks to E.-G.Schmid); added molstat field n_rBz (number of

       benzene rings; deactivated by default); added -l command-line

       option to checkmol (lists all molstat codes with a short

       explanation); added graceful handling of NoStruct (i.e.,

       zero-atom) molecules

v0.3m  minor bug fixes (chk_imine), let normalize_ionic_bonds return "true"

       if some bond-order change was made; fixed incorrect implementation

       of the Morgan algorithm (thanks to H.Feldman), fixed is_matching in

       order to prevent wrong matches of larger rings on smaller ones; count

       halogens also as type "X" in molstat (as before v0.3l); added some more

       molstat descriptors for most elements (deactivated by default; for

       activation, uncomment the definition of "extended_molstat", see below);

       added support for the generation of binary fingerprints with output

       either as boolean values (-f option) or as decimal values (-F option),

       fingerprint patterns are supplied by the user (in SDF format, max. 62

       structures per file); added a version check ("tweaklevel",

       ringsearch_mode, opt_metalrings) for "tweaked" MDL molfiles

v0.3n  increased max_vringsize in SSR mode from 10 to 12 (now defined in

       ssr_vringsize); optionally changed ring statistics to ignore envelope

       rings (which completely contain another ring, "reduced SAR") in order to

       make molstat in SAR and SSR mode more compatible) - disabled by default;

       introduced a new molstat descriptor: n_br2p (number of bonds which

       belong to two or more rings); changed n_b1 counter to ignore bonds to

       explicit hydrogens; added procedure fix_ssr_ringcounts

       (see comment in the code); added bond property mdl_stereo for preservation

       of original value; slightly changed "get_molstat" and "update_atypes" in

       order to consolidate atom type for various N atoms; remember "chiral" flag

       status in molfile output (-m); modified chk_arom in order to accept rings

       as aromatic if all bonds are of type 'A'; several minor bug fixes

v0.3o  minor changes in update_atypes (nitrogen); changed the matching

       algorithm in order to take care of disconnected molecular graphs

       (e.g., salts); refined matching of atoms with formal charges

Credits:

Rami Jbara (rami_jbara@hotmail.com) designed the 8-character functional

group codes.

I am also very grateful to Ernst-Georg Schmid (Bayer Business Services,

Leverkusen/Germany) and to Howard Feldman (The Blueprint Initiative,

Toronto/Canada) for numerous bug reports and suggestions for improvements.

===============================================================================

DISCLAIMER

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software Foundation,

Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

===============================================================================

*/

/* $DEFINE debug                    uncomment if desired */

/* $DEFINE extended_molstat         uncomment if desired */

/* $DEFINE reduced_SAR              uncomment if desired */

/* uses

  SYSUTILS, MATH; */

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "safemem.h"

#ifdef MAKE_SHARED_LIBRARY

#include "barsoi.h"

#endif

#ifdef MAKE_SHARED_LIBRARY

#define version         "0.3p C (pgchem::barsoi)"

#else

#define version         "0.3p C"

#endif

#undef REDUCED_SAR

/* How many recursions before aborting is_ringpath and reverting to SSR */

#define max_ringpath_recursion_depth   500000

/* How many recursions before aborting is_match and reverting to non-exhaustive match */

#define max_match_recursion_depth   500000

#define tweaklevel      2

    /* v0.3m; accept tweaks in MDL molfiles only if same level */

#define max_atoms       1024

#define max_bonds       1024

#define slack           8192

#define max_ringsize    128

#define max_rings       1024

#define max_fg          256

#define max_neighbors   16      /* new in v0.2h */

#define TAB             '\t'

#define max_matchpath_length  256

#define pmCheckMol      1001

#define pmMatchMol      1002

#define rs_sar          2001    /* ring search mode: SAR = set of all rings */

#define rs_ssr          2002

    /*                   SSR = set of small rings */

#define btopo_any       0       /* bond topology, new in v0.3d */

#define btopo_ring      1

#define btopo_chain     2

#define btopo_always_any  3     /* even in "strict mode" */

#define btopo_excess_rc  4

/* bond in candidate must be included in _more_ rings than

                        the matching bond in the query ==> specific search for

                        annulated systems */

#define btopo_exact_rc  5

    /* bond in query and candidate must have same ring count */

#define bstereo_any     0

    /* new in v0.3d, any E/Z isomer matches (for double bonds) */

#define bstereo_xyz     1

    /* E/Z match is checked by using XYZ coordinates of the atoms */

#define bstereo_up      11      /* new in v0.3f, flags for single bonds */

#define bstereo_down    16

#define bstereo_either    14    /* 0.3x */

#define bstereo_double_either    13     /* 0.3x */

#define fpf_boolean     3001

    /* v0.3m; format for fingerprint output (n:T, n:F) */

#define fpf_decimal     3002

    /* v0.3m; format for fingerprint output as decimal value of bitstring */

#define fp_blocksize    62

    /* v0.3m; 1 bit may be used for sign (e.g. by PHP), 1 bit for "exact hit" */

#define ssr_vringsize   12      /* v0.3n; max. ring size in SSR mode */

/* Definitions for functional groups: */

#define fg_cation       1

#define fg_anion        2

#define fg_carbonyl     3

#define fg_aldehyde     4

#define fg_ketone       5

#define fg_thiocarbonyl  6

#define fg_thioaldehyde  7

#define fg_thioketone   8

#define fg_imine        9

#define fg_hydrazone    10

#define fg_semicarbazone  11

#define fg_thiosemicarbazone  12

#define fg_oxime        13

#define fg_oxime_ether  14

#define fg_ketene       15

#define fg_ketene_acetal_deriv  16

#define fg_carbonyl_hydrate  17

#define fg_hemiacetal   18

#define fg_acetal       19

#define fg_hemiaminal   20

#define fg_aminal       21

#define fg_thiohemiaminal  22

#define fg_thioacetal   23

#define fg_enamine      24

#define fg_enol         25

#define fg_enolether    26

#define fg_hydroxy      27

#define fg_alcohol      28

#define fg_prim_alcohol  29

#define fg_sec_alcohol  30

#define fg_tert_alcohol  31

#define fg_1_2_diol     32

#define fg_1_2_aminoalcohol  33

#define fg_phenol       34

#define fg_1_2_diphenol  35

#define fg_enediol      36

#define fg_ether        37

#define fg_dialkylether  38

#define fg_alkylarylether  39

#define fg_diarylether  40

#define fg_thioether    41

#define fg_disulfide    42

#define fg_peroxide     43

#define fg_hydroperoxide  44

#define fg_hydrazine    45

#define fg_hydroxylamine  46

#define fg_amine        47

#define fg_prim_amine   48

#define fg_prim_aliph_amine  49

#define fg_prim_arom_amine  50

#define fg_sec_amine    51

#define fg_sec_aliph_amine  52

#define fg_sec_mixed_amine  53

#define fg_sec_arom_amine  54

#define fg_tert_amine   55

#define fg_tert_aliph_amine  56

#define fg_tert_mixed_amine  57

#define fg_tert_arom_amine  58

#define fg_quart_ammonium  59

#define fg_n_oxide      60

#define fg_halogen_deriv  61

#define fg_alkyl_halide  62

#define fg_alkyl_fluoride  63

#define fg_alkyl_chloride  64

#define fg_alkyl_bromide  65

#define fg_alkyl_iodide  66

#define fg_aryl_halide  67

#define fg_aryl_fluoride  68

#define fg_aryl_chloride  69

#define fg_aryl_bromide  70

#define fg_aryl_iodide  71

#define fg_organometallic  72

#define fg_organolithium  73

#define fg_organomagnesium  74

#define fg_carboxylic_acid_deriv  75

#define fg_carboxylic_acid  76

#define fg_carboxylic_acid_salt  77

#define fg_carboxylic_acid_ester  78

#define fg_lactone      79

#define fg_carboxylic_acid_amide  80

#define fg_carboxylic_acid_prim_amide  81

#define fg_carboxylic_acid_sec_amide  82

#define fg_carboxylic_acid_tert_amide  83

#define fg_lactam       84

#define fg_carboxylic_acid_hydrazide  85

#define fg_carboxylic_acid_azide  86

#define fg_hydroxamic_acid  87

#define fg_carboxylic_acid_amidine  88

#define fg_carboxylic_acid_amidrazone  89

#define fg_nitrile      90

#define fg_acyl_halide  91

#define fg_acyl_fluoride  92

#define fg_acyl_chloride  93

#define fg_acyl_bromide  94

#define fg_acyl_iodide  95

#define fg_acyl_cyanide  96

#define fg_imido_ester  97

#define fg_imidoyl_halide  98

#define fg_thiocarboxylic_acid_deriv  99

#define fg_thiocarboxylic_acid  100

#define fg_thiocarboxylic_acid_ester  101

#define fg_thiolactone  102

#define fg_thiocarboxylic_acid_amide  103

#define fg_thiolactam   104

#define fg_imido_thioester  105

#define fg_oxohetarene  106

#define fg_thioxohetarene  107

#define fg_iminohetarene  108

#define fg_orthocarboxylic_acid_deriv  109

#define fg_carboxylic_acid_orthoester  110

#define fg_carboxylic_acid_amide_acetal  111

#define fg_carboxylic_acid_anhydride  112

#define fg_carboxylic_acid_imide  113

#define fg_carboxylic_acid_unsubst_imide  114

#define fg_carboxylic_acid_subst_imide  115

#define fg_co2_deriv    116

#define fg_carbonic_acid_deriv  117

#define fg_carbonic_acid_monoester  118

#define fg_carbonic_acid_diester  119

#define fg_carbonic_acid_ester_halide  120

#define fg_thiocarbonic_acid_deriv  121

#define fg_thiocarbonic_acid_monoester  122

#define fg_thiocarbonic_acid_diester  123

#define fg_thiocarbonic_acid_ester_halide  124

#define fg_carbamic_acid_deriv  125

#define fg_carbamic_acid  126

#define fg_carbamic_acid_ester  127

#define fg_carbamic_acid_halide  128

#define fg_thiocarbamic_acid_deriv  129

#define fg_thiocarbamic_acid  130

#define fg_thiocarbamic_acid_ester  131

#define fg_thiocarbamic_acid_halide  132

#define fg_urea         133

#define fg_isourea      134

#define fg_thiourea     135

#define fg_isothiourea  136

#define fg_guanidine    137

#define fg_semicarbazide  138

#define fg_thiosemicarbazide  139

#define fg_azide        140

#define fg_azo_compound  141

#define fg_diazonium_salt  142

#define fg_isonitrile   143

#define fg_cyanate      144

#define fg_isocyanate   145

#define fg_thiocyanate  146

#define fg_isothiocyanate  147

#define fg_carbodiimide  148

#define fg_nitroso_compound  149

#define fg_nitro_compound  150

#define fg_nitrite      151

#define fg_nitrate      152

#define fg_sulfuric_acid_deriv  153

#define fg_sulfuric_acid  154

#define fg_sulfuric_acid_monoester  155

#define fg_sulfuric_acid_diester  156

#define fg_sulfuric_acid_amide_ester  157

#define fg_sulfuric_acid_amide  158

#define fg_sulfuric_acid_diamide  159

#define fg_sulfuryl_halide  160

#define fg_sulfonic_acid_deriv  161

#define fg_sulfonic_acid  162

#define fg_sulfonic_acid_ester  163

#define fg_sulfonamide  164

#define fg_sulfonyl_halide  165

#define fg_sulfone      166

#define fg_sulfoxide    167

#define fg_sulfinic_acid_deriv  168

#define fg_sulfinic_acid  169

#define fg_sulfinic_acid_ester  170

#define fg_sulfinic_acid_halide  171

#define fg_sulfinic_acid_amide  172

#define fg_sulfenic_acid_deriv  173

#define fg_sulfenic_acid  174

#define fg_sulfenic_acid_ester  175

#define fg_sulfenic_acid_halide  176

#define fg_sulfenic_acid_amide  177

#define fg_thiol        178

#define fg_alkylthiol   179

#define fg_arylthiol    180

#define fg_phosphoric_acid_deriv  181

#define fg_phosphoric_acid  182

#define fg_phosphoric_acid_ester  183

#define fg_phosphoric_acid_halide  184

#define fg_phosphoric_acid_amide  185

#define fg_thiophosphoric_acid_deriv  186

#define fg_thiophosphoric_acid  187

#define fg_thiophosphoric_acid_ester  188

#define fg_thiophosphoric_acid_halide  189

#define fg_thiophosphoric_acid_amide  190

#define fg_phosphonic_acid_deriv  191

#define fg_phosphonic_acid  192

#define fg_phosphonic_acid_ester  193

#define fg_phosphine    194

#define fg_phosphinoxide  195

#define fg_boronic_acid_deriv  196

#define fg_boronic_acid  197

#define fg_boronic_acid_ester  198

#define fg_alkene       199

#define fg_alkyne       200

#define fg_aromatic     201

#define fg_heterocycle  202

#define fg_alpha_aminoacid  203

#define fg_alpha_hydroxyacid  204

typedef enum

  { isfalse = 0, istrue } boolean;

typedef char str2[3];

typedef char str3[4];

typedef char str4[5];

typedef char str5[6];

typedef char str8[9];

typedef struct atom_rec

{

  str2 element;

  str3 atype;

  float x, y, z;

  int formal_charge;

  float real_charge;

  int Hexp;      /* explicit H count */

  int Htot;      /* total H count */

  int neighbor_count, ring_count;

  boolean arom, stereo_care;  /* new in v0.3d */

  boolean q_arom;    // v0.3p potentially aromatic in a query structure

  boolean heavy;    /* new in v0.3l */

  boolean metal;    /* new in v0.3l */

  int nvalences;    /* new in v0.3m */

  boolean tag;      /* new in v0.3o */

  int nucleon_number;   /* 0.3.x */

  int radical_type;             /* 0.3.x */

} atom_rec;

typedef struct bond_rec

{

  int a1, a2;

  char btype;

  int ring_count;

  boolean arom;

  boolean q_arom;    // v0.3p potentially aromatic in a query structure

  int topo;      /* new in v0.3d, see MDL file description */

  int stereo;    /* new in v0.3d */

  int mdl_stereo;/* new in v0.3n */

} bond_rec;

typedef int ringpath_type[max_ringsize];

typedef int matchpath_type[max_matchpath_length];

typedef atom_rec atomlist[max_atoms];

typedef bond_rec bondlist[max_bonds];

typedef ringpath_type ringlist[max_rings];

typedef int neighbor_rec[max_neighbors];  /* new in v0.2h */

typedef boolean fglist[max_fg];

typedef char molbuftype[max_atoms + max_bonds + slack][256];

typedef boolean matchmatrix[max_neighbors][max_neighbors];

    /* new in v0.2i */

typedef struct molstat_rec

{

  int n_QA, n_QB, n_chg;  /* number of query atoms, query bonds, charges */

  int n_C1, n_C2, n_C;

  /* number of sp, sp2 hybridized, and total no. of carbons */

  int n_CHB1p, n_CHB2p, n_CHB3p, n_CHB4;

  /* number of C atoms with at least 1, 2, 3 hetero bonds */

  int n_O2, n_O3;    /* number of sp2 and sp3 oxygens */

  int n_N1, n_N2, n_N3;    /* number of sp, sp2, and sp3 nitrogens */

  int n_S, n_SeTe;

  /* number of sulfur atoms and selenium or tellurium atoms */

  int n_F, n_Cl, n_Br, n_I;

  /* number of fluorine, chlorine, bromine, iodine atoms */

  int n_P, n_B;      /* number of phosphorus and boron atoms */

  int n_Met, n_X;

  /* number of metal and "other" atoms (not listed elsewhere); v0.3l */

  int n_b1, n_b2, n_b3, n_bar;

  /* number single, double, triple, and aromatic bonds */

  int n_C1O, n_C2O, n_CN, n_XY;

  /* number of C-O single bonds, C=O double bonds, CN bonds (any type), hetero/hetero bonds */

  int n_r3, n_r4, n_r5, n_r6, n_r7, n_r8;

  /* number of 3-, 4-, 5-, 6-, 7-, and 8-membered rings */

  int n_r9, n_r10, n_r11, n_r12, n_r13p;

  /* number of 9-, 10-, 11-, 12-, and 13plus-membered rings */

  int n_rN, n_rN1, n_rN2, n_rN3p;

  /* number of rings containing N (any number), 1 N, 2 N, and 3 N or more */

  int n_rO, n_rO1, n_rO2p;

  /* number of rings containing O (any number), 1 O, and 2 O or more */

  int n_rS, n_rX, n_rAr, n_rBz;

  /* number of rings containing S (any number), any heteroatom (any number),  */

  /* number of aromatic rings, number of benzene rings */

  int n_br2p;      /* number of bonds belonging to more than one ring (v0.3n) */

  /* p2c: checkmol.pas, line 590:

    * Note: Turbo Pascal conditional compilation directive was ignored [218] */

  /*$IFDEF extended_molstat */

  int n_psg01, n_psg02, n_psg13, n_psg14;

  /* number of atoms belonging to elements of group 1, 2, etc.  */

  int n_psg15, n_psg16, n_psg17, n_psg18;

  /* number of atoms belonging to elements of group 15, 16, etc.  */

  int n_pstm, n_psla;

  /* number of transition metals, lanthanides/actinides */

  int n_iso, n_rad;

  /* number of isotopes, radicals */

  /*$ENDIF */

} molstat_rec;

typedef struct ringprop_rec

{

  /* new in v0.3 */

  int size;

  boolean arom, envelope;

} ringprop_rec;

typedef ringprop_rec ringprop_type[max_rings];

typedef struct p_3d

{

  /* new in v0.3d */

  double x, y, z;

} p_3d;

typedef int chirpath_type[4];  /* new in v0.3f */

#ifdef MAKE_SHARED_LIBRARY

static boolean yet_initialized = isfalse;

#endif

typedef struct connval_rec

{

  /* new in v0.3j */

  int def;      /* better as longint for large molecules? */

  int tmp;

} connval_rec;

typedef connval_rec connval_type[max_atoms];  /* new in v0.3j  */

static int progmode;

static char progname[256];

#ifndef MAKE_SHARED_LIBRARY

static int i;      /* general purpose index */

#endif

static int li;

static boolean opt_none, opt_verbose, opt_text, opt_text_de, opt_code,

  opt_bin, opt_bitstring, opt_stdin, opt_exact, opt_debug,

  opt_molout, opt_molstat, opt_molstat_X, opt_xmdlout, opt_strict;

    /* new in v0.2f */

static boolean opt_metalrings;  /* new in v0.3 */

static boolean opt_geom;  /* new in v0.3d */

static boolean opt_chiral;  /* new in v0.3f */

static boolean opt_iso;    /* new in v0.3x */

static boolean opt_chg;    /* new in v0.3x */

static boolean opt_rad;    /* new in v0.3x */

static int opt_rs;    /* new in v0.3i */

#ifdef MAKE_SHARED_LIBRARY

static int opt_rs_dll = RPA_DEFAULT;

#endif

static boolean opt_fp;    /* new in v0.3m */

static int fpformat;    /* new in v0.3m */

static char filetype[256];

/*molfile : text; */

static char molfilename[256];

static char ndl_molfilename[256];

static char molname[256];

static char ndl_molname[256];

static char tmp_molname[256];  /* v0.3m */

static char molcomment[256];

static int n_atoms, n_bonds, n_rings;

    /* the number of rings we determined ourselves */

static int n_countablerings;

    /* v0.3n; number of rings which are not envelope rings */

static int n_cmrings;

    /* the number of rings we read from a (CheckMol-tweaked) MDL molfile */

//static int n_charges;         /* number of charges */

static int n_heavyatoms, n_heavybonds, ndl_n_atoms, ndl_n_bonds, ndl_n_rings,

  ndl_n_heavyatoms, ndl_n_heavybonds;

/*cm_mdlmolfile  : boolean; */

static boolean found_arominfo, found_querymol, ndl_querymol;

static int tmp_n_atoms;    /* v0.3m */

static int tmp_n_bonds;    /* v0.3m */

static int tmp_n_rings;    /* v0.3m */

static int tmp_n_heavyatoms;  /* v0.3m */

static int tmp_n_heavybonds;  /* v0.3m */

static atom_rec *atom;

static bond_rec *bond;

static ringpath_type *ring;

static ringprop_rec *ringprop;  /* new in v0.3 */

static atom_rec *ndl_atom;

static bond_rec *ndl_bond;

static ringpath_type *ndl_ring;

static ringprop_rec *ndl_ringprop;  /* new in v0.3 */

static int ndl_ref_atom;  /* since v0.3j as a global variable */

static atom_rec *tmp_atom;  /* v0.3m */

static bond_rec *tmp_bond;  /* v0.3m */

static ringpath_type *tmp_ring;  /* v0.3m */

static ringprop_rec *tmp_ringprop;  /* v0.3m */

static boolean matchresult, matchsummary;  /* v0.3o */

static matchpath_type ndl_matchpath, hst_matchpath;

static fglist fg;

static str4 atomtype;

static str3 newatomtype;

static char (*molbuf)[256];

static int molbufindex;

static boolean mol_in_queue;

static int mol_count;

static molstat_rec molstat, ndl_molstat, tmp_molstat;  /* v0.3m */

static int ringsearch_mode, max_vringsize;  /* for SSR ring search */

static FILE *rfile;

static boolean rfile_is_open, mol_OK;  /* new in v0.2i */

static int n_ar;    /* new in v0.3 */

static int prev_n_ar;    /* new in v0.3 */

static boolean ez_search;  /* new in v0.3d */

static boolean rs_search;  /* new in v0.3f */

static boolean ez_flag;    /* new in v0.3f */

static boolean chir_flag;  /* new in v0.3f */

static boolean rs_strict;  /* new in v0.3j */

static int n_Ctot, n_Otot, n_Ntot;  /* new in v0.3g */

static int ndl_n_Ctot, ndl_n_Otot, ndl_n_Ntot;  /* new in v0.3g */

static int tmp_n_Ctot, tmp_n_Otot, tmp_n_Ntot;  /* new in v0.3m */

static boolean ether_generic;  /* v0.3j */

static boolean amine_generic;  /* v0.3j   */

static boolean hydroxy_generic;  /* v0.3j */

static connval_rec *cv;    /* new in v0.3j */

static long long fpdecimal;  /* v0.3m */

static long long fpincrement;

static int fpindex;

static boolean fp_exacthit, fp_exactblock;

static int tmfcode;

    /* v0.3m; version number for tweaked MDL molfiles (tweaklevel) */

static boolean tmfmismatch;

    /* v0.3m; rely on tweaked MDL molfiles only if same level */

static boolean auto_ssr;

    /* v0.3n; indicates that SAR -> SSR fallback has happened */

static int recursion_depth;

    /* ====================emulated pascal functions============================ */

static boolean

file_exists (const char *fileName)

{

  struct stat filestat;

  return stat (fileName, &filestat) == 0 ? istrue : isfalse;

}

static void lblank (int cols, char *nstr)

{

  /* inserts leading blanks up to a given number of total characters */

  char STR1[256];

  if (strlen (nstr) >= cols)

    return;

  while (strlen (nstr) < cols)

    sprintf (nstr, " %s", strcpy (STR1, nstr));

}

static inline double radtodeg (double rads)

{

  return (180.0 / M_PI) * rads;

}

static void strdelete (char *s, int pos, int len)

{

  int slen;

  if (--pos < 0)

    return;

  slen = strlen (s) - pos;

  if (slen <= 0)

    return;

  s += pos;

  if (slen <= len) {

    *s = 0;

    return;

  }

  while ((*s = s[len]))

    s++;

}

static int strpos2 (char *s, char *pat, int pos)

{

  char *cp, ch;

  int slen;

  if (--pos < 0)

    return 0;

  slen = strlen (s) - pos;

  cp = s + pos;

  if (!(ch = *pat++))

    return 0;

  pos = strlen (pat);

  slen -= pos;

  while (--slen >= 0) {

    if (*cp++ == ch && !strncmp (cp, pat, pos))

      return cp - s;

  }

  return 0;

}

static char * strsub (char *ret, char *s, int pos, int len)

{

  char *s2;

  if (--pos < 0 || len <= 0){

    *ret = 0;

    return ret;

  }

  while (pos > 0){

    if (!*s++){

      *ret = 0;

      return ret;

    }