editbuffer.c

/***********************************************************************/
/*                                                                     */
/*                            OCamlTopWin                              */
/*                                                                     */
/*  Developed by Jacob Navia and Chris Watford.                        */
/*                                                                     */
/*  Copyright 2001 Institut National de Recherche en Informatique et   */
/*  en Automatique.  All rights reserved.  This file is distributed    */
/*  under the terms of the GNU General Public License version 2        */
/*  or (at your option) any later version.                             */
/*                                                                     */
/***********************************************************************/

/***********************************************************************/
/* Changes made by Chris Watford to enhance the source editor          */
/* Began 14 Sept 2003 - watford@uiuc.edu                               */
/***********************************************************************/

#include <string.h>
#include <stdlib.h>
#include "inriares.h"
#include "inria.h"

/*------------------------------------------------------------------------
 Procedure:     editbuffer_addline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Adds a line to the current edit buffer
 Input:         Line of text to append to the end
 Output:
 Errors:
--------------------------------------------------------------------------
 Edit History:
    18 Sept 2003 - Chris Watford watford@uiuc.edu
        - Corrected doubly linked list issue
------------------------------------------------------------------------*/
BOOL editbuffer_addline(EditBuffer* edBuf, char* line)
{
    LineList *tail = NULL; //head of the edit buffer line list
    LineList *newline = NULL;

    // sanity check
    if(edBuf == NULL)
    {
        return FALSE;
    }

    // perform edit buffer sanity checks
    if((edBuf->LineCount < 0) || (edBuf->Lines == NULL))
    {
        edBuf->LineCount = 0;
    }

    // move to the end of the line list in the edit buffer
    if((tail = edBuf->Lines) != NULL)
        for( ; tail->Next != NULL; tail = tail->Next);

    // create the new line entry
    newline = (LineList*)SafeMalloc(sizeof(LineList));
    newline->Next = NULL;
    newline->Prev = tail;
    newline->Text = (char*)SafeMalloc(strlen(line)+1);
    strncpy(newline->Text, line, strlen(line)+1);
    newline->Text[strlen(line)] = '\0';

    // add it to the list as the head or the tail
    if(tail != NULL)
    {
        tail->Next = newline;
    } else {
        edBuf->Lines = newline;
    }

    // update the number of lines in the buffer
    edBuf->LineCount++;

    return TRUE;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_updateline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Updates the edit buffer's internal contents for a line
 Input:         idx - Line index
                line - String to add
 Output:        if the line was updated or not
 Errors:
------------------------------------------------------------------------*/
BOOL editbuffer_updateline(EditBuffer* edBuf, int idx, char* line)
{
    LineList *update = edBuf->Lines; //head of the edit buffer line list
    LineList *newline = NULL;
    int i;

    // sanity checks
    if(edBuf == NULL)
    {
        return FALSE;
    } else if(  (edBuf->LineCount == 0) ||
                (edBuf->Lines == NULL) ||
                (idx >= edBuf->LineCount) ||
                (idx < 0) ) {
        return FALSE;
    }

    // move to the index in the line list
    // i left in update != NULL as a sanity check
    for(i = 0; ((update != NULL) && (i != idx)); update = update->Next, i++);

    // did things mess up?
    if( (update == NULL) || (i != idx) )
    {
        return FALSE;
    }

    // get rid of the old line
    free(update->Text);

    // get the new line updated
    update->Text = (char*)SafeMalloc(strlen(line)+1);
    strncpy(update->Text, line, strlen(line)+1);
    update->Text[strlen(line)] = '\0';

    return TRUE;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_updateoraddline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Updates the edit buffer's internal contents for a line
 Input:         idx - Line index
                line - String to add
 Output:        if the line was updated or not
 Errors:
------------------------------------------------------------------------*/
BOOL editbuffer_updateoraddline(EditBuffer* edBuf, int idx, char* line)
{
    LineList *update;

    // sanity checks
    if(edBuf == NULL)
    {
        return FALSE;
    } else if((idx > edBuf->LineCount) || (idx < 0)) {
        return FALSE;
    }

    update = edBuf->Lines; //head of the edit buffer line list

    // do we update or add?
    if((idx < edBuf->LineCount) && (edBuf->Lines != NULL))
    {   //interior line, update
        return editbuffer_updateline(edBuf, idx, line);
    } else {
        //fence line, add
        return editbuffer_addline(edBuf, line);
    }
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_removeline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Removes a line from the edit buffer
 Input:         idx - Line index to remove
 Output:        if the line was removed or not
 Errors:
--------------------------------------------------------------------------
 Edit History:
    18 Sept 2003 - Chris Watford watford@uiuc.edu
        - Added to allow backspace and delete support
        - Corrected doubly linked list issue
------------------------------------------------------------------------*/
BOOL editbuffer_removeline(EditBuffer* edBuf, int idx)
{
    LineList *update = NULL;
    int i = 0;

    // sanity checks
    if(edBuf == NULL)
    {
        return FALSE;
    } else if(  (edBuf->LineCount == 0) ||
                (edBuf->Lines == NULL) ||
                (idx >= edBuf->LineCount) ||
                (idx < 0) ) {
        return FALSE;
    }

    // move to the index in the line list
    // i left in update != NULL as a sanity check
    for(i = 0, update = edBuf->Lines; ((update != NULL) && (i != idx)); update = update->Next, i++);

    // remove this line
    if(update != NULL)
    {
        // break links, removing our line
        if(update->Prev != NULL)
        {
            // we're not the first so just break the link
            update->Prev->Next = update->Next;

            // fix the prev check
            if(update->Next != NULL)
                update->Next->Prev = update->Prev;
        } else {
            // we're the first, attach the next guy to lines
            edBuf->Lines = update->Next;
        }

        // one less line to worry about
        edBuf->LineCount--;

        // get rid of the text
        if(update->Text != NULL)
            free(update->Text);

        // get rid of us
        free(update);

        return TRUE;
    }

    return FALSE;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_getasline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Returns the edit buffer as one big line, \n's and \t's
                become spaces.
 Input:
 Output:
 Errors:
------------------------------------------------------------------------*/
char* editbuffer_getasline(EditBuffer* edBuf)
{
    LineList *line = NULL; //head of the edit buffer line list
    char* retline = (char*)realloc(NULL, 1);
    unsigned int i = 0;

    // fix retline bug
    retline[0] = '\0';

    // sanity checks
    if(edBuf == NULL)
    {
        return NULL;
    } else if (edBuf->LineCount == 0 || edBuf->Lines == NULL) {
        // fix any possible errors that may come from this
        edBuf->LineCount = 0;
        edBuf->Lines = NULL;
        return NULL;
    }

    // get the big line
    for(line = edBuf->Lines; line != NULL; line = line->Next)
    {
        if(line->Text != NULL)
        {
            retline = (char*)realloc(retline, (strlen(retline) + strlen(line->Text) + (strlen(retline) > 0 ? 2 : 1)));

            if(strlen(retline) > 0)
                retline = strcat(retline, " ");

            retline = strcat(retline, line->Text);

            //concat in the hoouuusssseee!
        }
    }

    // now we have the big line, so lets ditch all \n's \t's and \r's
    for(i = 0; i < strlen(retline); i++)
    {
        switch(retline[i])
        {
            case '\n':
            case '\t':
            case '\r':
                retline[i] = ' ';
        }
    }

    return retline;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_getasbuffer ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Returns the edit buffer as one big line, \n's and \t's
                become spaces.
 Input:
 Output:
 Errors:
------------------------------------------------------------------------*/
char* editbuffer_getasbuffer(EditBuffer* edBuf)
{
    LineList *line = NULL; //head of the edit buffer line list
    char* retbuf = (char*)realloc(NULL, 1);
    unsigned int i = 0;

    // fix retline bug
    retbuf[0] = '\0';

    // sanity checks
    if(edBuf == NULL)
    {
        return NULL;
    } else if (edBuf->LineCount == 0 || edBuf->Lines == NULL) {
        // fix any possible errors that may come from this
        edBuf->LineCount = 0;
        edBuf->Lines = NULL;
        return NULL;
    }

    // get the big line
    for(line = edBuf->Lines; line != NULL; line = line->Next)
    {
        if(line->Text != NULL)
        {
            int len = strlen(retbuf);
            len += strlen(line->Text) + (len > 0 ? 3 : 1);

            retbuf = (char*)realloc(retbuf, len);

            if(strlen(retbuf) > 0)
                retbuf = strcat(retbuf, "\r\n");

            retbuf = strcat(retbuf, line->Text);

            retbuf[len-1] = '\0';

            //concat in the hoouuusssseee!
        }
    }

    return retbuf;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_lastline ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Returns the last line in the edit buffer
 Input:
 Output:
 Errors:
------------------------------------------------------------------------*/
char* editbuffer_lastline(EditBuffer* edBuf)
{
    LineList *line = NULL; //head of the edit buffer line list

    // sanity checks
    if(edBuf == NULL)
    {
        return NULL;
    } else if (edBuf->LineCount == 0 || edBuf->Lines == NULL) {
        // fix any possible errors that may come from this
        edBuf->LineCount = 0;
        edBuf->Lines = NULL;
        return NULL;
    }

    // go to the last line
    for(line = edBuf->Lines; line->Next != NULL; line = line->Next);

    return line->Text;
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_copy ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Makes an exact copy of an edit buffer
 Input:
 Output:
 Errors:
--------------------------------------------------------------------------
 Edit History:
    16 Sept 2003 - Chris Watford watford@uiuc.edu
        - Added to make copies of history entries
    18 Sept 2003 - Chris Watford watford@uiuc.edu
        - Corrected doubly linked list issue
    06 Oct  2003 - Chris Watford watford@uiuc.edu
        - Added isCorrect flag
------------------------------------------------------------------------*/
EditBuffer* editbuffer_copy(EditBuffer* edBuf)
{
    // sanity checks
    if(edBuf == NULL)
    {
        return NULL;
    } else {
        EditBuffer* copy = (EditBuffer*)SafeMalloc(sizeof(EditBuffer));
        LineList* lines = edBuf->Lines;
        LineList* lastLine = NULL;

        // clear its initial values
        copy->LineCount = 0;
        copy->Lines = NULL;
        copy->isCorrect = FALSE;

        // well we don't have to copy much
        if((lines == NULL) || (edBuf->LineCount <= 0))
        {
            return copy;
        }

        // get if its correct
        copy->isCorrect = edBuf->isCorrect;

        // go through each line, malloc it and add it
        for( ; lines != NULL; lines = lines->Next)
        {
            LineList* curline = (LineList*)SafeMalloc(sizeof(LineList));
            curline->Next = NULL;
            curline->Prev = NULL;

            // if there was a last line, link them to us
            if(lastLine != NULL)
            {
                lastLine->Next = curline;
                curline->Prev = lastLine;
            }

            // are we the first line? add us to the edit buffer as the first
            if(copy->Lines == NULL)
            {
                copy->Lines = curline;
            }

            // check if there is text on the line
            if(lines->Text == NULL)
            {   // no text, make it blankz0r
                curline->Text = (char*)SafeMalloc(sizeof(char));
                curline->Text[0] = '\0';
            } else {
                // there is text, copy it and null-terminate
                curline->Text = (char*)SafeMalloc(strlen(lines->Text) + 1);
                strncpy(curline->Text, lines->Text, strlen(lines->Text));
                curline->Text[strlen(lines->Text)] = '\0';
            }

            // up the line count and make us the last line
            copy->LineCount++;
            lastLine = curline;
        }

        // return our new copy
        return copy;
    }
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_destroy ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Destroys an edit buffer
 Input:
 Output:
 Errors:
------------------------------------------------------------------------*/
void editbuffer_destroy(EditBuffer* edBuf)
{
    // sanity checks
    if(edBuf == NULL)
    {   // nothing to do
        return;
    } else if(edBuf->Lines != NULL) {
        LineList* lastline = NULL;

        // loop through each line free'ing its text
        for( ; edBuf->Lines != NULL; edBuf->Lines = edBuf->Lines->Next)
        {
            if(edBuf->Lines->Text != NULL)
                free(edBuf->Lines->Text);

            // if there was a line before us, free it
            if(lastline != NULL)
            {
                free(lastline);
                lastline = NULL;
            }

            lastline = edBuf->Lines;
        }

        // free the last line
        free(lastline);
    }

    // free ourself
    free(edBuf);
}

/*------------------------------------------------------------------------
 Procedure:     editbuffer_new ID:1
 Author:        Chris Watford watford@uiuc.edu
 Purpose:       Creates an edit buffer
 Input:
 Output:
 Errors:
--------------------------------------------------------------------------
 Edit History:
    06 Oct  2003 - Chris Watford watford@uiuc.edu
        - Added isCorrect flag
------------------------------------------------------------------------*/
EditBuffer* editbuffer_new(void)
{
    // create a new one
    EditBuffer *edBuf = (EditBuffer*)SafeMalloc(sizeof(EditBuffer));

    // default vals
    edBuf->LineCount = 0;
    edBuf->Lines = NULL;
    edBuf->isCorrect = FALSE;

    // return it
    return edBuf;
}