int main(void) { start = last = NULL; /* initialize start and end pointers */ for (;;) { switch (menu_select()) { case 1: enter(); /* enter an address */ break; case 2: mldelete(&start, &last); /* remove an address */ break; case 3: list(); /* display the list */ break; case 4: search(); /* find an address */ break; case 5: save(); /* save list to disk */ break; case 6: load(); /* read from disk */ break; case 7: exit(0); } } return 0; }
int killRectangle(int f, int n) { meUByte *kstr ; meInt slno, elno, size ; int soff, eoff, coff, llen, dotPos ; if (frameCur->windowCur->markLine == NULL) return noMarkSet() ; if(frameCur->windowCur->dotLine == frameCur->windowCur->markLine) return killRegion(f,n) ; if(bufferSetEdit() <= 0) /* Check we can change the buffer */ return meFALSE ; eoff = getcwcol() ; /* remember we have swapped */ windowSwapDotAndMark(0,1) ; soff = getcwcol() ; if(soff > eoff) { llen = eoff ; eoff = soff ; soff = llen ; } llen = eoff - soff ; if((dotPos=frameCur->windowCur->dotLineNo > frameCur->windowCur->markLineNo)) windowSwapDotAndMark(0,1) ; slno = frameCur->windowCur->dotLineNo ; elno = frameCur->windowCur->markLineNo ; /* calculate the maximum length */ size = (elno - slno + 1) * (llen + 1) ; /* sort out the kill buffer */ if((lastflag != meCFKILL) && (thisflag != meCFKILL)) killSave(); if((kstr = killAddNode(size)) == NULL) return meFALSE ; thisflag = meCFKILL; for(;;) { meUByte *off, cc ; int lspc=0, ii, jj, kk, ll ; windCurLineOffsetEval(frameCur->windowCur) ; off = frameCur->windowCur->dotCharOffset->text ; coff = 0 ; ii = 0 ; kk = frameCur->windowCur->dotLine->length ; while(ii < kk) { if(coff == soff) break ; if((coff+off[ii]) > soff) { lspc = soff - coff ; /* as we can convert tabs to spaces, adjust the offset */ if(meLineGetChar(frameCur->windowCur->dotLine,ii) == meCHAR_TAB) off[ii] -= lspc ; coff = soff ; break ; } coff += off[ii++] ; } jj = ii ; if(coff < soff) { /* line too short to even get to the start point */ lspc = soff - coff ; memset(kstr,' ',llen) ; kstr += llen ; } else { while(jj < kk) { if(coff == eoff) break ; if((ll = off[jj]) != 0) { cc = meLineGetChar(frameCur->windowCur->dotLine,jj) ; if((coff+ll) > eoff) { /* as we can convert tabs to spaces, delete and convert */ if(cc == meCHAR_TAB) { lspc += coff + ll - eoff ; jj++ ; } break ; } coff += ll ; if(cc == meCHAR_TAB) { /* convert tabs to spaces for better column support */ do *kstr++ = ' ' ; while(--ll > 0) ; } else *kstr++ = cc ; } jj++ ; } if(coff < eoff) { /* line too short to get to the end point, fill with spaces */ coff = eoff - coff ; memset(kstr,' ',coff) ; kstr += coff ; } } *kstr++ = '\n' ; frameCur->windowCur->dotOffset = ii ; if((jj -= ii) > 0) { #if MEOPT_UNDO meUndoAddDelChars(jj) ; #endif mldelete(jj,NULL) ; } if(lspc) { if(lineInsertChar(lspc,' ') <= 0) { *kstr = '\0' ; return meFALSE ; } #if MEOPT_UNDO if(jj > 0) meUndoAddReplaceEnd(lspc) ; else meUndoAddInsChars(lspc) ; #endif } if(frameCur->windowCur->dotLineNo == elno) break ; /* move on to the next line */ frameCur->windowCur->dotLineNo++ ; frameCur->windowCur->dotLine = meLineGetNext(frameCur->windowCur->dotLine); frameCur->windowCur->dotOffset = 0; } *kstr = '\0' ; if(dotPos) windowSwapDotAndMark(0,1) ; return meTRUE ; }
int meUndo(int f, int n) { if(n < -1) { #ifndef NDEBUG if(n == -4) { meUndoNode *nn ; FILE *undoFp=NULL ; if(undoFp == NULL) undoFp = fopen("undo.log","w+") ; fprintf(undoFp,"[Undo stack for %s]\n",frameCur->bufferCur->name) ; nn=frameCur->bufferCur->undoHead ; while(nn != NULL) { if(meUndoIsLineSort(nn)) { fprintf(undoFp,"Undo 0x%02x %p %ld %ld:",nn->type,nn->next, nn->udata.lineSort[0],nn->count) ; for(n=0 ; n<nn->count ; n++) fprintf(undoFp," %ld",nn->udata.lineSort[n+1]) ; fprintf(undoFp,"\n") ; } #if MEOPT_NARROW else if(meUndoIsNarrow(nn)) { meUndoNarrow *nun = (meUndoNarrow *) nn ; fprintf(undoFp,"Undo 0x%02x %p Nrrw %x %ld %ld %d [%s]\n",nun->type,nun->next, nun->name,nun->count,nun->udata.dotp,nun->markupCmd,nun->str) ; } #endif else { fprintf(undoFp,"Undo 0x%02x %p %ld (%ld,%d) [%s]\n",nn->type,nn->next,nn->count, nn->udata.dotp,nn->doto,nn->str) ; if(meUndoIsReplace(nn)) { for(n=0 ; n<nn->doto ; n++) fprintf(undoFp,"(%d,%d) ",nn->udata.pos[n][0],nn->udata.pos[n][1]) ; fprintf(undoFp,"\n") ; } } nn = nn->next ; } fprintf(undoFp,"---------------\n") ; fflush(undoFp) ; } else #endif undoContFlag++ ; } else if(!meModeTest(frameCur->bufferCur->mode,MDUNDO)) return ctrlg(meFALSE,1) ; else if(n < 0) meUndoRemove(frameCur->bufferCur) ; else { static meUndoNode *cun ; static meInt ccount ; static meUShort cdoto ; if((lastflag != meCFUNDO) && ((cun = frameCur->bufferCur->undoHead) != NULL)) { cdoto = cun->doto ; ccount = cun->count ; } for(;;) { meInt count, cont ; if((cun == NULL) || ((n <= 0) && !meModeTest(frameCur->bufferCur->mode,MDEDIT))) break ; if(bufferSetEdit() <= 0) /* Check we can change the buffer */ return meABORT ; cont=0 ; if(cun->type & meUNDO_SPECIAL) { if(meUndoIsSetEdit(cun)) { if(!(cun->type & meUNDO_UNSET_EDIT)) { autowriteremove(frameCur->bufferCur) ; meModeClear(frameCur->bufferCur->mode,MDEDIT) ; frameAddModeToWindows(WFMODE) ; /* update ALL mode lines */ } } else if(meUndoIsLineSort(cun)) { meLine *ln, *eln, **list ; meInt *lineSort, *undoInfo, dddd ; lineSort = cun->udata.lineSort ; windowGotoLine(meTRUE,(*lineSort++) + 1) ; if((list = meMalloc(cun->count * sizeof(meLine *))) == NULL) return meABORT ; undoInfo = meUndoAddLineSort(cun->count) ; eln = frameCur->windowCur->dotLine ; ln = meLineGetPrev(eln) ; for(count=0 ; count<cun->count ; eln=meLineGetNext(eln),count++) { list[*lineSort++] = eln ; eln->prev = (meLine *) count ; } for(count=0 ; count<cun->count ; ln=meLineGetNext(ln),count++) { if(undoInfo != NULL) { dddd = (meInt) list[count]->prev ; *undoInfo++ = dddd ; } ln->next = list[count] ; list[count]->prev = ln ; } ln->next = eln ; eln->prev = ln ; frameCur->windowCur->dotLine = list[0] ; meFree(list) ; } #if MEOPT_NARROW else if(meUndoIsNarrow(cun)) { meUndoNarrow *nun = (meUndoNarrow *) cun ; meInt name ; name = nun->name ; windowGotoLine(meTRUE,nun->udata.dotp+1) ; if(nun->type & meUNDO_NARROW_ADD) { meNarrow *nrrw ; nrrw = frameCur->bufferCur->narrow ; while(nrrw->name != name) nrrw = nrrw->next ; frameCur->bufferCur->dotLine = frameCur->windowCur->dotLine ; frameCur->bufferCur->dotLineNo = frameCur->windowCur->dotLineNo ; frameCur->bufferCur->dotOffset = 0 ; meBufferRemoveNarrow(frameCur->bufferCur,nrrw, (nun->markupCmd > 0) ? nun->str:NULL,1) ; } else { meLine *slp ; slp = frameCur->windowCur->dotLine ; windowGotoLine(meTRUE,ccount+1) ; meBufferCreateNarrow(frameCur->bufferCur,slp,frameCur->windowCur->dotLine, nun->udata.dotp,ccount,name,nun->scheme, (nun->markupFlag) ? nun->str:NULL,nun->markupCmd,1) ; } } #endif if(cun->type & meUNDO_CONTINUE) cont=1 ; goto meUndoNext ; } if(cun->type & meUNDO_REPLACE) { windowGotoLine(meTRUE,cun->udata.pos[cdoto-1][0]+1) ; count = cun->udata.pos[cdoto-1][1] ; if(count < 0) { cont = 1 ; count = -1 - count ; } frameCur->windowCur->dotOffset = (meUShort) count ; } else { if(cun->type & meUNDO_CONTINUE) cont = 1 ; windowGotoLine(meTRUE,cun->udata.dotp+1) ; frameCur->windowCur->dotOffset = cdoto ; } if(cun->type & meUNDO_SINGLE) { ccount-- ; count = 1 ; } else count = ccount ; if(cun->type & meUNDO_INSERT) { meWindowBackwardChar(frameCur->windowCur,count) ; if((count == 1)) meUndoAddDelChar() ; else meUndoAddDelChars(count) ; mldelete(count,NULL) ; } if(cun->type & meUNDO_DELETE) { /* When dealing with long lines this loop becomes infinitly * long because of the number of times that the line is * re-allocated - pre-allocate the line length first. In order * to reduce the processing overhead then we find the longest * strings and then add them back in in one go, this ensures * that we only ever re-allocate the line once. * Jon - 99/12/12. */ meUByte *ss, cc ; ss = cun->str ; /* Deal with a single character undo */ if(cun->type & meUNDO_SINGLE) { ss += ccount ; if((cc = *ss++) == meCHAR_NL) lineInsertNewline(meBUFINSFLAG_UNDOCALL); else if (cc != '\0') lineInsertChar(1, cc); meUndoAddInsChar() ; } else { /* Deal with a multiple character undo. */ count = bufferInsertText(ss,meBUFINSFLAG_UNDOCALL) ; if(count > 0) meUndoAddInsChars(count) ; } } if((cun->type & meUNDO_SINGLE) && (ccount > 0)) { if(cun->type & meUNDO_FORWARD) cdoto++ ; else if(cun->type & meUNDO_INSERT) cdoto-- ; } else if(cun->type & meUNDO_REPLACE) { cdoto-- ; if(!cdoto) goto meUndoNext ; } else { meUndoNext: if((cun = cun->next) != NULL) { cdoto = cun->doto ; ccount = cun->count ; } } if(!cont && (--n == 0)) break ; } thisflag = meCFUNDO ; } return meTRUE ; }