#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "common.h"

Functions
void	NAMD_truncate (char *)

int	NAMD_read_line (FILE , char , int bufsize=512)

int	NAMD_find_word (const char , const char )

int	NAMD_blank_string (char *)

void	NAMD_find_first_word (char , char )

int	NAMD_read_int (FILE , const char )

void	NAMD_pad (char *, size_t)

void	NAMD_remove_comment (char *)

Function Documentation

int NAMD_blank_string ( char * )

Definition at line 222 of file strlib.C.

Referenced by Molecule::prepare_qm(), Parameters::read_charmm_parameter_file(), Molecule::read_go_file(), and Parameters::read_parameter_file().

 {
         int i;          // Current position in str
         int blank=1;    // Flag 1-> string is blank
         int len;        // length of the string str
 
         len=strlen(str);
 
         for (i=0; i<len && blank; i++)
         {
                 blank = isspace(str[i]);
         }
 
         return(blank);
 }

void NAMD_find_first_word	(	char *	,
		char *
	)

Definition at line 258 of file strlib.C.

References STRINGNULL.

Referenced by Parameters::read_charmm_parameter_file(), Molecule::read_go_file(), and Parameters::read_parameter_file().

 {
         int i=0;        //  Position within source
         int j=0;        //  Position within word
 
         /*  Skip leading white space                                    */
         while ( (source[i] != STRINGNULL) && isspace(source[i]))
                 i++;
 
         /*  Copy the word                                               */
         while ( (source[i] != STRINGNULL) && !isspace(source[i]))
         {
                 word[j]=source[i];
                 i++;
                 j++;
         }
 
         word[j]=STRINGNULL;
 
         return;
 }

int NAMD_find_word	(	const char *	,
		const char *
	)

Definition at line 180 of file strlib.C.

 {
         int i=0;                //  Position inside source
         int search_length;      //  Length of string search
         int source_length;      //  Length of string source
         int found=0;            //  Flag 1-> found the value
 
         search_length=strlen(search);
         source_length=strlen(source);
 
         /*  While we haven't found it and we haven't readched the      */
         /*  point where our current position plus the length of the    */
         /*  string we are looking for is longer than the string itself,*/
         /*  check the next search_length characters for a match        */
         while (!found && ((i+search_length)<=(source_length)))
         {
                 found = (strncasecmp(source+i, search, search_length)==0);
 
                 i++;
         }
 
         return(found);
 }

void NAMD_pad	(	char *	,
		size_t
	)

Definition at line 382 of file strlib.C.

References STRINGNULL.

 {
         char tmp_string[128];
         size_t i;
 
         if (strlen(str) >= length)
                 return;
 
         for (i=0; i<(length-strlen(str)); i++)
         {
                 tmp_string[i] = ' ';
         }
 
         tmp_string[i] = STRINGNULL;
 
         strcat(str, tmp_string);
 }

int NAMD_read_int	(	FILE *	,
		const char *
	)

Definition at line 302 of file strlib.C.

References NAMD_die(), and STRINGNULL.

Referenced by Molecule::read_alch_unpert_angles(), Molecule::read_alch_unpert_bonds(), and Molecule::read_alch_unpert_dihedrals().

 {
         int i;                  //  Loop counter
         int c;                  //  Character read in from file
         char tmp_string[11];    //  Temporary string for integer
         int isNeg;
     
         /*  Skip white space                            */
         while ( ((c=fgetc(fd)) == '\n') || isspace(c) )
         {
         }
 
         /*  Check to make sure we didn't hit EOF        */
         if (c==EOF)
         {
                 char err_msg[128];
 
                 sprintf(err_msg, "EOF ENCOUNTERED READING %s FROM PSF FILE", msg);
                 NAMD_die(err_msg);
         }
 
         /*  Now read in the integer itself              */
         i=0;
 
         /* Modified to read an integer with '-' or '+' sign --Chao Mei */
         isNeg = 0;
         if(c=='-'){
             c = fgetc(fd);
             isNeg = 1;
         }
         if(c=='+')
             c = fgetc(fd);
                 
 
         while (!isspace(c))
         {
                 /*  Check to make sure we only get #'s  */
                 if (!isdigit(c))
                 {
                         char err_msg[128];
 
                         sprintf(err_msg, "ALPHA CHARCTER ENCOUNTERED WHILE READING %s FROM PSF FILE", msg);
                         NAMD_die(err_msg);
                 }
 
                 tmp_string[i] = c;
                 i++;
 
                 c=fgetc(fd);
 
                 /*  Check to make sure we didn't hit EOF*/
                 if (c==EOF)
                 {
                         char err_msg[128];
 
                         sprintf(err_msg, "EOF ENCOUNTERED WHILE READING %s FROM PSF FILE", msg);
                         NAMD_die(err_msg);
                 }
         }
 
         tmp_string[i]=STRINGNULL;
 
         /*  Convert the string to an integer and return its value       */
         if(isNeg)
             return(-atoi(tmp_string));
         else
            return(atoi(tmp_string));
 }

int NAMD_read_line	(	FILE *	fd,
		char *	buf,
		int	bufsize
	)

Definition at line 38 of file strlib.C.

References NAMD_die(), and STRINGNULL.

Referenced by Molecule::prepare_qm(), Parameters::read_charmm_parameter_file(), Molecule::read_go_file(), and Parameters::read_parameter_file().

 {
         int i=0;        //  Current position in buf
         int c;          //  Character read in from file
 
         /*  Loop and read characters until we get either an EOF or a    */
         /*  newline                                                     */
         while ( ((c=fgetc(fd)) != EOF) && (c != '\n') )
         {
                 /*  If we encounter a bracketed comment, skip it.  This */
                 /*  basically means read EVERYTHING until the next } and*/
                 /*  throw it into the big bit bucket                    */
                 if (c == '{')
                 {
                         while ( ((c=fgetc(fd)) != EOF) && (c!='}') )
                         {
                         }
 
                         if (c==EOF)
                         {
                                 buf[i]=STRINGNULL;
                                 char *err_msg = new char[128 + strlen(buf)];
                                 sprintf(err_msg, "ABNORMAL EOF FOUND - buffer=*%s*\n", buf);
                                 NAMD_die(err_msg);
                         }
 
                         continue;
                 }
 
                 /*  Also, use this little piece of logic to remove      */
                 /*  any leading spaces from the line                    */
                 if ((i>0) || !isspace(c))
                 {
                         buf[i] = c;
                         i++;
                         if ( i == bufsize ) {
                                 i--;
                                 buf[i]=STRINGNULL;
                                 char *err_msg = new char[128 + strlen(buf)];
                                 sprintf(err_msg, "BUFFER OVERRUN - buffer=*%s*\n", 
                                    buf);
                                 NAMD_die(err_msg);
                         }
                 }
         }
 
         /*  NULL terminate the string                                   */
         buf[i]=STRINGNULL;
 
         /*  Check for an EOF in the middle of a line                    */
         if ((c==EOF) && (i!=0))
         {
                 buf[i]=STRINGNULL;
                 char *err_msg = new char[128 + strlen(buf)];
                 sprintf(err_msg, "ABNORMAL EOF FOUND - buffer=*%s*\n", buf);
                 NAMD_die(err_msg);
         }
 
         /*  Return the appropriate value                                */
         if (c==EOF)
                 return(-1);
         else
                 return(0);
 }

void NAMD_remove_comment ( char * )

Definition at line 119 of file strlib.C.

References STRINGNULL.

 {
         int i=0;
 
         while ( (str[i] != STRINGNULL) && (str[i] != '!') )
         {
                 i++;
         }
 
         str[i] = STRINGNULL;
 }

void NAMD_truncate ( char * )

Definition at line 145 of file strlib.C.

References STRINGNULL.

 {
         int i;          //  Current position in str
 
         i=strlen(str);
 
         /*  Loop from the back of the string until we find a non-space  */
         for (i--; i>=0 && isspace(str[i]); i--)
         {
         }
         
         str[i+1]=STRINGNULL;
 }

Functions

Function Documentation