BUS error when reading input from file

hello to all, (*ignore title part about input file)

I am not sure where the problem is in my code. Everything is compiling correctly.

here is the code:

Code:

else if ((strcmp (command, "align")) == 0 )
                    {
                        printf("Align sequences ( not yet implemented)\n");
                        
                        int firstSeq = atoi(strtok(NULL, " \n\t")) ;  
                        int secondSeq = atoi(strtok(NULL, " \n\t")) ;  
                        
                        #define GAPSCORE -1 

                        // m = top sequence
                        // n = bottom sequence
                        
                        // Change bestScore setup to capture best score
                        // in outer column and row
                        // Note: this may not be the global bestScore
                        
                        typedef struct DPCell { char rowChar ; char colChar ;  int Score ; struct DPCell *traceBack ; int traceBackType; } DPCell ; 
                        
                        // Traceback type = 0 for vertical, 1 for horizontal, 2 for 
                        // diagonal, -1 undefined 
                        
                        DPCell **DPArray ;   // 2-D array
                      
                        
                        // collect sequences from seqTool (*Modify)
                        char *rowSeq = loadedSequences[firstSeq-1].data ; // top sequence (m) "left edge of matrix"
                        char *colSeq = loadedSequences[secondSeq-1].data ; // bottom sequence (n) "top edge of matrix"
                        
                        
                        // Add 1 for the first column that contains gap penalty ( = -1 )
                        int rowLength = strlen( rowSeq ) + 1 ; 
                        int colLength = strlen( colSeq ) + 1 ; 
                        
                        // Arrays to collect final alignment (Must be reversed!!)
                        char *rowAlign = (char *) malloc( (strlen(rowSeq) + strlen(colSeq) + 1) * sizeof( char ) ) ; 
                        char *colAlign = (char *) malloc( (strlen(rowSeq) + strlen(colSeq) + 1) * sizeof( char ) ) ; 
                        
                        // Allocate DP matrix 
                        DPArray = (DPCell **) malloc( rowLength  * sizeof( DPCell * ) ) ; 
                            
                            int i, j ; 
                        
                            for( i = 0 ; i < rowLength ; ++i ) 
                                { 
                                    DPArray[i] = (DPCell *) malloc( colLength * sizeof( DPCell ) ) ; 
                                }  
                        
                        // Initialize Upper left corner 
                            DPArray[0][0].rowChar = '\0' ; 
                            DPArray[0][0].colChar = '\0' ; 
                            DPArray[0][0].Score = 0 ; 
                            DPArray[0][0].traceBack = NULL ; 
                            DPArray[0][0].traceBackType = -1 ;
                        
                        // Left edge 
                            for( i = 1 ; i < rowLength ; ++i ) 
                                { 
                                    DPArray[i][0].rowChar = toupper(rowSeq[i-1]) ; 
                                    DPArray[i][0].colChar = '\0' ; 
                                    DPArray[i][0].Score = i * GAPSCORE ; 
                                    DPArray[i][0].traceBack = & DPArray[i-1][0] ; 
                                    DPArray[i][0].traceBackType = 0 ; 
                                } 
                        
                        // Top edge 
                            for( j = 1 ; j < colLength ; ++j ) 
                                { 
                                    DPArray[0][j].rowChar = '\0' ;
                                    DPArray[0][j].colChar = toupper(colSeq[j-1]) ;
                                    DPArray[0][j].Score = i * GAPSCORE ; 
                                    DPArray[0][j].traceBack = & DPArray[j-1][0] ; 
                                    DPArray[0][j].traceBackType = 1 ; 
                                } 
                        
                        // Process the array interior 
                            for( i = 1 ; i < rowLength ; ++i ) 
                                { 
                                    for( j = 1 ; j < colLength ; ++j ) 
                                        { 
                                            // Simple match score ( +1 for match, 0 for mismatch)
                                            if ( DPArray[i][j].rowChar == DPArray[i][j].colChar  )
                                                {
                                                    DPArray[i][j].Score = (DPArray[i-1][j-1].Score + 1) ;
                                                }
                                            else
                                                {
                                                    DPArray[i][j].Score = DPArray[i-1][j-1].Score ;
                                                }
                                                    {
                                        
                                                        // Horizontal                 
                                                        if( DPArray[i][j-1].Score + GAPSCORE > DPArray[i][j].Score ) 
                                                            { 
                                                                DPArray[i][j].Score = DPArray[i][j-1].Score + GAPSCORE ; 
                                                                DPArray[i][j].traceBack = & DPArray[i][j-1] ; 
                                                                DPArray[i][j].traceBackType = 0 ; 
                                                            } 
                                                        
                                                        // Vertical
                                                        else if( DPArray[i-1][j].Score + GAPSCORE > DPArray[i][j].Score ) 
                                                            { 
                                                                DPArray[i][j].Score = DPArray[i-1][j].Score + GAPSCORE ; 
                                                                DPArray[i][j].traceBack = & DPArray[i-1][j] ; 
                                                                DPArray[i][j].traceBackType = 1 ;
                                                            }
                                                            
                                                        // Diagonal
                                                        else
                                                            {
                                                                DPArray[i][j].traceBack = & DPArray[i-1][j-1] ; 
                                                                DPArray[i][j].traceBackType = 2 ;
                                                            }
                                                    }
                                            }
                                }
                            
                        struct { int score ; struct DPCell *address ;} bestRowCell ;
                        struct { int score ; struct DPCell *address ;} bestColumnCell ;
                        struct { int score ; struct DPCell *address ;} bestCell ; 
                                            
                        // Find the address of the highest value in the bottom row 
                        bestRowCell.score = 0 ;
                        
                            for(i = rowLength, j=1 ; j < (colLength-1) ; ++j )
                                {
                                    if( DPArray[i][j].Score > DPArray[i][j+1].Score ) 
                                        {
                                            bestRowCell.score = DPArray[i][j].Score ;
                                            bestRowCell.address = & DPArray[i][j] ;
                                        }
                                    else
                                        {   
                                            bestRowCell.score = DPArray[i][j+1].Score ;
                                            bestRowCell.address = & DPArray[i][j+1] ;
                                        }
                                }
                        
                        // Find the address of the highest value in the right-most column
                        bestColumnCell.score = 0 ;
                        
                            for(i = 1, j= colLength ; i < (rowLength-1) ; ++i )
                                {
                                    if( DPArray[i][j].Score > DPArray[i][j+1].Score ) 
                                        {
                                            bestColumnCell.score = DPArray[i][j].Score ;
                                            bestColumnCell.address = & DPArray[i][j] ;
                                        }
                                    else
                                        {   
                                            bestColumnCell.score = DPArray[i][j+1].Score ;
                                            bestColumnCell.address = & DPArray[i][j+1] ;
                                        }
                                }
                            
                        // Take values for bestCell
                        bestCell.score = 0 ;
                        
                            if(bestColumnCell.score > bestRowCell.score)
                                {
                                    bestCell.score = bestColumnCell.score ;
                                    bestCell.address = bestColumnCell.address ;
                                }
                            else
                                {
                                    bestCell.score = bestRowCell.score ;
                                    bestCell.address = bestRowCell.address ;
                                }
                                
                        struct DPCell *currentTraceBack = bestCell.address ;
                        
                        int alignPos = 0 ; 
                        while( currentTraceBack ) 
                            { 
                                if( currentTraceBack->traceBackType == 2 ) 
                                    { 
                                        // Diagonal 
                                        
                                        rowAlign[alignPos] = currentTraceBack->rowChar ; 
                                        colAlign[alignPos] = currentTraceBack->colChar ; 
                                        ++alignPos ; 
                                     } 
                               
                                else if( currentTraceBack->traceBackType == 1 )
                                    {
                                        //  Horizontal
                                        
                                        rowAlign[alignPos] = '-' ;
                                        colAlign[alignPos] = currentTraceBack->colChar ;
                                        ++alignPos ; 
                                    }
                        
                                else if( currentTraceBack->traceBackType == 0 ) 
                                    { 
                                        // Veritcal 
                                        
                                        rowAlign[alignPos] = currentTraceBack->rowChar ; 
                                        colAlign[alignPos] = '-' ; 
                                        ++alignPos ; 
                                    }
                            } 
                                    
                        // Reverse the alignments 
                        
                        //char topSequence[] = reverse(rowAlign) ;
                       // char bottomSequence[] = reverse(colAlign) ;
                        
                        // Print sequences
                        
                        //printf("&#37;c\n\n",topSequence) ;
                        //printf("%c\n",bottomSequence) ;
                       
                       printf("%c\n\n",rowAlign) ;
                       printf("%c\n",colAlign) ;
                       
                    }

Any suggestions?

You need to figure out how to post a meaningful question.

I am receiving a "Bus error" when i am running my program. It occurs somewhere in the posted code. Can anyone see a possible source in the posted code that may cause a "Bus error"?

It occurs somewhere in the posted code.

code is too long - start stripping lines of the code
for example putting several lines into

Code:

#if 0
/* these lines will not be compiled */
#endif

till you locate the sourse of your problem

do not cast malloc - read FAQ, check the return values of strtok, malloc etc before using this pointer - you can be trying to access null-pointers

If you run it in the debugger, you should find out which line is the problem at least.

A bus error is usually the result of trying to access mis-aligned data. Are you doing anything odd with pointer arithmetic?

Code:

                        struct { int score ; struct DPCell *address ;} bestRowCell ;
                        struct { int score ; struct DPCell *address ;} bestColumnCell ;
                        struct { int score ; struct DPCell *address ;} bestCell ;

Use a typedef or a struct declaration if you really want these 3 variables to have the same type.

Code:

>                        DPArray = (DPCell **) malloc( rowLength  * sizeof( DPCell * ) ) ;

No need for the cast:

Code:

                        DPArray = malloc( rowLength  * sizeof( DPCell * ) ) ;

Code:

>                                    DPArray[i] = (DPCell *) malloc( colLength * sizeof( DPCell ) ) ;

Same here:

Code:

                                    DPArray[i] = malloc( colLength * sizeof( DPCell ) ) ;

Code:

>                            for(i = rowLength, j=1 ; j < (colLength-1) ; ++j )
>                                {
>                                    if( DPArray[i][j].Score > DPArray[i][j+1].Score )

The value of i is out-of-bounds of the array.