rino 0.1.0

data/ext/src/ichicomp.h

@@ -0,0 +1,50 @@
+/*
+ * 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 __INCHI_COMPAT_H__
+#define __INCHI_COMPAT_H__
+
+/* compatibility */
+
+#if( defined(__GNUC__) && defined(__MINGW32__) && __GNUC__ == 3 && __GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ == 0 && defined(_WIN32) ) 
+/* replace with the proper definition for GNU gcc & MinGW-2.0.0-3 (mingw special 20020817-1), gcc 3.2 core */
+#define my_va_start(A,B) ((A)=(va_list)__builtin_next_arg(lpszFormat))
+#else
+#define my_va_start va_start
+#endif
+
+
+
+/*  ANSI redefinitions */
+#ifdef INCHI_ANSI_ONLY  /* { */
+#ifndef __isascii
+#define __isascii(val)  ((unsigned)(val) <= 0x7F)
+#endif
+
+/* #ifndef __GNUC__ */
+/* these non-ANSI functions are implemented in gcc */
+#include <stdio.h>
+ /* this #include provides size_t definition */
+ /* implementation is located in util.c */
+#if ( !defined(_MSC_VER) || defined(__STDC__) && __STDC__ == 1 )
+/* support (VC++ Language extensions) = OFF && defined(INCHI_ANSI_ONLY) */
+int   memicmp (const void*, const void*, size_t);
+int   stricmp( const char *s1, const char *s2 );
+char *_strnset( char *string, int c, size_t count );
+char *_strdup( const char *string );
+#endif
+/* #endif */
+
+#endif /* } */
+
+#define inchi_max(a,b)  (((a)>(b))?(a):(b))
+#define inchi_min(a,b)  (((a)<(b))?(a):(b))
+
+
+#endif /* __INCHI_COMPAT_H__ */

data/ext/src/ichidrp.h

@@ -0,0 +1,119 @@
+/*
+ * 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 __INCHIDRP_H__
+#define __INCHIDRP_H__
+
+#ifndef INCHI_ANSI_ONLY /* { */
+/********************************************
+ * Parameters for the structure drawing
+ ********************************************/
+#define TDP_LEN_LBL      16  /* length of a label (label: Req., Shown, Found) */
+/* #define TDP_NUM_LBL 3  */ /* number of labels */
+/* #define TDP_NUM_PAR 3  */ /* number of types per label (types: B/T, I/N, S) */
+typedef enum tagTblTypes {itBASIC, itISOTOPIC, itSTEREO, TDP_NUM_PAR} TBL_TYPES; /*  types */
+typedef enum tagTblLabels{ ilSHOWN,  TDP_NUM_LBL} TBL_LABELS; /*  labels */
+typedef struct tagTblDrawPatms {
+    char   ReqShownFoundTxt[TDP_NUM_LBL][TDP_LEN_LBL];
+    char   ReqShownFound[TDP_NUM_LBL][TDP_NUM_PAR];
+    int    nOrientation;  /* 10*degrees: 0 or 2700 */
+    int    bDrawTbl;
+} TBL_DRAW_PARMS;
+/*********************************************/
+typedef struct tagDrawParmsSettings {
+    TBL_DRAW_PARMS *tdp;
+    unsigned long  ulDisplTime;
+    int            bOrigAtom;
+    int            nFontSize;
+} SET_DRAW_PARMS;  /* input only: how to draw or calculate */
+/*********************************************/
+typedef struct tagReturnedDrawParms {
+    int       bEsc;
+} RET_DRAW_PARMS;
+/*********************************************/
+typedef struct tagPersistDrawParms {
+    int rcPict[4];
+} PER_DRAW_PARMS; /* saved between displaying different structures */
+/*********************************************/
+typedef struct tagDrawParms {
+    SET_DRAW_PARMS  sdp;   /* how to draw: fill on the 1st call */
+    RET_DRAW_PARMS  rdp;   /* returned when drawing window is closed */
+    PER_DRAW_PARMS *pdp;   /* persistent: save between calls (window size) */
+#ifndef INCHI_LIB
+#ifndef INCHI_ANSI_ONLY
+    AT_NUMB   *nEquLabels; /* num_inp_atoms elements, value>0 marks atoms in the set #value  */
+    AT_NUMB    nNumEquSets;  /* max mark value */
+    AT_NUMB    nCurEquLabel; /* current mark */
+#endif
+#endif
+} DRAW_PARMS; /* Settings: How to draw the structure */
+
+#endif /* } INCHI_ANSI_ONLY */
+
+#if( ACD_LABS_VERSION == 1 )
+#define MAX_NUM_PATHS 5
+#else
+#define MAX_NUM_PATHS 4
+#endif
+
+typedef enum tagInputType { INPUT_NONE=0, INPUT_MOLFILE=1, INPUT_SDFILE=2, INPUT_INCHI_XML=3, INPUT_INCHI_PLAIN=4, INPUT_CMLFILE=5, INPUT_MAX } INPUT_TYPE;
+typedef struct tagInputParms {
+    char            szSdfDataHeader[MAX_SDF_HEADER+1];
+    char           *pSdfLabel;
+    char           *pSdfValue;
+    long            lSdfId;
+    long            lMolfileNumber;
+#ifndef INCHI_ANSI_ONLY
+    DRAW_PARMS      dp;
+    PER_DRAW_PARMS  pdp;
+    TBL_DRAW_PARMS  tdp;
+#endif
+/*
+  -- Files --
+  ip->path[0] => Input
+  ip->path[1] => Output (INChI)
+  ip->path[2] => Log
+  ip->path[3] => Problem structures
+  ip->path[4] => Errors file (ACD(
+
+*/
+    const char     *path[MAX_NUM_PATHS];
+    int             num_paths;
+    int             first_struct_number;
+    int             last_struct_number;
+    INPUT_TYPE      nInputType;
+    INCHI_MODE      nMode;
+    int             bAbcNumbers;
+    /*int             bXml;*/
+    int             bINChIOutputOptions; /* !(ip->bINChIOutputOptions & INCHI_OUT_PLAIN_TEXT) */
+    int             bCtPredecessors;
+    int             bXmlStarted;
+    int             bDisplayEachComponentINChI;
+
+    long            msec_MaxTime;   /* was ulMaxTime; max time to run ProsessOneStructure */
+    long            msec_LeftTime;
+
+    long            ulDisplTime; /* not used: max structure or question display time */
+    int             bDisplay;
+    int             bMergeAllInputStructures;
+    int             bSaveWarningStructsAsProblem;
+    int             bSaveAllGoodStructsAsProblem;
+    int             bGetSdfileId;
+    int             bGetMolfileNumber;  /* read molfile number from the name line like "Structure #22" */
+    int             bCompareComponents; /* see flags CMP_COMPONENTS, etc. */
+    int             bDisplayCompositeResults;
+    int             bDoNotAddH;
+    int             bNoStructLabels;
+    int             bChiralFlag;
+    int             bAllowEmptyStructure;
+    INCHI_MODE      bTautFlags;
+    INCHI_MODE      bTautFlagsDone;
+} INPUT_PARMS;
+
+#endif /* __INCHIDRP_H__ */

data/ext/src/ichierr.h

@@ -0,0 +1,124 @@
+/*
+ * 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 __INCHIERR_H__
+#define __INCHIERR_H__
+
+#define _IS_OKAY    0
+#define _IS_WARNING 1
+#define _IS_ERROR   2    /* Microsoft defined its own IS_ERROR() macro */
+#define _IS_FATAL   3
+#define _IS_UNKNOWN 4    /* unknown error: used in INChI DLL only */
+#define _IS_EOF    -1    /* end of file */
+#define _IS_SKIP   -2
+
+#define CT_ERR_FIRST         (-30000)
+#define CT_OVERFLOW          (CT_ERR_FIRST- 0)  /*(-30000) */
+#define CT_LEN_MISMATCH      (CT_ERR_FIRST- 1)  /*(-30001) */
+#define CT_OUT_OF_RAM        (CT_ERR_FIRST- 2)  /*(-30002) */
+#define CT_RANKING_ERR       (CT_ERR_FIRST- 3)  /*(-30003) */
+#define CT_ISOCOUNT_ERR      (CT_ERR_FIRST- 4)  /*(-30004) */
+#define CT_TAUCOUNT_ERR      (CT_ERR_FIRST- 5)  /*(-30005) */
+#define CT_ISOTAUCOUNT_ERR   (CT_ERR_FIRST- 6)  /*(-30006) */
+#define CT_MAPCOUNT_ERR      (CT_ERR_FIRST- 7)  /*(-30007) */
+#define CT_TIMEOUT_ERR       (CT_ERR_FIRST- 8)  /*(-30008) */
+#define CT_ISO_H_ERR         (CT_ERR_FIRST- 9)  /*(-30009) */
+#define CT_STEREOCOUNT_ERR   (CT_ERR_FIRST-10)  /*(-30010) */
+#define CT_ATOMCOUNT_ERR     (CT_ERR_FIRST-11)  /*(-30011) */
+#define CT_STEREOBOND_ERROR  (CT_ERR_FIRST-12)  /*(-30012) */
+#define CT_USER_QUIT_ERR     (CT_ERR_FIRST-13)  /*(-30013) */
+#define CT_REMOVE_STEREO_ERR (CT_ERR_FIRST-14)  /*(-30014) */
+#define CT_CALC_STEREO_ERR   (CT_ERR_FIRST-15)  /*(-30015) */
+#define CT_CANON_ERR         (CT_ERR_FIRST-16)  /*(-30016) */
+#define CT_STEREO_CANON_ERR  (CT_ERR_FIRST-17)  /*(-30017) */
+#define CT_UNKNOWN_ERR       (CT_ERR_FIRST-18)  /*(-30018) */
+
+#define CT_ERR_MIN CT_UNKNOWN_ERR
+#define CT_ERR_MAX CT_ERR_FIRST
+
+#define CHECK_OVERFLOW(Len, Maxlen) ( (Len) >= (Maxlen) )
+#define RETURNED_ERROR(nVal) (CT_ERR_MIN<=(nVal) && (nVal)<=CT_ERR_MAX)
+
+
+#define BNS_ERR            -9999
+#define BNS_WRONG_PARMS    (BNS_ERR +  0) /*(-9999)*/
+#define BNS_OUT_OF_RAM     (BNS_ERR +  1) /*(-9998)*/
+#define BNS_PROGRAM_ERR    (BNS_ERR +  2) /*(-9997)*/
+#define BNS_ALTPATH_OVFL   (BNS_ERR +  3) /*(-9996)*/
+#define BNS_BOND_ERR       (BNS_ERR +  4) /*(-9995)*/
+#define BNS_VERT_NUM_ERR   (BNS_ERR +  5) /*(-9994)*/
+#define BNS_VERT_EDGE_OVFL (BNS_ERR +  6) /*(-9993)*/
+#define BNS_SET_ALTP_ERR   (BNS_ERR +  7) /*(-9992)*/
+#define BNS_CPOINT_ERR     (BNS_ERR +  8) /*(-9991)*/
+#define BNS_CANT_SET_BOND  (BNS_ERR +  9) /*(-9990)*/
+#define BNS_CAP_FLOW_ERR   (BNS_ERR + 10) /*(-9989)*/
+#define BNS_RADICAL_ERR    (BNS_ERR + 11) /*(-9988)*/
+#define BNS_REINIT_ERR     (BNS_ERR + 12) /*(-9987)*/
+
+#define BNS_MAX_ERR_VALUE  (BNS_ERR + 19) /*(-9980)*/
+
+#define IS_BNS_ERROR(X) (BNS_ERR <= (X) && (X) <= BNS_MAX_ERR_VALUE)
+
+
+#define INCHI_INP_ERROR_ERR   40
+#define INCHI_INP_ERROR_RET  (-1)
+
+#define INCHI_INP_FATAL_ERR    1
+#define INCHI_INP_FATAL_RET    0
+
+#define INCHI_INP_EOF_ERR     11
+#define INCHI_INP_EOF_RET      0
+
+#ifndef INCHI_ALL_CPP
+#ifdef  __cplusplus
+extern "C" {
+#endif
+#endif
+
+extern int (*UserAction)(void); /* callback */
+extern int (*ConsoleQuit)(void); /* Console user issued CTRL+C etc. */
+
+#ifndef INCHI_ALL_CPP
+#ifdef  __cplusplus
+}
+#endif
+#endif
+
+#define LOG_MASK_WARN  1
+#define LOG_MASK_ERR   2
+#define LOG_MASK_FATAL 4
+
+#define LOG_MASK_ALL     (LOG_MASK_WARN | LOG_MASK_ERR | LOG_MASK_FATAL)
+#define LOG_MASK_NO_WARN (LOG_MASK_ERR | LOG_MASK_FATAL)
+
+#ifdef INCHI_LIB
+#include <stdarg.h>
+
+#ifndef INCHI_ALL_CPP
+#ifdef  __cplusplus
+extern "C" {
+#endif
+#endif
+
+extern void (*FWPRINT) (const char * format, va_list argptr );
+extern void (*DRAWDATA) ( struct DrawData * pDrawData);
+extern int  (*DRAWDATA_EXISTS) ( int nComponent, int nType, int bReconnected );
+extern struct DrawData * (*GET_DRAWDATA) ( int nComponent, int nType, int bReconnected );
+
+#ifndef INCHI_ALL_CPP
+#ifdef  __cplusplus
+}
+#endif
+#endif
+
+#endif
+
+#define USER_ACTION_QUIT   1
+
+#endif /* __INCHIERR_H__ */

data/ext/src/ichiisot.c

@@ -0,0 +1,101 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include "mode.h"
+
+#include "comdef.h"
+#include "extr_ct.h"
+#include "ichitaut.h"
+#include "ichicant.h"
+#include "ichicomn.h"
+
+#ifdef NEVER
+/**********************************************************************************/
+int unpack_iso_sort_key( AT_ISO_SORT_KEY iso_sort_key, S_CHAR *num_1H, S_CHAR *num_2H, S_CHAR *num_3H, S_CHAR *iso_atw_diff )
+{
+    int is_negative;
+    AT_ISO_SORT_KEY HOnlyAtwPart;
+    static const AT_ISO_SORT_KEY MultAtwDiff = AT_ISO_SORT_KEY_MULT*AT_ISO_SORT_KEY_MULT*AT_ISO_SORT_KEY_MULT;
+    if ( !iso_sort_key ) {
+        *num_1H = *num_2H = *num_3H = *iso_atw_diff = 0;
+        return 0;
+    } else
+    if ( iso_sort_key < 0 ) {
+        is_negative = 1;
+        iso_sort_key = -iso_sort_key;
+        HOnlyAtwPart = MultAtwDiff - iso_sort_key % MultAtwDiff;
+        iso_sort_key += HOnlyAtwPart;
+    } else {
+        is_negative = 0;
+        HOnlyAtwPart  = iso_sort_key % MultAtwDiff;
+        iso_sort_key -= HOnlyAtwPart;
+    }
+    
+    iso_sort_key /= MultAtwDiff;
+    
+    *num_1H = (S_CHAR)(HOnlyAtwPart % AT_ISO_SORT_KEY_MULT);
+    HOnlyAtwPart /= AT_ISO_SORT_KEY_MULT;
+    *num_2H = (S_CHAR)(HOnlyAtwPart % AT_ISO_SORT_KEY_MULT);
+    HOnlyAtwPart /= AT_ISO_SORT_KEY_MULT;
+    *num_3H = (S_CHAR)(HOnlyAtwPart % AT_ISO_SORT_KEY_MULT);
+    
+    *iso_atw_diff = (S_CHAR)(is_negative? -iso_sort_key : iso_sort_key);
+    
+    return 1;
+}
+#endif
+
+/**********************************************************************************/
+AT_ISO_SORT_KEY make_iso_sort_key( int iso_atw_diff, int num_1H, int num_2H, int num_3H)
+{
+    AT_ISO_SORT_KEY iso_sort_key = 0, mult=1;
+    
+    iso_sort_key += mult * num_1H;
+    mult *= AT_ISO_SORT_KEY_MULT;
+    iso_sort_key += mult * num_2H;
+    mult *= AT_ISO_SORT_KEY_MULT;
+    iso_sort_key += mult * num_3H;
+    mult *= AT_ISO_SORT_KEY_MULT;
+    iso_sort_key += mult * iso_atw_diff;
+    return iso_sort_key;
+}
+/**********************************************************************************/
+/*  set sp_ATOM isotopic sort keys */
+int set_atom_iso_sort_keys(  int num_at, sp_ATOM *at, T_GROUP_INFO* t_group_info, int *bHasIsotopicInTautomerGroups )
+{
+    int             i, num_isotopic = 0, bMergedTgroup;
+    AT_ISO_SORT_KEY iso_sort_key;
+    T_GROUP        *t_group =
+                       (t_group_info &&
+                        t_group_info->t_group &&
+                        t_group_info->num_t_groups > 0)? t_group_info->t_group : NULL;
+
+    if ( bHasIsotopicInTautomerGroups )
+        *bHasIsotopicInTautomerGroups = 0;
+    for ( i = 0; i < num_at; i ++ ) {
+        bMergedTgroup = (t_group_info && t_group_info->nIsotopicEndpointAtomNumber && (at[i].cFlags & AT_FLAG_ISO_H_POINT));
+        if ( (!at[i].endpoint || !t_group) && !bMergedTgroup ) {
+            iso_sort_key = make_iso_sort_key(at[i].iso_atw_diff, at[i].num_iso_H[0], at[i].num_iso_H[1], at[i].num_iso_H[2]);
+        } else {
+            /*  H isotopes go to the tautomer part of the CT (name) */
+            /*  if (at[i].endpoint && t_group) ... */
+            iso_sort_key = make_iso_sort_key(at[i].iso_atw_diff, 0, 0, 0);
+            if ( bHasIsotopicInTautomerGroups )
+                *bHasIsotopicInTautomerGroups += (at[i].num_iso_H[0] || at[i].num_iso_H[1] || at[i].num_iso_H[2] || bMergedTgroup);
+        }
+        at[i].iso_sort_key = iso_sort_key;
+        num_isotopic += (iso_sort_key != 0);
+    }
+    return num_isotopic;
+}
+

data/ext/src/ichilnct.c

@@ -0,0 +1,286 @@
+/*
+ * 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 <stdlib.h>
+#include <limits.h>
+#include <math.h>
+#include <float.h>
+#include <string.h>
+#include <ctype.h>
+
+/* for use in the InChI library */
+
+#include "mode.h"
+#include "inchi_api.h"
+#include "util.h"
+#include "ichierr.h"
+#include "ichicomp.h"
+
+#define my_fgetsTab       l_my_fgetsTab
+#define my_fgetsTab1      l_my_fgetsTab1
+#define my_fgets          l_my_fgets
+#define str_fgetc         l_str_fgetc
+#define str_fgets         l_str_fgets
+#define str_fgetsTab      l_str_fgetsTab
+
+#define INChIToInchi_Atom l_INChIToInchi_Atom
+
+int INChIToInchi_Input( INCHI_FILE *inp_molfile, inchi_Input *orig_at_data, int bMergeAllInputStructures,
+                       int bDoNotAddH, INPUT_TYPE nInputType,
+                       char *pSdfLabel, char *pSdfValue, long *lSdfId, INCHI_MODE *pInpAtomFlags,
+                       int *err, char *pStrErr );
+
+/* This contains executable code. Included in lReadAux.c, e_ReadINCH.c, ReadINCH.c,  */
+#include "aux2atom.h"
+
+extern int bLibInchiSemaphore;
+/*****************************************************************************************************/
+EXPIMP_TEMPLATE INCHI_API int INCHI_DECL Get_inchi_Input_FromAuxInfo(
+                        char *szInchiAuxInfo, int bDoNotAddH, InchiInpData *pInchiInp )
+{
+    INCHI_FILE inp;
+    int num_at, nRet = inchi_Ret_OKAY, err = 0;
+    INCHI_MODE bChiral = 0;
+    /* the input string may contain the following line: "Structure NNN. HHH=VVV" */
+    long         lNumber;                   /* structure number NNN from the input */
+    char         szHeader[MAX_SDF_HEADER];  /* stucture label header HHH from the input */
+    char         szLabel[MAX_SDF_VALUE];    /* stucture label VVV from the input */
+    if ( bLibInchiSemaphore ) {  /* does not work properly under sufficient stress */
+        return inchi_Ret_BUSY;
+    }
+    bLibInchiSemaphore = 1;
+
+    if ( pInchiInp && pInchiInp->pInp ) {
+        /* clear output fields */
+        inchi_Input *pInp      = pInchiInp->pInp;
+        char        *szOptions = pInp->szOptions;
+        memset( pInchiInp, 0, sizeof(*pInchiInp) );
+        memset( pInp,      0, sizeof(*pInp) );
+        pInp->szOptions = szOptions;
+        pInchiInp->pInp = pInp;
+    } else {
+        bLibInchiSemaphore = 0;
+        return inchi_Ret_ERROR;
+    }
+    szHeader[0]     = '\0';
+    szLabel[0]      = '\0';
+    lNumber         = 0;
+    /* prepare input string pointers */
+    inp.pStr             = szInchiAuxInfo;
+    inp.nUsedLength      = strlen(szInchiAuxInfo);
+    inp.nAllocatedLength = inp.nUsedLength+1;
+    inp.nPtr             = 0;
+
+    num_at = INChIToInchi_Input( &inp, pInchiInp->pInp, 1, bDoNotAddH, INPUT_INCHI_PLAIN,
+                       szHeader, szLabel, &lNumber, &bChiral,
+                       &err, pInchiInp->szErrMsg );
+    pInchiInp->bChiral = bChiral;
+    if ( num_at <= 0 ) {
+        if ( 10 < err && err < 20 ) {
+            nRet = inchi_Ret_EOF;
+        } else
+        if ( err == 9 ) {
+            nRet = inchi_Ret_ERROR; /*  sdfile bypassed to $$$$ */
+        } else
+        if ( err && err < 30 ) {
+            nRet = inchi_Ret_FATAL;
+        } else
+        if ( 98 == err ) {
+            nRet =  inchi_Ret_WARNING; /* empty AuxInfo */
+        } else
+        if ( err ) {
+            nRet =  inchi_Ret_ERROR;
+        } else
+        if ( pInchiInp->szErrMsg[0] ) {
+            nRet = inchi_Ret_WARNING;
+        }
+    }
+    if ( nRet != inchi_Ret_OKAY && nRet != inchi_Ret_WARNING ) {
+        Free_inchi_Input( pInchiInp->pInp );
+        pInchiInp->bChiral = 0;
+    }
+    bLibInchiSemaphore = 0;
+    return nRet;
+}
+/*****************************************************************************************************/
+EXPIMP_TEMPLATE INCHI_API void INCHI_DECL Free_inchi_Input( inchi_Input *pInp )
+{
+    FreeInchi_Atom( &pInp->atom );
+    FreeInchi_Stereo0D ( &pInp->stereo0D );
+    pInp->num_atoms = 0;
+    pInp->num_stereo0D = 0;
+}
+
+
+/*#endif*/ /* INCHI_MAIN */
+
+#ifndef INCHI_LIBRARY
+#error "INCHI_LIBRARY MUST be defined here"
+#endif
+
+
+/**********************************************************************************/
+int INChIToInchi_Input( INCHI_FILE *inp_molfile, inchi_Input *orig_at_data, int bMergeAllInputStructures,
+                       int bDoNotAddH, INPUT_TYPE nInputType,
+                       char *pSdfLabel, char *pSdfValue, long *lSdfId, INCHI_MODE *pInpAtomFlags,
+                       int *err, char *pStrErr )
+{
+    /* inp_ATOM       *at = NULL; */
+    int             num_dimensions_new;
+    int             num_inp_bonds_new;
+    int             num_inp_atoms_new;
+    int             num_inp_0D_new;
+    inchi_Atom     *at_new     = NULL;
+    inchi_Atom     *at_old     = NULL;
+    inchi_Stereo0D *stereo0D_new = NULL;
+    inchi_Stereo0D *stereo0D_old = NULL;
+    int             nNumAtoms  = 0, nNumStereo0D = 0;
+    MOL_COORD      *szCoordNew = NULL;
+    MOL_COORD      *szCoordOld = NULL;
+    int            i, j;
+
+    if ( pStrErr ) {
+        pStrErr[0] = '\0';
+    }
+
+    /*FreeOrigAtData( orig_at_data );*/
+    if ( lSdfId )
+        *lSdfId = 0;
+    do {
+        
+        at_old       = orig_at_data? orig_at_data->atom      : NULL; /*  save pointer to the previous allocation */
+        stereo0D_old = orig_at_data? orig_at_data->stereo0D  : NULL;
+        szCoordOld = NULL;
+        num_inp_atoms_new =
+            INChIToInchi_Atom( inp_molfile, orig_at_data? &stereo0D_new:NULL, &num_inp_0D_new,
+                          bDoNotAddH, nInputType, orig_at_data? &at_new:NULL, MAX_ATOMS,
+                          &num_dimensions_new, &num_inp_bonds_new,
+                          pSdfLabel, pSdfValue, lSdfId, pInpAtomFlags, err, pStrErr );
+        if ( num_inp_atoms_new <= 0 && !*err ) {
+            MOLFILE_ERR_SET (*err, 0, "Empty structure");
+            *err = 98;
+        } else
+        if ( orig_at_data && !num_inp_atoms_new && 10 < *err && *err < 20 && orig_at_data->num_atoms > 0 && bMergeAllInputStructures ) {
+            *err = 0; /* end of file */
+            break;
+        } else
+        if ( num_inp_atoms_new > 0 && orig_at_data ) {
+            /*  merge pOrigDataTmp + orig_at_data => pOrigDataTmp; */
+            nNumAtoms    = num_inp_atoms_new + orig_at_data->num_atoms;
+            nNumStereo0D = num_inp_0D_new    + orig_at_data->num_stereo0D;
+            if ( nNumAtoms >= MAX_ATOMS ) {
+                MOLFILE_ERR_SET (*err, 0, "Too many atoms");
+                *err = 70;
+                orig_at_data->num_atoms = -1;
+            } else
+            if ( !at_old ) {
+                /* the first structure */
+                orig_at_data->atom         = at_new;            at_new            = NULL;
+                orig_at_data->num_atoms    = num_inp_atoms_new; num_inp_atoms_new = 0;
+                orig_at_data->stereo0D     = stereo0D_new;      stereo0D_new      = NULL;
+                orig_at_data->num_stereo0D = num_inp_0D_new;    num_inp_0D_new    = 0;
+            } else
+            if ( orig_at_data->atom = CreateInchi_Atom( nNumAtoms ) ) {
+                /*  switch at_new <--> orig_at_data->at; */
+                if ( orig_at_data->num_atoms ) {
+                    memcpy( orig_at_data->atom, at_old, orig_at_data->num_atoms * sizeof(orig_at_data->atom[0]) );
+                    /*  adjust numbering in the newly read structure */
+                    for ( i = 0; i < num_inp_atoms_new; i ++ ) {
+                        for ( j = 0; j < at_new[i].num_bonds; j ++ ) {
+                            at_new[i].neighbor[j] += orig_at_data->num_atoms;
+                        }
+                    }
+                }
+                FreeInchi_Atom( &at_old );
+                /*  copy newly read structure */
+                memcpy( orig_at_data->atom + orig_at_data->num_atoms,
+                        at_new,
+                        num_inp_atoms_new * sizeof(orig_at_data->atom[0]) );
+                /*  copy newly read 0D stereo */
+                if ( num_inp_0D_new > 0 && stereo0D_new ) {
+                    if ( orig_at_data->stereo0D = CreateInchi_Stereo0D( nNumStereo0D ) ) {
+                        memcpy( orig_at_data->stereo0D, stereo0D_old, orig_at_data->num_stereo0D * sizeof(orig_at_data->stereo0D[0]) );
+                        /*  adjust numbering in the newly read structure */
+                        for ( i = 0; i < num_inp_0D_new; i ++ ) {
+                            if ( stereo0D_new[i].central_atom >= 0 ) {
+                                stereo0D_new[i].central_atom += orig_at_data->num_atoms;
+                            }
+                            for ( j = 0; j < 4; j ++ ) {
+                                stereo0D_new[i].neighbor[j] += orig_at_data->num_atoms;
+                            }
+                        }
+                        FreeInchi_Stereo0D( &stereo0D_old );
+                        memcpy( orig_at_data->stereo0D+orig_at_data->num_stereo0D,
+                                stereo0D_new,
+                                num_inp_0D_new * sizeof(orig_at_data->stereo0D[0]) );
+                    } else {
+                        num_inp_0D_new = 0;
+                        MOLFILE_ERR_SET (*err, 0, "Out of RAM");
+                        *err = -1;
+                    }
+                } else {
+                    num_inp_0D_new = 0;
+                }
+                /* update lengths */
+                orig_at_data->num_atoms    += num_inp_atoms_new;
+                orig_at_data->num_stereo0D += num_inp_0D_new;
+            } else {
+                MOLFILE_ERR_SET (*err, 0, "Out of RAM");
+                *err = -1;
+            }
+        } else
+        if ( num_inp_atoms_new > 0 ) {
+            nNumAtoms += num_inp_atoms_new;
+        }
+        FreeInchi_Atom( &at_new );
+        num_inp_atoms_new = 0;
+        FreeInchi_Stereo0D( &stereo0D_new );
+        num_inp_0D_new = 0;
+
+    } while ( !*err && bMergeAllInputStructures );
+    /*
+    if ( !*err ) {
+        orig_at_data->num_components =
+            MarkDisconnectedComponents( orig_at_data );
+        if ( orig_at_data->num_components == 0 ) {
+            MOLFILE_ERR_SET (*err, 0, "No components found");
+            *err = 99;
+        }
+        if ( orig_at_data->num_components < 0 ) {
+            MOLFILE_ERR_SET (*err, 0, "Too many components");
+            *err = 99;
+        }
+    }
+    */
+    if ( szCoordNew ) {
+        inchi_free( szCoordNew );
+    }
+    if ( at_new ) {
+        inchi_free( at_new );
+    }
+    /*
+    if ( !*err ) {
+        if ( ReconcileAllCmlBondParities( orig_at_data->atom, orig_at_data->num_atoms ) ) {
+            MOLFILE_ERR_SET (*err, 0, "Cannot reconcile stereobond parities");
+            if (!orig_at_data->num_atoms) {
+                *err = 1;
+            }
+        }
+    }
+    */
+    if ( *err ) {
+        FreeInchi_Input( orig_at_data );
+    }
+    if ( *err && !(10 < *err && *err < 20) && pStrErr && !pStrErr[0] ) {
+        MOLFILE_ERR_SET (*err, 0, "Unknown error");  /*   <BRKPT> */
+    }
+    return orig_at_data? orig_at_data->num_atoms : nNumAtoms;
+}
+