rino 0.1.0

data/ext/src/e_ichimain.c

@@ -0,0 +1,593 @@
+/*
+ * International Union of Pure and Applied Chemistry (IUPAC)
+ * International Chemical Identifier (InChI)
+ * Version 1
+ * Software version 1.00
+ * April 13, 2005
+ * Developed at NIST
+ */
+
+/*#define ADD_WIN_CTLC*/
+
+#if( defined( WIN32 ) && defined( _CONSOLE ) && defined(_MSC_VER) && _MSC_VER >= 800 && defined(ADD_WIN_CTLC) )
+#include <windows.h>
+#endif
+
+
+/* #define CREATE_0D_PARITIES */      /* uncomment to replace coordinates and 2D-parirties with 0D-parities */
+/* #define MAKE_INCHI_FROM_AUXINFO */ /* uncomment to create the second InChI out of AuxInfo and compare */
+#define NEIGH_ONLY_ONCE         /* comment out to include each bond in both neighboring atoms adjacency lists */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <limits.h>
+#include <float.h>
+
+#include "e_mode.h"
+#include "inchi_api.h"
+#include "e_inchi_atom.h"
+#include "e_ctl_data.h"
+#include "e_ichi_parms.h"
+#include "e_util.h"
+#include "e_ichi_io.h"
+#include "e_ichierr.h"
+#include "e_readstru.h"
+#include "e_ichicomp.h"
+#ifdef CREATE_0D_PARITIES
+#include "e_0dstereo.h"
+#endif
+
+int e_MakeOutputHeader( char *pSdfLabel, char *pSdfValue, long lSdfId, int num_inp, char *pStr1, char *pStr2 );
+char *e_GetChiralFlagString( int bChiralFlagOn );
+
+
+/*  console-specific */
+/*****************************************************************
+ *
+ *  Ctrl+C trap; works under Win32 + MS VC++
+ *
+ *****************************************************************/
+#ifndef INCHI_LIB
+
+int e_bInterrupted = 0;
+#if( defined( _WIN32 ) && defined( _CONSOLE ) )
+
+#if( defined(_MSC_VER) && _MSC_VER >= 800 && defined(ADD_WIN_CTLC) )
+BOOL WINAPI MyHandlerRoutine(
+  DWORD dwCtrlType   /*   control signal type */
+  ) {
+    if ( dwCtrlType == CTRL_C_EVENT     ||
+         dwCtrlType == CTRL_BREAK_EVENT ||
+         dwCtrlType == CTRL_CLOSE_EVENT ||
+         dwCtrlType == CTRL_LOGOFF_EVENT ) {
+        e_bInterrupted = 1;
+        return TRUE;
+    }
+    return FALSE;
+}
+#endif
+int WasInterrupted(void) {
+#ifdef _DEBUG            
+    if ( e_bInterrupted ) {
+        int stop=1;  /*  for debug only <BRKPT> */
+    }
+#endif
+    return e_bInterrupted;
+}
+
+#endif
+
+#define EXIT_ON_ERR
+#define REPEAT_ALL  0
+/********************************************************************/
+int main( int argc, char *argv[ ] )
+{
+
+    STRUCT_DATA struct_data;
+    STRUCT_DATA *sd = &struct_data;
+    FILE *inp_file = NULL, *output_file = NULL, *log_file = NULL, *prb_file = NULL;
+
+    long num_inp, num_err, num_output;
+    char        szSdfDataValue[MAX_SDF_VALUE+1];
+    const char *p1, *p2;
+
+    unsigned long  ulDisplTime = 0;    /*  infinite, milliseconds */
+    unsigned long  ulTotalProcessingTime = 0;
+    INPUT_PARMS inp_parms;
+    INPUT_PARMS *ip = &inp_parms;
+    char        szInchiCmdLine[512];
+
+    inchi_Input  inchi_inp, *pInp = &inchi_inp;
+    inchi_Output inchi_out, *pOut = &inchi_out;
+
+
+    int             bReleaseVersion = bRELEASE_VERSION;
+#define nStrLen 256
+    char  pStrInchiId[nStrLen], pStrLogId[nStrLen];
+    int   nRet = 0, nRet1, i, k, tot_len;
+    int   inp_index, out_index;
+    long  lSdfId;
+    int   nStructNo;
+
+#if ( defined(REPEAT_ALL) && REPEAT_ALL > 0 )
+    int  num_repeat = REPEAT_ALL;
+#endif
+
+
+#if( TRACE_MEMORY_LEAKS == 1 )
+    _CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
+/* for execution outside of the VC++ debugger uncomment one of the following two */
+/*#define MY_REPORT_FILE  _CRTDBG_FILE_STDERR */
+/*#define MY_REPORT_FILE  _CRTDBG_FILE_STDOUT */
+#ifdef MY_REPORT_FILE 
+   _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_WARN, MY_REPORT_FILE );
+   _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_ERROR, MY_REPORT_FILE );
+   _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
+   _CrtSetReportFile( _CRT_ASSERT, MY_REPORT_FILE );
+#else
+    _CrtSetReportMode(_CRT_WARN | _CRT_ERROR, _CRTDBG_MODE_DEBUG);
+#endif
+   /* turn on floating point exceptions */
+    {
+        /* Get the default control word. */
+        int cw = _controlfp( 0,0 );
+
+        /* Set the exception masks OFF, turn exceptions on. */
+        /*cw &=~(EM_OVERFLOW|EM_UNDERFLOW|EM_INEXACT|EM_ZERODIVIDE|EM_DENORMAL);*/
+        cw &=~(EM_OVERFLOW|EM_UNDERFLOW|EM_ZERODIVIDE|EM_DENORMAL);
+
+        /* Set the control word. */
+        _controlfp( cw, MCW_EM );
+ 
+    }
+#endif
+
+/*****************************************************************
+ *
+ *  Set Ctrl+C trap; works under Win32 + MS VC++
+ *
+ *****************************************************************/
+#if( defined( _WIN32 ) && defined( _CONSOLE ) && defined(_MSC_VER) && _MSC_VER >= 800 && defined(ADD_WIN_CTLC))
+    if ( SetConsoleCtrlHandler( MyHandlerRoutine, 1 ) ) {
+        /*ConsoleQuit = WasInterrupted*/;
+    }
+#endif
+
+
+
+#if ( defined(REPEAT_ALL) && REPEAT_ALL > 0 )
+repeat:
+    inp_file = output_file = log_file = prb_file = NULL;
+#endif
+
+    num_inp    = 0;
+    num_err    = 0;
+    num_output = 0;
+
+    if ( argc < 2 || argc==2 && ( argv[1][0]==INCHI_OPTION_PREFX ) &&
+        (!strcmp(argv[1]+1, "?") || !stricmp(argv[1]+1, "help") ) ) {
+        e_HelpCommandLineParms(stdout);
+        return 0;
+    }
+    /*  original input structure */
+    memset( pInp, 0, sizeof(*pInp) );
+    memset( pOut, 0, sizeof(*pOut) );
+
+    memset( szSdfDataValue    , 0, sizeof( szSdfDataValue    ) );
+    
+    /* explicitly cast to (const char **) to avoid a warning about "incompatible pointer type":*/
+    if ( 0 > e_ReadCommandLineParms( argc, (const char **)argv, ip, szSdfDataValue, &ulDisplTime, bReleaseVersion, NULL ) ) {
+        goto exit_function;
+    }
+    if ( !e_OpenFiles( &inp_file, &output_file, &log_file, &prb_file, ip ) ) {
+        goto exit_function;
+    }
+    if ( ip->bNoStructLabels ) {
+        ip->pSdfLabel = NULL;
+        ip->pSdfValue = NULL;
+    } else
+    if ( ip->nInputType == INPUT_INCHI_PLAIN  ||
+         ip->nInputType == INPUT_INCHI_XML    ||
+         ip->nInputType == INPUT_CMLFILE      ) {
+        /* the input may contain both the header and the label of the structure */
+        if ( !ip->pSdfLabel ) 
+            ip->pSdfLabel  = ip->szSdfDataHeader;
+        if ( !ip->pSdfValue )
+            ip->pSdfValue  = szSdfDataValue;
+    }
+    e_PrintInputParms( log_file, ip );
+    pStrInchiId[0] = '\0';
+    /******************************************************************/
+    /*  Main cycle */
+    /*  read input structures and create their InChI */
+    ulTotalProcessingTime = 0;
+
+    out_index = 0;
+    while ( !e_bInterrupted ) {
+        int bHasTimeout = 0;
+        if ( ip->last_struct_number && num_inp >= ip->last_struct_number ) {
+            nRet = _IS_EOF; /*  simulate end of file */
+            goto exit_function;
+        }
+        /* create command line */
+        szInchiCmdLine[0] = '\0';
+        for ( i = 1; i < argc; i ++ ) {
+            if ( argv[i] && INCHI_OPTION_PREFX == argv[i][0] && argv[i][1] ) {
+                /* omit certrain options */
+                if ( !memicmp( argv[i]+1, "start:", 6) ||
+                     !memicmp( argv[i]+1, "end:",   4) ||
+                     !stricmp( argv[i]+1, "Tabbed" )
+                     ) {
+                    continue;
+                }
+                if ( !memicmp( argv[i]+1, "w", 1 ) && isdigit( UCINT argv[i][2] ) ) {
+                    bHasTimeout = 1;
+                }
+                /* add option to szInchiCmdLine */
+                if ( strlen(szInchiCmdLine)+strlen(argv[i]) + 4 < sizeof(szInchiCmdLine) ) {
+                    if ( szInchiCmdLine[0] )
+                        strcat( szInchiCmdLine, " " );
+                    k = ( !(k=strcspn( argv[i], " \t" )) || argv[i][k] ); /* k means enclose in "" */
+                    if ( k )
+                        strcat( szInchiCmdLine, "\"" );
+                    strcat( szInchiCmdLine, argv[i] );
+                    if ( k )
+                        strcat( szInchiCmdLine, "\"" );
+                } else {
+                    e_my_fprintf( stderr, "Too many options. Option \"%s\" ignored\n", argv[i] );
+                }
+            }
+        }
+        if ( !bHasTimeout ) {
+            /* add default timeout option -W60: 60 seconds */
+            char p1[] = "  W60";
+            p1[1] = INCHI_OPTION_PREFX;
+            if ( strlen(szInchiCmdLine) + strlen( p1 ) < sizeof(szInchiCmdLine) ) {
+                strcat( szInchiCmdLine, p1 );
+            } else {
+                e_my_fprintf( stderr, "Too many options. Option \"%s\" ignored\n", p1 );
+            }
+        }
+
+        inp_index = out_index;
+        /*  read one structure from input */
+        e_FreeInchi_Input( pInp );
+        //e_my_fprintf( stderr, "\rStructure: %d.................\r", num_inp+1 );
+        nRet = e_ReadStructure( sd, ip, inp_file, log_file, output_file, prb_file, pInp, num_inp+1,
+                      /* for CML:*/ inp_index, &out_index );
+        /* simulate INChI structure header */
+        lSdfId    = ( ip->bGetSdfileId )? ip->lSdfId : 0; /* if requested then CAS r.n. otherwise struct. number*/
+        nStructNo = ( ip->lMolfileNumber > 0 )? ip->lMolfileNumber : num_inp+1;
+        e_MakeOutputHeader( ip->pSdfLabel, ip->pSdfValue, lSdfId, nStructNo, pStrInchiId, pStrLogId );
+        if ( sd->pStrErrStruct && sd->pStrErrStruct[0] ) {
+            p1 = "; ";
+            p2 = sd->pStrErrStruct;
+        } else {
+            p1 = p2 = "";
+        }
+        /* e_ReadStructure() outputs the error/warning messages, so we do not need to re-output them here */
+        switch ( nRet ) {
+        case _IS_FATAL:
+            num_inp ++;
+            num_err ++;
+            goto exit_function;
+        case _IS_EOF:
+            //e_my_fprintf( stderr, "\rStructure %d could not be read: Detected end of file. \r", num_inp+1 );
+            goto exit_function;
+        case _IS_ERROR:
+            num_inp ++;
+            num_err ++;
+            continue;
+        case _IS_SKIP:
+            num_inp ++;
+            continue;
+        }
+        if ( nRet != _IS_WARNING ) {
+            //e_my_fprintf( stderr, "\r%s   \r", pStrLogId );
+        }
+        /* chiral flag */
+        /* *****************************************************************************
+         * Chiral flags are set in: 
+         * - RunICHI.c #1610 -- ReadTheStructure()     -- cInChI, wInChI
+         * - e_IchiMain.c #273 -- main()               -- C example of calling InChI dll (here)
+         * - inchi_dll.c  #1662 -- ExtractOneStructure -- InChI dll code 
+         *******************************************************************************/   
+
+        p1 = NULL;
+        if ( (ip->nMode & REQ_MODE_CHIR_FLG_STEREO) && (ip->nMode & REQ_MODE_STEREO) &&
+             ( ip->bChiralFlag & (FLAG_SET_INP_AT_CHIRAL | FLAG_SET_INP_AT_NONCHIRAL) ) ) {
+                ; /* cmd line has priority over the chiral flag in Molfile */
+        } else
+        if ( sd->bChiralFlag & FLAG_INP_AT_CHIRAL ) {
+            p1 =  e_GetChiralFlagString( 1 );  /* input file has chiral flag */
+        } else
+        if ( (ip->nMode & REQ_MODE_CHIR_FLG_STEREO) && (ip->nMode & REQ_MODE_STEREO) ||
+             (sd->bChiralFlag & FLAG_INP_AT_NONCHIRAL) ) { /* fix 04/05/2005 D.T.*/
+            /* chiral flag requested (/SUCF) or input has non-chiral flag */
+            p1 =  e_GetChiralFlagString( 0 );
+        }
+        if ( p1 ) {
+            if ( strlen(szInchiCmdLine) + strlen( p1 ) < sizeof(szInchiCmdLine) ) {
+                strcat( szInchiCmdLine, p1 );
+            } else {
+                e_my_fprintf( stderr, "Too many options. Option \"%s\" ignored\n", p1 );
+            }
+        }
+
+        /* create INChI for each connected component of the structure and optionally display them */
+        /* output INChI for the whole structure */
+        FreeINCHI ( pOut );
+        pInp->szOptions = szInchiCmdLine;
+#ifdef CREATE_0D_PARITIES
+        if ( !pInp->stereo0D && !pInp->num_stereo0D ) {
+            int bPointedEdgeStereo = (0 != (TG_FLAG_POINTED_EDGE_STEREO & ip->bTautFlags));
+            set_0D_stereo_parities( pInp, bPointedEdgeStereo );
+            Clear3D2Dstereo(pInp);
+        }
+#endif
+#ifdef NEIGH_ONLY_ONCE
+        e_RemoveRedundantNeighbors( pInp );
+#endif
+        /********************************************
+         *
+         *  CREATE  INCHI
+         *
+         ********************************************/
+        nRet1 = GetINCHI( pInp, pOut );
+
+        ulTotalProcessingTime += sd->ulStructTime;
+        nRet = nRet1;
+#ifdef MAKE_INCHI_FROM_AUXINFO
+        /**************************************************
+         *
+         *  CREATE one more INCHI FROM AuxInfo and compare
+         *
+         *  it to to the first INCHI
+         *
+         *  Note: This should double the elapsed CPU time
+         *
+         **************************************************/
+        if ( nRet1 == inchi_Ret_OKAY || nRet1 == inchi_Ret_WARNING ) {
+            char *szInchiAuxInfo = pOut->szAuxInfo, *p1 /* shadowing previous definition */;
+            int   bDoNotAddH = ip->bDoNotAddH;
+            int   nRet2;
+            inchi_Input  inchi_inp2, *pInp2 = &inchi_inp2;
+            inchi_Output inchi_out2, *pOut2 = &inchi_out2;
+            InchiInpData idat;
+            /* setup input for Get_inchi_Input_FromAuxInfo */
+            idat.pInp = pInp2;
+            pInp2->szOptions = NULL; /* not needed */
+            
+            /* Make InChI input out of AuxInfo */
+            nRet2 = Get_inchi_Input_FromAuxInfo( szInchiAuxInfo, bDoNotAddH, &idat );
+            
+            if ( inchi_Ret_OKAY == nRet2 || inchi_Ret_WARNING == nRet2 ) {
+                /* set chiral flag */
+                p1 = NULL;
+                if ( (ip->nMode & REQ_MODE_CHIR_FLG_STEREO) && (ip->nMode & REQ_MODE_STEREO) &&
+                     ( ip->bChiralFlag & (FLAG_SET_INP_AT_CHIRAL | FLAG_SET_INP_AT_NONCHIRAL) ) ) {
+                        ; /* cmd line has priority over the chiral flag in Molfile */
+                } else
+                if ( idat.bChiral & FLAG_INP_AT_CHIRAL ) { /* fix 04/05/2005 D.T.*/
+                    p1 = e_GetChiralFlagString( 1 );  /* input file has chiral flag */
+                } else
+                if ( (ip->nMode & REQ_MODE_CHIR_FLG_STEREO) && (ip->nMode & REQ_MODE_STEREO) ||
+                     (idat.bChiral & FLAG_INP_AT_NONCHIRAL) ) { /* fix 04/05/2005 D.T.*/
+                    /* chiral flag requested (/SUCF) or input has non-chiral flag */
+                    p1 = e_GetChiralFlagString( 0 );
+                }
+                if ( p1 ) {
+                    if ( strlen(szInchiCmdLine) + strlen( p1 ) < sizeof(szInchiCmdLine) ) {
+                        strcat( szInchiCmdLine, p1 );
+                    } else {
+                        e_my_fprintf( stderr, "Too many options. Option \"%s\" ignored\n", p1 );
+                    }
+                }
+
+                /* Make InChI out of InChI input out of AuxInfo */
+                pInp2->szOptions = pInp->szOptions;
+                memset( pOut2, 0, sizeof(*pOut2) );
+                nRet2 = GetINCHI( pInp2, pOut2 );
+                /* Compare the two InChI */
+                if ( nRet2 == inchi_Ret_OKAY || nRet2 == inchi_Ret_WARNING ) {
+                    if ( !pOut2->szInChI || strcmp( pOut->szInChI, pOut2->szInChI ) ) {
+                        e_my_fprintf( stderr, "InChI from AuxInfo Is Different!\n" );
+                    }
+                } else {
+                    e_my_fprintf( stderr, "InChI from AuxInfo could not be produced: \"%s\"\n", pOut2->szMessage );
+                }
+                FreeINCHI( pOut2 );
+            }
+            Free_inchi_Input( pInp2 );
+        }
+#endif
+
+        /*****************************/
+        /*     output err/warn       */
+        /*****************************/
+        if ( pOut->szMessage && pOut->szMessage[0] ) {
+            p1 = "; ";
+            p2 = pOut->szMessage;
+        } else {
+            p1 = p2 = "";
+        }
+        switch ( nRet ) {
+        case inchi_Ret_UNKNOWN:
+        case inchi_Ret_FATAL: /* fatal processing error -- typically, memory allocation error */
+            num_inp ++;
+            num_err ++;
+#if( defined(EXIT_ON_ERR) && defined(REPEAT_ALL) && REPEAT_ALL > 0 )
+            num_repeat = 0;
+#endif
+            e_my_fprintf( log_file, "Fatal Error (No INChI%s%s) %s\n", p1, p2, pStrLogId );
+            goto exit_function;
+        case inchi_Ret_EOF: /* typically, no input structure provided or help requested */
+            /* output previous structure number and message */
+            e_my_fprintf( log_file, "End of file detected after structure %d\n", num_inp );
+            goto exit_function;
+        case inchi_Ret_ERROR:
+            num_inp ++;
+            num_err ++;
+            e_my_fprintf( log_file, "Error (No INChI%s%s) %s\n", p1, p2, pStrLogId );
+#if( defined(EXIT_ON_ERR) && defined(REPEAT_ALL) && REPEAT_ALL > 0 )
+            num_repeat = 0;
+            goto exit_function;
+#endif
+            continue;
+        case inchi_Ret_SKIP:
+            num_inp ++;
+            e_my_fprintf( log_file, "Skipped %s\n", pStrLogId );
+            goto exit_function;
+        case inchi_Ret_OKAY:
+            break;
+        case inchi_Ret_WARNING:
+            e_my_fprintf( log_file, "Warning (%s) %s\n", p2, pStrLogId );
+            break; /* ok */
+        }
+
+        num_inp ++;
+        tot_len = 0;
+        if ( pOut->szInChI && pOut->szInChI[0] ) {
+            if (ip->bINChIOutputOptions & INCHI_OUT_SDFILE_ONLY ) {
+                /*****************************/
+                /*       output SDfile       */
+                /*****************************/
+                char *start;
+                unsigned len;
+                int bAddLabel = 0;
+                /*******************************************************************************/
+                /* output a SDfile. pOut->szInChI contains Molfile ending with "$$$$\n" line.  */
+                /* Replace the 1st line with the structure number                              */
+                /* Replace the last line with the SDfile header, label, and new "$$$$\n" line  */
+                /*******************************************************************************/
+                /* 1. remove the 1st line (later replace it with the actual structure number) */
+                if ( start = strchr( pOut->szInChI, '\n' ) ) {
+                    e_inchi_print( output_file, "Structure #%ld", nStructNo );
+                } else {
+                    start = pOut->szInChI;
+                }
+                /* 2. SDfile header and data: write zero to the 1st byte of
+                 *    the last line "$$$$\n" to remove this line with purpose to relpace it */
+                if ( ip->pSdfLabel && ip->pSdfLabel[0] && ip->pSdfValue && ip->pSdfValue[0] &&
+                     (len = strlen(start)) && len > 5 && '$' == start[len-5] && '\n' == start[len-6] ) {
+                    start[len-5] = '\0';
+                    bAddLabel = 1;
+                }
+                /* 3. Output the whole Molfile */
+                e_inchi_print( output_file, "%s", start );
+                if ( bAddLabel ) {
+                    e_inchi_print( output_file, ">  <%s>\n%s\n\n$$$$\n", ip->pSdfLabel, ip->pSdfValue );
+                }
+
+            } else {
+                /*****************************/
+                /*       output InChI        */
+                /*****************************/
+                int bTabbed  = 0 != ( ip->bINChIOutputOptions & INCHI_OUT_TABBED_OUTPUT );
+                int bAuxInfo = !( ip->bINChIOutputOptions & INCHI_OUT_ONLY_AUX_INFO ) &&
+                               pOut->szAuxInfo && pOut->szAuxInfo[0];
+                const char *pLF  = "\n";
+                const char *pTAB = bTabbed? "\t" : pLF;
+                if ( !ip->bNoStructLabels ) {
+                    /* or print a previously created label string */
+                    e_inchi_print( output_file, "%s%s", pStrInchiId, pTAB );
+                }
+                /* output INChI Identifier */
+                e_inchi_print( output_file, "%s%s", pOut->szInChI, bAuxInfo? pTAB : pLF );
+                /* output INChI Aux Info */
+                if ( bAuxInfo ) {
+                    e_inchi_print( output_file, "%s\n",pOut->szAuxInfo );
+                }
+            }
+        }
+    }
+
+exit_function:
+    e_my_fprintf( log_file, "\nProcessed %d structure%s, %d error%s.\n",
+                 num_inp, (num_inp==1)?"":"s", num_err, (num_err==1)?"":"s" );
+
+
+    e_FreeInchi_Input( pInp );
+    FreeINCHI ( pOut );
+
+#if( ADD_CMLPP == 1 )
+        /* BILLY 8/6/04 */
+        /* free CML memory */
+        FreeCml ();
+        FreeCmlDoc( 1 );
+#endif
+
+    if ( inp_file && inp_file != stdin) {
+        fclose ( inp_file );
+    }
+    if ( prb_file ) {
+        fclose ( prb_file );
+    }
+    if ( output_file && output_file != stdout ) {
+        fclose( output_file );
+    }
+
+    if ( log_file && log_file != stderr ) {
+        fclose( log_file );
+    }
+    for ( i = 0; i < MAX_NUM_PATHS; i ++ ) {
+        if ( ip->path[i] ) {
+            e_inchi_free( (void*) ip->path[i] ); /*  cast deliberately discards 'const' qualifier */
+            ip->path[i] = NULL;
+        }
+    }
+
+#if ( defined(REPEAT_ALL) && REPEAT_ALL > 0 )
+    if ( --num_repeat > 0 ) {
+        goto repeat;
+    }
+#endif
+
+
+    return 0;
+}
+
+
+#endif
+
+/**********************************************************/
+int e_MakeOutputHeader( char *pSdfLabel, char *pSdfValue, long lSdfId, int num_inp, char *pStr1, char *pStr2  )
+{
+    int tot_len1 = 0, tot_len2 = 0;
+    pStr1[0] = '\0';
+    if ( !(pSdfLabel && pSdfLabel[0]) && !(pSdfValue && pSdfValue[0]) ) {
+        tot_len1 = sprintf( pStr1, "Structure: %d", num_inp );
+        tot_len2 = sprintf( pStr2, "structure #%d", num_inp );
+    } else {
+        tot_len1 = sprintf( pStr1, "Structure: %d.%s%s%s%s",
+            num_inp,
+            SDF_LBL_VAL(pSdfLabel, pSdfValue) );
+
+        tot_len2 = sprintf( pStr2, "structure #%d.%s%s%s%s",
+            num_inp,
+            SDF_LBL_VAL(pSdfLabel, pSdfValue) );
+        if ( lSdfId ) {
+            tot_len1 += sprintf( pStr1 + tot_len1, ":%ld", lSdfId );
+            tot_len2 += sprintf( pStr2 + tot_len2, ":%ld", lSdfId );
+        }
+    }
+    return tot_len1;
+}
+/************************************************************/
+char *e_GetChiralFlagString( int bChiralFlagOn )
+{
+    static char szChiralFlag[64];
+    szChiralFlag[0] = ' ';
+    szChiralFlag[1] = INCHI_OPTION_PREFX;
+    sprintf( szChiralFlag+2, "ChiralFlag%s", bChiralFlagOn? "On":"Off" );
+    return szChiralFlag;
+}
+
+

data/ext/src/e_ichisize.h

@@ -0,0 +1,43 @@
+/*
+ * 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 ___INCHISIZE_H__
+#define ___INCHISIZE_H__
+
+
+typedef unsigned short AT_NUMB;
+typedef unsigned short AT_RANK;
+#define AT_RANK_MASK   ((AT_RANK)~0)
+
+typedef signed short NUM_H;
+#define MAX_ATOMS  1024
+
+#define CHAR_MASK  0xFF
+
+typedef unsigned long INCHI_MODE;
+
+#define LEN_COORD 10
+#define NUM_COORD 3
+typedef char MOL_COORD[LEN_COORD*NUM_COORD + NUM_COORD-1]; /*copied 30 bytes from MOLfile */
+
+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;
+
+/* other types */
+
+#define UCINT  (int)(unsigned char)
+#ifndef INCHI_US_CHAR_DEF
+typedef signed char   S_CHAR;
+typedef unsigned char U_CHAR;
+#define INCHI_US_CHAR_DEF
+#endif
+
+
+
+#endif /* ___INCHISIZE_H__ */
+