source: MondoRescue/branches/2.2.5/mindi-busybox/editors/ed.c@ 1854

/* vi: set sw=4 ts=4: */
/*
 * Copyright (c) 2002 by David I. Bell
 * Permission is granted to use, distribute, or modify this source,
 * provided that this copyright notice remains intact.
 *
 * The "ed" built-in command (much simplified)
 */

#include "libbb.h"

#define searchString bb_common_bufsiz1

enum {
    USERSIZE = sizeof(searchString) > 1024 ? 1024
             : sizeof(searchString) - 1, /* max line length typed in by user */
    INITBUF_SIZE = 1024, /* initial buffer size */
};

typedef struct LINE {
    struct LINE *next;
    struct LINE *prev;
    int len;
    char data[1];
} LINE;

static LINE lines, *curLine;
static int curNum, lastNum, marks[26], dirty;
static char *bufBase, *bufPtr, *fileName;
static int bufUsed, bufSize;

static void doCommands(void);
static void subCommand(const char *cmd, int num1, int num2);
static int getNum(const char **retcp, int *retHaveNum, int *retNum);
static int setCurNum(int num);
static int initEdit(void);
static void termEdit(void);
static void addLines(int num);
static int insertLine(int num, const char *data, int len);
static int deleteLines(int num1, int num2);
static int printLines(int num1, int num2, int expandFlag);
static int writeLines(const char *file, int num1, int num2);
static int readLines(const char *file, int num);
static int searchLines(const char *str, int num1, int num2);
static LINE *findLine(int num);

static int findString(const LINE *lp, const char * str, int len, int offset);

int ed_main(int argc, char **argv);
int ed_main(int argc, char **argv)
{
    if (!initEdit())
        return EXIT_FAILURE;

    if (argc > 1) {
        fileName = strdup(argv[1]);

        if (fileName == NULL) {
            bb_error_msg("no memory");
            termEdit();
            return EXIT_SUCCESS;
        }

        if (!readLines(fileName, 1)) {
            termEdit();
            return EXIT_SUCCESS;
        }

        if (lastNum)
            setCurNum(1);

        dirty = FALSE;
    }

    doCommands();

    termEdit();
    return EXIT_SUCCESS;
}

/*
 * Read commands until we are told to stop.
 */
static void doCommands(void)
{
    const char *cp;
    char *endbuf, *newname, buf[USERSIZE];
    int len, num1, num2, have1, have2;

    while (TRUE) {
        printf(": ");
        fflush(stdout);

        if (fgets(buf, sizeof(buf), stdin) == NULL)
            return;

        len = strlen(buf);

        if (len == 0)
            return;

        endbuf = &buf[len - 1];

        if (*endbuf != '\n') {
            bb_error_msg("command line too long");

            do {
                len = fgetc(stdin);
            } while ((len != EOF) && (len != '\n'));

            continue;
        }

        while ((endbuf > buf) && isblank(endbuf[-1]))
            endbuf--;

        *endbuf = '\0';

        cp = buf;

        while (isblank(*cp))
            cp++;

        have1 = FALSE;
        have2 = FALSE;

        if ((curNum == 0) && (lastNum > 0)) {
            curNum = 1;
            curLine = lines.next;
        }

        if (!getNum(&cp, &have1, &num1))
            continue;

        while (isblank(*cp))
            cp++;

        if (*cp == ',') {
            cp++;

            if (!getNum(&cp, &have2, &num2))
                continue;

            if (!have1)
                num1 = 1;

            if (!have2)
                num2 = lastNum;

            have1 = TRUE;
            have2 = TRUE;
        }

        if (!have1)
            num1 = curNum;

        if (!have2)
            num2 = num1;

        switch (*cp++) {
            case 'a':
                addLines(num1 + 1);
                break;

            case 'c':
                deleteLines(num1, num2);
                addLines(num1);
                break;

            case 'd':
                deleteLines(num1, num2);
                break;

            case 'f':
                if (*cp && !isblank(*cp)) {
                    bb_error_msg("bad file command");
                    break;
                }

                while (isblank(*cp))
                    cp++;

                if (*cp == '\0') {
                    if (fileName)
                        printf("\"%s\"\n", fileName);
                    else
                        printf("No file name\n");
                    break;
                }

                newname = strdup(cp);

                if (newname == NULL) {
                    bb_error_msg("no memory for file name");
                    break;
                }

                if (fileName)
                    free(fileName);

                fileName = newname;
                break;

            case 'i':
                addLines(num1);
                break;

            case 'k':
                while (isblank(*cp))
                    cp++;

                if ((*cp < 'a') || (*cp > 'a') || cp[1]) {
                    bb_error_msg("bad mark name");
                    break;
                }

                marks[*cp - 'a'] = num2;
                break;

            case 'l':
                printLines(num1, num2, TRUE);
                break;

            case 'p':
                printLines(num1, num2, FALSE);
                break;

            case 'q':
                while (isblank(*cp))
                    cp++;

                if (have1 || *cp) {
                    bb_error_msg("bad quit command");
                    break;
                }

                if (!dirty)
                    return;

                printf("Really quit? ");
                fflush(stdout);

                buf[0] = '\0';
                fgets(buf, sizeof(buf), stdin);
                cp = buf;

                while (isblank(*cp))
                    cp++;

                if ((*cp == 'y') || (*cp == 'Y'))
                    return;

                break;

            case 'r':
                if (*cp && !isblank(*cp)) {
                    bb_error_msg("bad read command");
                    break;
                }

                while (isblank(*cp))
                    cp++;

                if (*cp == '\0') {
                    bb_error_msg("no file name");
                    break;
                }

                if (!have1)
                    num1 = lastNum;

                if (readLines(cp, num1 + 1))
                    break;

                if (fileName == NULL)
                    fileName = strdup(cp);

                break;

            case 's':
                subCommand(cp, num1, num2);
                break;

            case 'w':
                if (*cp && !isblank(*cp)) {
                    bb_error_msg("bad write command");
                    break;
                }

                while (isblank(*cp))
                    cp++;

                if (!have1) {
                    num1 = 1;
                    num2 = lastNum;
                }

                if (*cp == '\0')
                    cp = fileName;

                if (cp == NULL) {
                    bb_error_msg("no file name specified");
                    break;
                }

                writeLines(cp, num1, num2);
                break;

            case 'z':
                switch (*cp) {
                case '-':
                    printLines(curNum-21, curNum, FALSE);
                    break;
                case '.':
                    printLines(curNum-11, curNum+10, FALSE);
                    break;
                default:
                    printLines(curNum, curNum+21, FALSE);
                    break;
                }
                break;

            case '.':
                if (have1) {
                    bb_error_msg("no arguments allowed");
                    break;
                }

                printLines(curNum, curNum, FALSE);
                break;

            case '-':
                if (setCurNum(curNum - 1))
                    printLines(curNum, curNum, FALSE);

                break;

            case '=':
                printf("%d\n", num1);
                break;

            case '\0':
                if (have1) {
                    printLines(num2, num2, FALSE);
                    break;
                }

                if (setCurNum(curNum + 1))
                    printLines(curNum, curNum, FALSE);

                break;

            default:
                bb_error_msg("unimplemented command");
                break;
        }
    }
}


/*
 * Do the substitute command.
 * The current line is set to the last substitution done.
 */
static void subCommand(const char * cmd, int num1, int num2)
{
    char *cp, *oldStr, *newStr, buf[USERSIZE];
    int delim, oldLen, newLen, deltaLen, offset;
    LINE *lp, *nlp;
    int globalFlag, printFlag, didSub, needPrint;

    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
        bb_error_msg("bad line range for substitute");
        return;
    }

    globalFlag = FALSE;
    printFlag = FALSE;
    didSub = FALSE;
    needPrint = FALSE;

    /*
     * Copy the command so we can modify it.
     */
    strcpy(buf, cmd);
    cp = buf;

    if (isblank(*cp) || (*cp == '\0')) {
        bb_error_msg("bad delimiter for substitute");
        return;
    }

    delim = *cp++;
    oldStr = cp;

    cp = strchr(cp, delim);

    if (cp == NULL) {
        bb_error_msg("missing 2nd delimiter for substitute");
        return;
    }

    *cp++ = '\0';

    newStr = cp;
    cp = strchr(cp, delim);

    if (cp)
        *cp++ = '\0';
    else
        cp = (char*)"";

    while (*cp) switch (*cp++) {
        case 'g':
            globalFlag = TRUE;
            break;

        case 'p':
            printFlag = TRUE;
            break;

        default:
            bb_error_msg("unknown option for substitute");
            return;
    }

    if (*oldStr == '\0') {
        if (searchString[0] == '\0') {
            bb_error_msg("no previous search string");
            return;
        }

        oldStr = searchString;
    }

    if (oldStr != searchString)
        strcpy(searchString, oldStr);

    lp = findLine(num1);

    if (lp == NULL)
        return;

    oldLen = strlen(oldStr);
    newLen = strlen(newStr);
    deltaLen = newLen - oldLen;
    offset = 0;
    nlp = NULL;

    while (num1 <= num2) {
        offset = findString(lp, oldStr, oldLen, offset);

        if (offset < 0) {
            if (needPrint) {
                printLines(num1, num1, FALSE);
                needPrint = FALSE;
            }

            offset = 0;
            lp = lp->next;
            num1++;

            continue;
        }

        needPrint = printFlag;
        didSub = TRUE;
        dirty = TRUE;

        /*
         * If the replacement string is the same size or shorter
         * than the old string, then the substitution is easy.
         */
        if (deltaLen <= 0) {
            memcpy(&lp->data[offset], newStr, newLen);

            if (deltaLen) {
                memcpy(&lp->data[offset + newLen],
                    &lp->data[offset + oldLen],
                    lp->len - offset - oldLen);

                lp->len += deltaLen;
            }

            offset += newLen;

            if (globalFlag)
                continue;

            if (needPrint) {
                printLines(num1, num1, FALSE);
                needPrint = FALSE;
            }

            lp = lp->next;
            num1++;

            continue;
        }

        /*
         * The new string is larger, so allocate a new line
         * structure and use that.  Link it in in place of
         * the old line structure.
         */
        nlp = (LINE *) malloc(sizeof(LINE) + lp->len + deltaLen);

        if (nlp == NULL) {
            bb_error_msg("cannot get memory for line");
            return;
        }

        nlp->len = lp->len + deltaLen;

        memcpy(nlp->data, lp->data, offset);

        memcpy(&nlp->data[offset], newStr, newLen);

        memcpy(&nlp->data[offset + newLen],
            &lp->data[offset + oldLen],
            lp->len - offset - oldLen);

        nlp->next = lp->next;
        nlp->prev = lp->prev;
        nlp->prev->next = nlp;
        nlp->next->prev = nlp;

        if (curLine == lp)
            curLine = nlp;

        free(lp);
        lp = nlp;

        offset += newLen;

        if (globalFlag)
            continue;

        if (needPrint) {
            printLines(num1, num1, FALSE);
            needPrint = FALSE;
        }

        lp = lp->next;
        num1++;
    }

    if (!didSub)
        bb_error_msg("no substitutions found for \"%s\"", oldStr);
}


/*
 * Search a line for the specified string starting at the specified
 * offset in the line.  Returns the offset of the found string, or -1.
 */
static int findString( const LINE * lp, const char * str, int len, int offset)
{
    int left;
    const char *cp, *ncp;

    cp = &lp->data[offset];
    left = lp->len - offset;

    while (left >= len) {
        ncp = memchr(cp, *str, left);

        if (ncp == NULL)
            return -1;

        left -= (ncp - cp);

        if (left < len)
            return -1;

        cp = ncp;

        if (memcmp(cp, str, len) == 0)
            return (cp - lp->data);

        cp++;
        left--;
    }

    return -1;
}


/*
 * Add lines which are typed in by the user.
 * The lines are inserted just before the specified line number.
 * The lines are terminated by a line containing a single dot (ugly!),
 * or by an end of file.
 */
static void addLines(int num)
{
    int len;
    char buf[USERSIZE + 1];

    while (fgets(buf, sizeof(buf), stdin)) {
        if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0'))
            return;

        len = strlen(buf);

        if (len == 0)
            return;

        if (buf[len - 1] != '\n') {
            bb_error_msg("line too long");
            do {
                len = fgetc(stdin);
            } while ((len != EOF) && (len != '\n'));
            return;
        }

        if (!insertLine(num++, buf, len))
            return;
    }
}


/*
 * Parse a line number argument if it is present.  This is a sum
 * or difference of numbers, '.', '$', 'x, or a search string.
 * Returns TRUE if successful (whether or not there was a number).
 * Returns FALSE if there was a parsing error, with a message output.
 * Whether there was a number is returned indirectly, as is the number.
 * The character pointer which stopped the scan is also returned.
 */
static int getNum(const char **retcp, int *retHaveNum, int *retNum)
{
    const char *cp;
    char *endStr, str[USERSIZE];
    int haveNum, value, num, sign;

    cp = *retcp;
    haveNum = FALSE;
    value = 0;
    sign = 1;

    while (TRUE) {
        while (isblank(*cp))
            cp++;

        switch (*cp) {
            case '.':
                haveNum = TRUE;
                num = curNum;
                cp++;
                break;

            case '$':
                haveNum = TRUE;
                num = lastNum;
                cp++;
                break;

            case '\'':
                cp++;

                if ((*cp < 'a') || (*cp > 'z')) {
                    bb_error_msg("bad mark name");
                    return FALSE;
                }

                haveNum = TRUE;
                num = marks[*cp++ - 'a'];
                break;

            case '/':
                strcpy(str, ++cp);
                endStr = strchr(str, '/');

                if (endStr) {
                    *endStr++ = '\0';
                    cp += (endStr - str);
                }
                else
                    cp = "";

                num = searchLines(str, curNum, lastNum);

                if (num == 0)
                    return FALSE;

                haveNum = TRUE;
                break;

            default:
                if (!isdigit(*cp)) {
                    *retcp = cp;
                    *retHaveNum = haveNum;
                    *retNum = value;
                    return TRUE;
                }

                num = 0;

                while (isdigit(*cp))
                    num = num * 10 + *cp++ - '0';

                haveNum = TRUE;
                break;
        }

        value += num * sign;

        while (isblank(*cp))
            cp++;

        switch (*cp) {
            case '-':
                sign = -1;
                cp++;
                break;

            case '+':
                sign = 1;
                cp++;
                break;

            default:
                *retcp = cp;
                *retHaveNum = haveNum;
                *retNum = value;
                return TRUE;
        }
    }
}


/*
 * Initialize everything for editing.
 */
static int initEdit(void)
{
    int i;

    bufSize = INITBUF_SIZE;
    bufBase = malloc(bufSize);

    if (bufBase == NULL) {
        bb_error_msg("no memory for buffer");
        return FALSE;
    }

    bufPtr = bufBase;
    bufUsed = 0;

    lines.next = &lines;
    lines.prev = &lines;

    curLine = NULL;
    curNum = 0;
    lastNum = 0;
    dirty = FALSE;
    fileName = NULL;
    searchString[0] = '\0';

    for (i = 0; i < 26; i++)
        marks[i] = 0;

    return TRUE;
}


/*
 * Finish editing.
 */
static void termEdit(void)
{
    if (bufBase)
        free(bufBase);

    bufBase = NULL;
    bufPtr = NULL;
    bufSize = 0;
    bufUsed = 0;

    if (fileName)
        free(fileName);

    fileName = NULL;

    searchString[0] = '\0';

    if (lastNum)
        deleteLines(1, lastNum);

    lastNum = 0;
    curNum = 0;
    curLine = NULL;
}


/*
 * Read lines from a file at the specified line number.
 * Returns TRUE if the file was successfully read.
 */
static int readLines(const char * file, int num)
{
    int fd, cc;
    int len, lineCount, charCount;
    char *cp;

    if ((num < 1) || (num > lastNum + 1)) {
        bb_error_msg("bad line for read");
        return FALSE;
    }

    fd = open(file, 0);

    if (fd < 0) {
        perror(file);
        return FALSE;
    }

    bufPtr = bufBase;
    bufUsed = 0;
    lineCount = 0;
    charCount = 0;
    cc = 0;

    printf("\"%s\", ", file);
    fflush(stdout);

    do {
        cp = memchr(bufPtr, '\n', bufUsed);

        if (cp) {
            len = (cp - bufPtr) + 1;

            if (!insertLine(num, bufPtr, len)) {
                close(fd);
                return FALSE;
            }

            bufPtr += len;
            bufUsed -= len;
            charCount += len;
            lineCount++;
            num++;

            continue;
        }

        if (bufPtr != bufBase) {
            memcpy(bufBase, bufPtr, bufUsed);
            bufPtr = bufBase + bufUsed;
        }

        if (bufUsed >= bufSize) {
            len = (bufSize * 3) / 2;
            cp = realloc(bufBase, len);

            if (cp == NULL) {
                bb_error_msg("no memory for buffer");
                close(fd);
                return FALSE;
            }

            bufBase = cp;
            bufPtr = bufBase + bufUsed;
            bufSize = len;
        }

        cc = read(fd, bufPtr, bufSize - bufUsed);
        bufUsed += cc;
        bufPtr = bufBase;

    } while (cc > 0);

    if (cc < 0) {
        perror(file);
        close(fd);
        return FALSE;
    }

    if (bufUsed) {
        if (!insertLine(num, bufPtr, bufUsed)) {
            close(fd);
            return -1;
        }

        lineCount++;
        charCount += bufUsed;
    }

    close(fd);

    printf("%d lines%s, %d chars\n", lineCount,
        (bufUsed ? " (incomplete)" : ""), charCount);

    return TRUE;
}


/*
 * Write the specified lines out to the specified file.
 * Returns TRUE if successful, or FALSE on an error with a message output.
 */
static int writeLines(const char * file, int num1, int num2)
{
    LINE *lp;
    int fd, lineCount, charCount;

    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
        bb_error_msg("bad line range for write");
        return FALSE;
    }

    lineCount = 0;
    charCount = 0;

    fd = creat(file, 0666);

    if (fd < 0) {
        perror(file);
        return FALSE;
    }

    printf("\"%s\", ", file);
    fflush(stdout);

    lp = findLine(num1);

    if (lp == NULL) {
        close(fd);
        return FALSE;
    }

    while (num1++ <= num2) {
        if (write(fd, lp->data, lp->len) != lp->len) {
            perror(file);
            close(fd);
            return FALSE;
        }

        charCount += lp->len;
        lineCount++;
        lp = lp->next;
    }

    if (close(fd) < 0) {
        perror(file);
        return FALSE;
    }

    printf("%d lines, %d chars\n", lineCount, charCount);
    return TRUE;
}


/*
 * Print lines in a specified range.
 * The last line printed becomes the current line.
 * If expandFlag is TRUE, then the line is printed specially to
 * show magic characters.
 */
static int printLines(int num1, int num2, int expandFlag)
{
    const LINE *lp;
    const char *cp;
    int ch, count;

    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
        bb_error_msg("bad line range for print");
        return FALSE;
    }

    lp = findLine(num1);

    if (lp == NULL)
        return FALSE;

    while (num1 <= num2) {
        if (!expandFlag) {
            write(1, lp->data, lp->len);
            setCurNum(num1++);
            lp = lp->next;

            continue;
        }

        /*
         * Show control characters and characters with the
         * high bit set specially.
         */
        cp = lp->data;
        count = lp->len;

        if ((count > 0) && (cp[count - 1] == '\n'))
            count--;

        while (count-- > 0) {
            ch = *cp++;

            if (ch & 0x80) {
                fputs("M-", stdout);
                ch &= 0x7f;
            }

            if (ch < ' ') {
                fputc('^', stdout);
                ch += '@';
            }

            if (ch == 0x7f) {
                fputc('^', stdout);
                ch = '?';
            }

            fputc(ch, stdout);
        }

        fputs("$\n", stdout);

        setCurNum(num1++);
        lp = lp->next;
    }

    return TRUE;
}


/*
 * Insert a new line with the specified text.
 * The line is inserted so as to become the specified line,
 * thus pushing any existing and further lines down one.
 * The inserted line is also set to become the current line.
 * Returns TRUE if successful.
 */
static int insertLine(int num, const char * data, int len)
{
    LINE *newLp, *lp;

    if ((num < 1) || (num > lastNum + 1)) {
        bb_error_msg("inserting at bad line number");
        return FALSE;
    }

    newLp = malloc(sizeof(LINE) + len - 1);

    if (newLp == NULL) {
        bb_error_msg("failed to allocate memory for line");
        return FALSE;
    }

    memcpy(newLp->data, data, len);
    newLp->len = len;

    if (num > lastNum)
        lp = &lines;
    else {
        lp = findLine(num);

        if (lp == NULL) {
            free((char *) newLp);
            return FALSE;
        }
    }

    newLp->next = lp;
    newLp->prev = lp->prev;
    lp->prev->next = newLp;
    lp->prev = newLp;

    lastNum++;
    dirty = TRUE;
    return setCurNum(num);
}


/*
 * Delete lines from the given range.
 */
static int deleteLines(int num1, int num2)
{
    LINE *lp, *nlp, *plp;
    int count;

    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
        bb_error_msg("bad line numbers for delete");
        return FALSE;
    }

    lp = findLine(num1);

    if (lp == NULL)
        return FALSE;

    if ((curNum >= num1) && (curNum <= num2)) {
        if (num2 < lastNum)
            setCurNum(num2 + 1);
        else if (num1 > 1)
            setCurNum(num1 - 1);
        else
            curNum = 0;
    }

    count = num2 - num1 + 1;

    if (curNum > num2)
        curNum -= count;

    lastNum -= count;

    while (count-- > 0) {
        nlp = lp->next;
        plp = lp->prev;
        plp->next = nlp;
        nlp->prev = plp;
        lp->next = NULL;
        lp->prev = NULL;
        lp->len = 0;
        free(lp);
        lp = nlp;
    }

    dirty = TRUE;

    return TRUE;
}


/*
 * Search for a line which contains the specified string.
 * If the string is NULL, then the previously searched for string
 * is used.  The currently searched for string is saved for future use.
 * Returns the line number which matches, or 0 if there was no match
 * with an error printed.
 */
static int searchLines(const char *str, int num1, int num2)
{
    const LINE *lp;
    int len;

    if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
        bb_error_msg("bad line numbers for search");
        return 0;
    }

    if (*str == '\0') {
        if (searchString[0] == '\0') {
            bb_error_msg("no previous search string");
            return 0;
        }

        str = searchString;
    }

    if (str != searchString)
        strcpy(searchString, str);

    len = strlen(str);

    lp = findLine(num1);

    if (lp == NULL)
        return 0;

    while (num1 <= num2) {
        if (findString(lp, str, len, 0) >= 0)
            return num1;

        num1++;
        lp = lp->next;
    }

    bb_error_msg("cannot find string \"%s\"", str);
    return 0;
}


/*
 * Return a pointer to the specified line number.
 */
static LINE *findLine(int num)
{
    LINE *lp;
    int lnum;

    if ((num < 1) || (num > lastNum)) {
        bb_error_msg("line number %d does not exist", num);
        return NULL;
    }

    if (curNum <= 0) {
        curNum = 1;
        curLine = lines.next;
    }

    if (num == curNum)
        return curLine;

    lp = curLine;
    lnum = curNum;

    if (num < (curNum / 2)) {
        lp = lines.next;
        lnum = 1;
    }
    else if (num > ((curNum + lastNum) / 2)) {
        lp = lines.prev;
        lnum = lastNum;
    }

    while (lnum < num) {
        lp = lp->next;
        lnum++;
    }

    while (lnum > num) {
        lp = lp->prev;
        lnum--;
    }
    return lp;
}


/*
 * Set the current line number.
 * Returns TRUE if successful.
 */
static int setCurNum(int num)
{
    LINE *lp;

    lp = findLine(num);

    if (lp == NULL)
        return FALSE;

    curNum = num;
    curLine = lp;
    return TRUE;
}