rino 0.1.0

data/ext/src/e_util.c

@@ -0,0 +1,284 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+#include "e_mode.h"
+#include "inchi_api.h"
+#include "e_ichisize.h"
+#include "e_comdef.h"
+#include "e_util.h"
+#include "e_ichicomp.h"
+
+#define extract_ChargeRadical  e_extract_ChargeRadical
+#define normalize_name         e_normalize_name
+/******************************************************************************************************/
+int extract_ChargeRadical( char *elname, int *pnRadical, int *pnCharge )
+{
+    char *q, *r, *p;
+    int  nCharge=0, nRad = 0, charge_len = 0, k, nVal, nSign, nLastSign=1, len;
+
+    p = elname;
+
+    /*  extract radicals & charges */
+    while ( q = strpbrk( p, "+-^" ) ) {
+        switch ( *q ) {
+        case '+':
+        case '-':
+            for ( k = 0, nVal=0; (nSign = ('+' == q[k])) || (nSign = -('-' == q[k])); k++ ) {
+                nVal += (nLastSign = nSign);
+                charge_len ++;
+            }
+            if ( nSign = (int)strtol( q+k, &r, 10 ) ) { /*  fixed 12-5-2001 */
+                nVal += nLastSign * (nSign-1);
+            }
+            charge_len = r - q;
+            nCharge += nVal;
+            break;
+        /* case '.': */ /*  singlet '.' may be confused with '.' in formulas like CaO.H2O */
+        case '^':
+            nRad = 1; /* doublet here is 1. See below */
+            charge_len = 1;
+            for ( k = 1; q[0] == q[k]; k++ ) {
+                nRad ++;
+                charge_len ++;
+            }
+            break;
+        }
+        memmove( q, q+charge_len, strlen(q+charge_len)+1 );
+    }
+    len = strlen(p);
+    /*  radical */
+    if ( (q = strrchr( p, ':' )) && !q[1]) {
+        nRad = RADICAL_SINGLET;
+        q[0] = '\0';
+        len --;
+    } else {
+        while( (q = strrchr( p, '.' )) && !q[1] ) {
+            nRad ++;
+            q[0] = '\0';
+            len --;
+        }
+
+        nRad = nRad == 1? RADICAL_DOUBLET :
+               nRad == 2? RADICAL_TRIPLET : 0;
+    }
+    *pnRadical = nRad;
+    *pnCharge  = nCharge;
+    return ( nRad || nCharge );
+
+}
+/*****************************************************************/
+int normalize_name( char* name )
+{
+    /* remove leading & trailing spaces; replace consecutive spaces with a single space */
+    /* Treat non-printable characters (Greeks) as spaces. 11-23-99 DCh. */
+    int i, len, n;
+    len = (int)strlen(name);
+    for ( i = 0, n = 0; i < len; i++ ) {
+        if ( isspace( UCINT name[i] ) /*|| !isprint( UCINT name[i] )*/ ) {
+            name[i] = ' '; /* exterminate tabs !!! */
+            n++;
+        } else {
+            if ( n > 0 ) {
+                memmove( (void*) &name[i-n], (void*) &name[i], len-i+1 );
+                i   -= n;
+                len -= n;
+            }
+            n = -1;
+        }
+    }
+    if ( n == len ) /* empty line */
+        name[len=0] = '\0';
+    else
+    if ( ++n && n <= len ) {
+        len -= n;
+        name[len] = '\0';
+    }
+    return len;
+}
+/************************************************/
+#ifndef e_inchi_malloc
+void *e_inchi_malloc(size_t c)
+{
+    return  malloc(c);
+}
+#endif
+#ifndef e_inchi_calloc
+void *e_inchi_calloc(size_t c, size_t n)
+{
+    return calloc(c,n);
+}
+#endif
+#ifndef e_inchi_free
+void e_inchi_free(void *p)
+{
+    if(p) {
+        free(p); /*added check if zero*/
+    }
+}
+#endif
+
+
+/***************************************************************************/
+/* Copies up to maxlen characters INCLUDING end null from source to target */
+/* Fills out the rest of the target with null bytes */
+int e_mystrncpy(char *target,const char *source,unsigned maxlen)
+{   /*  protected from non-zero-terminated source and overlapped target/source. 7-9-99 DCh. */
+    const char  *p;
+    unsigned    len;
+
+    if (target==NULL || maxlen == 0 || source == NULL)
+        return 0;
+    if ( p = (const char*)memchr(source, 0, maxlen) ) {
+        len = p-source; /*  maxlen does not include the found zero termination */
+    } else {
+        len = maxlen-1; /*  reduced length does not include one more byte for zero termination */
+    }
+    if ( len )
+        memmove( target, source, len );
+    /* target[len] = '\0'; */
+    memset( target+len, 0, maxlen-len); /*  zero termination */
+    return 1;
+}
+/************************************************************************/
+/* Remove leading and trailing white spaces                             */
+char* e_LtrimRtrim( char *p, int* nLen )
+{
+    int i, len=0;
+    if ( p &&  (len = strlen( p )) ) {
+        for ( i = 0; i < len && __isascii( p[i] ) && isspace( p[i] ); i++ )
+            ;
+        if ( i )
+            (memmove)( p, p+i, (len -= i)+1 );
+        for ( ; 0 < len && __isascii( p[len-1] ) && isspace( p[len-1] ); len-- )
+            ;
+        p[len] = '\0';
+    }
+    if ( nLen )
+        *nLen = len;
+    return p;
+}
+
+/*************************************************************************/
+void e_remove_trailing_spaces( char* p )
+{
+    int   len;
+    for( len = (int)strlen( p ) - 1; len >= 0 && isspace( UCINT p[len] ); len-- )
+        ;
+    p[++len] = '\0';
+}
+/*************************************************************************/
+void e_remove_one_lf( char* p)
+{
+    size_t len;
+    if ( p && 0 < (len = strlen(p)) && p[len-1] == '\n' ){
+        p[len-1] = '\0';
+        if ( len >= 2 && p[len-2] == '\r' )
+            p[len-2] = '\0';
+    }
+}
+/*************************************************************************/
+S_SHORT *e_is_in_the_slist( S_SHORT *pathAtom, S_SHORT nNextAtom, int nPathLen )
+{
+    for ( ; nPathLen && *pathAtom != nNextAtom; nPathLen--,  pathAtom++ )
+        ;
+    return nPathLen? pathAtom : NULL;
+}
+/************************************************/
+int e_is_element_a_metal( char szEl[] )
+{
+    static char szMetals[] = "K;V;Y;W;U;"
+        "Li;Be;Na;Mg;Al;Ca;Sc;Ti;Cr;Mn;Fe;Co;Ni;Cu;Zn;Ga;Rb;Sr;Zr;"
+        "Nb;Mo;Tc;Ru;Rh;Pd;Ag;Cd;In;Sn;Sb;Cs;Ba;La;Ce;Pr;Nd;Pm;Sm;"
+        "Eu;Gd;Tb;Dy;Ho;Er;Tm;Yb;Lu;Hf;Ta;Re;Os;Ir;Pt;Au;Hg;Tl;Pb;"
+        "Bi;Po;Fr;Ra;Ac;Th;Pa;Np;Pu;Am;Cm;Bk;Cf;Es;Fm;Md;No;Lr;Rf;";
+    int len = strlen(szEl);
+    char *p;
+
+    if ( 0 < len && len <= 2 &&
+         isalpha( UCINT szEl[0] ) && isupper( szEl[0] ) &&
+         (p = strstr(szMetals, szEl) ) && p[len] == ';' ) {
+
+            return 1; /*return AtType_Metal;*/
+    }
+    return 0;
+}
+
+#ifdef INCHI_ANSI_ONLY
+/*************************************************************************/
+/*************          non-ANSI functions                ****************/
+/*************************************************************************/
+#define __MYTOLOWER(c) ( ((c) >= 'A') && ((c) <= 'Z') ? ((c) - 'A' + 'a') : (c) )
+
+#if ( !defined(_MSC_VER) || defined(__STDC__) && __STDC__ == 1 )
+/* support (VC++ Language extensions) = OFF && defined(INCHI_ANSI_ONLY) */
+#ifdef INCHI_LINK_AS_DLL
+/* the following code is enabled if linked as dll (ANSI C)                      */
+/* because the InChI library dll does not export it                             */
+int memicmp ( const void * p1, const void * p2, size_t length )
+{
+    const U_CHAR *s1 = (const U_CHAR*)p1;
+    const U_CHAR *s2  = (const U_CHAR*)p2;
+    while ( length-- ) {
+        if ( *s1 == *s2 ||
+              __MYTOLOWER( (int)*s1 ) == __MYTOLOWER( (int)*s2 )) {
+            s1 ++;
+            s2  ++;
+        } else {
+            return __MYTOLOWER( (int)*s1 ) - __MYTOLOWER( (int)*s2 );
+        }
+    }
+    return 0;
+}
+/*************************************************************************/
+int stricmp( const char *s1, const char *s2 )
+{
+    while ( *s1 ) {
+        if ( *s1 == *s2 ||
+              __MYTOLOWER( (int)*s1 ) == __MYTOLOWER( (int)*s2 )) {
+            s1 ++;
+            s2 ++;
+        } else {
+            return __MYTOLOWER( (int)*s1 ) - __MYTOLOWER( (int)*s2 );
+        }
+    }
+    if ( *s2 )
+        return -1;
+    return 0;
+}
+/*************************************************************************/
+char *_strnset( char *s, int val, size_t length )
+{
+    char *ps = s;
+    while (length-- && *ps)
+        *ps++ = (char)val;
+    return s;
+}
+/*************************************************************************/
+char *_strdup( const char *string )
+{
+    char *p = NULL;
+    if ( string ) {
+        size_t length = strlen( string );
+        p = e_inchi_malloc( length + 1 );
+        if ( p ) {
+            strcpy( p, string );
+        }
+    }
+    return p;
+}
+#endif /* INCHI_LINK_AS_DLL */
+#endif /* !defined(_MSC_VER) || defined(__STDC__) && __STDC__ == 1 */
+#endif /* INCHI_ANSI_ONLY */
+

data/ext/src/e_util.h

@@ -0,0 +1,61 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+#ifndef __UTIL_H__
+#define __UTIL_H__
+
+/* BILLY 8/6/04 */
+#ifndef INCHI_ALL_CPP
+#ifdef __cplusplus
+extern "C" {
+#endif
+#endif
+
+int   e_extract_ChargeRadical( char *elname, int *pnRadical, int *pnCharge );
+int   e_normalize_name( char* name );
+
+int   e_mystrncpy(char *target,const char *source,unsigned maxlen);
+char *e_LtrimRtrim( char *p, int* nLen );
+void  e_remove_trailing_spaces( char* p );
+void  e_remove_one_lf( char* p);
+int   e_is_element_a_metal( char szEl[] );
+
+AT_NUMB *e_is_in_the_list( AT_NUMB *pathAtom, AT_NUMB nNextAtom, int nPathLen );
+S_SHORT *e_is_in_the_slist( S_SHORT *pathAtom, S_SHORT nNextAtom, int nPathLen );
+void     e_SplitTime( unsigned long ulTotalTime, int *hours, int *minutes, int *seconds, int *mseconds );
+
+/* allocator */
+#ifndef e_inchi_malloc
+void *e_inchi_malloc(size_t c);
+#endif
+#ifndef e_inchi_calloc
+void *e_inchi_calloc(size_t c, size_t n);
+#endif
+#ifndef e_inchi_free
+void e_inchi_free(void *p);
+#endif
+
+
+extern char e_gsMissing[];
+extern char e_gsEmpty[];
+extern char e_gsSpace[];
+extern char e_gsEqual[];
+/* format string for SDF_LBL_VAL(L,V): %s%s%s%s (four strings) */
+#define SDF_LBL_VAL(L,V)  ((L)&&(L)[0])?e_gsSpace:e_gsEmpty, ((L)&&(L)[0])?L:e_gsEmpty, ((L)&&(L)[0])? (((V)&&(V)[0])?e_gsEqual:e_gsSpace):e_gsEmpty, ((V)&&(V)[0])?V:((L)&&(L)[0])?e_gsMissing:e_gsEmpty
+
+
+/* BILLY 8/6/04 */
+#ifndef INCHI_ALL_CPP
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif /* __UTIL_H__*/
+

data/ext/src/extr_ct.h

@@ -0,0 +1,251 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+#ifndef __EXTR_CT_H__
+#define __EXTR_CT_H__
+
+#include "mode.h"
+#include "ichisize.h"
+
+struct AtData {
+     char element[3];
+     int maxvalence;
+};
+
+ 
+
+#define NUM_CHEM_ELEMENTS 127   /* well above number of known chem. elements */
+
+
+#define               AT_ISO_SORT_KEY_MULT  32  /* up to 32 identical hydrogen isotopes */
+                                                /* (similar to T_GROUP_ISOWT_MULT) */
+                                                /* changed from 16 9-12-2003 */
+typedef long          AT_ISO_SORT_KEY;          /* signed, should hold up to 4096*max_iso_diff */
+                                                /* (similar to T_GROUP_ISOWT) */
+/*
+   = num_1H + AT_ISO_SORT_KEY_MULT*(num_D + AT_ISO_SORT_KEY_MULT*(num_T+AT_ISO_SORT_KEY_MULT*iso_atw_diff))
+*/
+
+/* typedef signed   char AT_ISOTOPIC; */ /* + or - */
+typedef struct tagStereoCarb {
+    AT_NUMB        at_num;
+    U_CHAR         parity;
+} AT_STEREO_CARB;
+typedef struct tagStereoDble {
+    AT_NUMB        at_num1;
+    AT_NUMB        at_num2;
+    U_CHAR         parity;
+} AT_STEREO_DBLE;
+
+typedef struct tagIsotopicAtom {
+    AT_NUMB        at_num;
+    NUM_H          num_1H;
+    NUM_H          num_D;
+    NUM_H          num_T;
+    NUM_H          iso_atw_diff;
+} AT_ISOTOPIC;
+
+typedef AT_NUMB AT_STEREO;
+
+#define BYTE_BITS         8       /* number of bits in one byte */
+
+#define BOND_MASK         0xf     /* 4 bits */
+#define BOND_BITS         4       /* 3 or 4 does not matter; 2 is too small for BOND_TAUTOM */
+#define BOND_ADD          (BOND_BITS==2?-1:0) /* subtract 1 from bonds stored in CT */
+
+
+typedef struct tagAtom {
+    char elname[ATOM_EL_LEN];
+    AT_NUMB    neighbor[MAXVAL]; /* changed to unsigned 2-2-95. D.Ch. */
+    AT_NUMB    init_rank;        /* also used in remove_terminal_HDT() to save orig. at. number */
+    AT_NUMB    orig_at_number;
+    AT_NUMB    orig_compt_at_numb;
+    /* low 3 bits=bond type;
+       high 5 bits (in case of cut-vertex atom) = an attached part number
+    */
+    U_CHAR bond_type[MAXVAL];
+    U_CHAR el_number;  /* periodic table number = charge of the nucleus = number of the protons */
+    /* U_CHAR hill_type; */  /* number in psudo hill order */
+    S_CHAR valence;
+    S_CHAR chem_bonds_valence; /* 8-24-00 to treat tautomer centerpoints, etc. */
+    S_CHAR num_H;              /* first not including D, T; add_DT_to_num_H() includes. */
+    S_CHAR num_iso_H[NUM_H_ISOTOPES];   /* num 1H, 2H(D), 3H(T) */
+    S_CHAR cFlags;
+    S_CHAR iso_atw_diff;        /* abs(iso_atw_diff) < 127 or 31 - ??? */
+    AT_ISO_SORT_KEY iso_sort_key;  /* = num_1H + AT_ISO_SORT_KEY_MULT^1*num_D
+                                               + AT_ISO_SORT_KEY_MULT^2*num_T
+                                               + AT_ISO_SORT_KEY_MULT^3*iso_atw_diff
+                                    */
+    S_CHAR charge;
+    S_CHAR radical; /* 1=>doublet(.), 2=> triplet as singlet (:) ???? why are they same ???? */
+    S_CHAR marked;
+    
+    AT_NUMB endpoint;  /* tautomer analysis. If != 0 then the hydrogens & (-)charge are in the tautomer group. */
+
+    /*
+       Pairs stereo_bond_neighbor[] and stereo_bond_neighbor2[], etc
+       initially refer to non-isotopic and isotopic cases, respectively.
+       To use same stereo processing code these arrays are swapped when
+       switching from non-isotopic to isotopic processing and back.
+    */
+    AT_NUMB stereo_bond_neighbor[MAX_NUM_STEREO_BONDS];  /* Original number of an opposite atom */
+    AT_NUMB stereo_bond_neighbor2[MAX_NUM_STEREO_BONDS]; /*     (stereo bond neighbor) +1; */
+    S_CHAR  stereo_bond_ord[MAX_NUM_STEREO_BONDS];    /* Ordering number of a bond/neighbor in the direction to the */
+    S_CHAR  stereo_bond_ord2[MAX_NUM_STEREO_BONDS];   /* stereo bond opposite atom (important for cumulenes); */
+    S_CHAR  stereo_bond_z_prod[MAX_NUM_STEREO_BONDS];  /* Relative  atom-neighbors */
+    S_CHAR  stereo_bond_z_prod2[MAX_NUM_STEREO_BONDS]; /* double bond planes orientation; */
+    S_CHAR  stereo_bond_parity[MAX_NUM_STEREO_BONDS];  /* parity + MULT_STEREOBOND*chain_length, */
+    S_CHAR  stereo_bond_parity2[MAX_NUM_STEREO_BONDS]; /* where: */
+              /*
+                 parity (Mask 0x07=BITS_PARITY):
+                
+                 0   = AB_PARITY_NONE = not a stereo bond
+                 1/2 = AB_PARITY_ODD/EVEN = bond parity defined from initial ranks
+                 3   = AB_PARITY_UNKN = geometry is unknown to the user
+                 4   = AB_PARITY_UNDF = not enough geometry info to find the parity
+                 6   = AB_PARITY_CALC = calculate later from the neighbor ranks; some ot them can be
+                       replaced with AB_PARITY_ODD/EVEN after equivalence ranks have been determined
+                
+                 length (Mask 0x38=MASK_CUMULENE_LEN, length=stereo_bond_parity[i]/MULT_STEREOBOND):
+                
+                 0   => double or alternating stereogenic bond
+                 1   => cumulene with 2 double bonds (stereogenic center)
+                 2   => cumulene with 3 double bonds (stereogenic bond)
+                 length <= (MAX_CUMULENE_LEN=2)
+                 bit KNOWN_PARITIES_EQL =  0x40: all pairs of const. equ. atoms are connected by stereo bonds
+                                                and these bonds have identical parities
+              */
+
+    S_CHAR parity; /* -- Mask 0x07=BITS_PARITY: --
+                   0 = AB_PARITY_NONE => no parity; also parity&0x38 = 0
+                   1 = AB_PARITY_ODD  => odd parity
+                   2 = AB_PARITY_EVEN => even parity
+                   3 = AB_PARITY_UNKN => user marked as unknown parity
+                   4 = AB_PARITY_UNDF => parity cannot be defined because of symmetry or not well defined geometry
+                  */
+    S_CHAR parity2;        /* parity including parity due to isotopic terminal H */
+    /* bit msks: 0x07 => known parity (1,2,3,4) or AB_PARITY_CALC=6, AB_PARITY_IISO = 6 */
+    /*           0x40 => KNOWN_PARITIES_EQL */
+    S_CHAR stereo_atom_parity; /* similar to stereo_bond_parity[]: known in advance AB_PARITY_* value + KNOWN_PARITIES_EQL bit */
+    S_CHAR stereo_atom_parity2;
+    S_CHAR final_parity;   /* defined by equivalence ranks */
+    S_CHAR final_parity2;  /* defined by equivalence ranks, incl. due to terminal isotopic H */
+    S_CHAR bAmbiguousStereo;
+    S_CHAR bHasStereoOrEquToStereo;
+    S_CHAR bHasStereoOrEquToStereo2;
+#if( FIND_RING_SYSTEMS == 1 )
+    S_CHAR    bCutVertex;
+    AT_NUMB   nRingSystem;
+    AT_NUMB   nNumAtInRingSystem;
+    AT_NUMB   nBlockSystem;
+#if( FIND_RINS_SYSTEMS_DISTANCES == 1 )
+    AT_NUMB   nDistanceFromTerminal;
+#endif
+#endif
+    S_CHAR z_dir[3];
+
+} sp_ATOM ;
+
+#define BOND_SINGLE BOND_TYPE_SINGLE  /* 1 */
+#define BOND_DOUBLE BOND_TYPE_DOUBLE  /* 2 */
+#define BOND_TRIPLE BOND_TYPE_TRIPLE  /* 3 */
+#define BOND_ALTERN BOND_TYPE_ALTERN  /* 4 single/double */
+
+#define BOND_ALT_123             5  /* single/double/triple */
+#define BOND_ALT_13              6  /* single/triple */
+#define BOND_ALT_23              7  /* double/triple */
+#define BOND_TAUTOM              8
+#define BOND_ALT12NS             9
+#define BOND_NUMDIF              9  /* number of different kinds of bonds */
+
+#define BOND_TYPE_MASK        0x0f
+
+#define BOND_MARK_ALL         0xf0  /* complement to BOND_TYPE_MASK */
+
+#define BOND_MARK_ALT12       0x10
+#define BOND_MARK_ALT123      0x20
+#define BOND_MARK_ALT13       0x30
+#define BOND_MARK_ALT23       0x40
+#define BOND_MARK_ALT12NS     0x50  /* 1 or 2, non-stereo */
+#define BOND_MARK_MASK        0x70
+
+
+#define BITS_PARITY        0x07  /* mask to retrieve half-bond parity */
+#define MASK_CUMULENE_LEN  0x38  /* mask to retrieve (cumulene chain length - 1)*MULT_STEREOBOND */
+#define KNOWN_PARITIES_EQL 0x40  /* parity is same for all pairs of constit. equivalent atoms */
+#define MAX_CUMULENE_LEN   2     /* max number of bonds in a cumulene chain - 1 */
+
+#define MULT_STEREOBOND    0x08  /* multiplier for cumulene chain length
+                                    odd length => chiral, even length => stereogenic bond */
+
+#define MAKE_BITS_CUMULENE_LEN(X)   ((X)*MULT_STEREOBOND)
+#define GET_BITS_CUMULENE_LEN(X)    ((X)&MASK_CUMULENE_LEN)
+#define BOND_CHAIN_LEN(X)           (GET_BITS_CUMULENE_LEN(X)/MULT_STEREOBOND) /* 0 => double bond, 1 => allene, 2 => cumulene,..*/
+#define IS_ALLENE_CHAIN(X)          ((GET_BITS_CUMULENE_LEN(X)/MULT_STEREOBOND)%2)
+
+/* atom or bond parity value definitions */
+#define AB_PARITY_NONE   0  /* 0 => no parity; also parity&0x38 = 0 */
+#define AB_PARITY_ODD    1  /* 1 => odd parity */
+#define AB_PARITY_EVEN   2  /* 2 => even parity */
+#define AB_PARITY_UNKN   3  /* 3 => user marked as unknown parity */
+#define AB_PARITY_UNDF   4  /* 4 => parity cannot be defined because of symmetry or not well defined geometry */
+#define AB_PARITY_IISO   5  /* 5 => no parity because of identical atoms */
+#define AB_PARITY_CALC   6  /* 6 => calculate parity later */
+#define AB_PARITY_0D     8  /* 8 => bit signifies 0D case -- not used */
+
+#define AB_INV_PARITY_BITS (AB_PARITY_ODD ^ AB_PARITY_EVEN)
+
+
+#define AB_MAX_KNOWN_PARITY        4 /* precalculated from const. equivalence parities */
+#define AB_MIN_KNOWN_PARITY        1
+
+#define AB_MAX_PART_DEFINED_PARITY 3 /* 1, 2, 3 => defined parities, uncluding 'unknown' */
+#define AB_MIN_PART_DEFINED_PARITY 1 /* min(AB_PARITY_ODD, AB_PARITY_EVEN, AB_PARITY_UNKN) */
+
+#define AB_MAX_WELL_DEFINED_PARITY 2 /* 1, 2 => well defined parities, uncluding 'unknown' */
+#define AB_MIN_WELL_DEFINED_PARITY 1 /* min(AB_PARITY_ODD, AB_PARITY_EVEN) */
+
+#define AB_MIN_ILL_DEFINED_PARITY  3
+#define AB_MAX_ILL_DEFINED_PARITY  4
+
+#define AB_MAX_ANY_PARITY          4
+#define AB_MIN_ANY_PARITY          1
+
+#define AMBIGUOUS_STEREO           1
+#define AMBIGUOUS_STEREO_ATOM      2
+#define AMBIGUOUS_STEREO_BOND      4
+#define AMBIGUOUS_STEREO_ATOM_ISO  8
+#define AMBIGUOUS_STEREO_BOND_ISO  16
+#define AMBIGUOUS_STEREO_ERROR     32
+
+
+#define MIN_DOT_PROD 50          /* min value of at->stereo_bond_z_prod[i] to define parity */
+
+#define ATOM_PARITY_VAL(X)          (X)
+#define ATOM_PARITY_PART_DEF(X)     (AB_MIN_PART_DEFINED_PARITY <= (X) && (X) <= AB_MAX_PART_DEFINED_PARITY)
+#define ATOM_PARITY_ILL_DEF(X)      (AB_MIN_ILL_DEFINED_PARITY <= (X) && (X) <= AB_MAX_ILL_DEFINED_PARITY)
+#define ATOM_PARITY_KNOWN(X)        (AB_MIN_KNOWN_PARITY <= (X) && (X) <= AB_MAX_KNOWN_PARITY)
+#define ATOM_PARITY_WELL_DEF(X)     (AB_MIN_WELL_DEFINED_PARITY <= (X) && (X) <= AB_MAX_WELL_DEFINED_PARITY)
+#define ATOM_PARITY_NOT_UNKN(X)     (ATOM_PARITY_KNOWN(X) && (X) != AB_PARITY_UNKN)
+
+#define PARITY_VAL(X)               ((X) & BITS_PARITY)
+#define PARITY_PART_DEF(X)          (AB_MIN_PART_DEFINED_PARITY <= PARITY_VAL(X) && PARITY_VAL(X) <= AB_MAX_PART_DEFINED_PARITY)
+#define PARITY_ILL_DEF(X)           (AB_MIN_ILL_DEFINED_PARITY <= PARITY_VAL(X) && PARITY_VAL(X) <= AB_MAX_ILL_DEFINED_PARITY)
+#define PARITY_KNOWN(X)             (AB_MIN_KNOWN_PARITY <= PARITY_VAL(X) && PARITY_VAL(X) <= AB_MAX_KNOWN_PARITY)
+#define PARITY_WELL_DEF(X)          (AB_MIN_WELL_DEFINED_PARITY <= PARITY_VAL(X) && PARITY_VAL(X) <= AB_MAX_WELL_DEFINED_PARITY)
+#define PARITY_CALCULATE(X)         (AB_PARITY_CALC == PARITY_VAL(X))
+#define BOND_PARITY_PART_DEFINED(X) (PARITY_PART_DEF(X) || PARITY_CALCULATE(X))
+#define BOND_PARITY_PART_KNOWN(X)   (PARITY_KNOWN(X) || PARITY_CALCULATE(X))
+#define ALL_BUT_PARITY(X)           ((X)&~BITS_PARITY)
+
+#define ALWAYS_SET_STEREO_PARITY           0
+#define NO_ISOLATED_NON_6RING_AROM_BOND    0  /* for Yuri */
+#define SAVE_6_AROM_CENTERS                0  /* for Yuri */
+
+#endif /* __EXTR_CT_H__ */