/* Word wrap on n-spaces. Back-over whatever precedes the point on the current * line and stop on the first word-break or the beginning of the line. If we * reach the beginning of the line, jump back to the end of the word and start * a new line. Otherwise, break the line at the word-break, eat it, and jump * back to the end of the word. * Returns TRUE on success, FALSE on errors. */ int wrapword(void) { register int cnt; /* size of word wrapped to next line */ register int bp; /* index to wrap on */ register int first = -1; int wid, ww; if(curwp->w_doto <= 0) /* no line to wrap? */ return(FALSE); wid = 0; for(bp = cnt = 0; cnt < llength(curwp->w_dotp) && !bp; cnt++){ if(ucs4_isspace(lgetc(curwp->w_dotp, cnt).c)){ first = 0; if(lgetc(curwp->w_dotp, cnt).c == TAB){ ++wid; while(wid & 0x07) ++wid; } else ++wid; } else{ ww = wcellwidth((UCS) lgetc(curwp->w_dotp, cnt).c); wid += (ww >= 0 ? ww : 1); if(!first) first = cnt; } if(first > 0 && wid > fillcol) bp = first; } if(!bp) return(FALSE); /* bp now points to the first character of the next line */ cnt = curwp->w_doto - bp; curwp->w_doto = bp; if(!lnewline()) /* break the line */ return(FALSE); /* * if there's a line below, it doesn't start with whitespace * and there's room for this line... */ if(!(curbp->b_flag & BFWRAPOPEN) && lforw(curwp->w_dotp) != curbp->b_linep && llength(lforw(curwp->w_dotp)) && !ucs4_isspace(lgetc(lforw(curwp->w_dotp), 0).c) && (llength(curwp->w_dotp) + llength(lforw(curwp->w_dotp)) < fillcol)){ gotoeol(0, 1); /* then pull text up from below */ if(lgetc(curwp->w_dotp, curwp->w_doto - 1).c != ' ') linsert(1, ' '); forwdel(0, 1); gotobol(0, 1); } curbp->b_flag &= ~BFWRAPOPEN; /* don't open new line next wrap */ /* restore dot (account for NL) */ if(cnt && !forwchar(0, cnt < 0 ? cnt-1 : cnt)) return(FALSE); return(TRUE); }
/* * The region we're filling is the region from dot to mark. * We cut out that region and then put it back in filled. * The cut out part is saved in the ldelete call and the * reinstalled region is noted in addedregion, so that yank() * can delete it and restore the saved part. */ int fillregion(UCS *qstr, REGION *addedregion) { long c, sz, last_char = 0; int i, j, qlen, same_word, spaces, word_len, word_ind, line_len, ww; int starts_midline = 0; int ends_midline = 0; int offset_into_start; LINE *line_before_start, *lp; UCS line_last, word[NSTRING]; REGION region; /* if region starts midline insert a newline */ if(curwp->w_doto > 0 && curwp->w_doto < llength(curwp->w_dotp)) starts_midline++; /* if region ends midline insert a newline at end */ if(curwp->w_marko > 0 && curwp->w_marko < llength(curwp->w_markp)) ends_midline++; /* cut the paragraph into our fill buffer */ fdelete(); if(!getregion(®ion, curwp->w_markp, curwp->w_marko)) return(FALSE); if(!ldelete(region.r_size, finsert)) return(FALSE); line_before_start = lback(curwp->w_dotp); offset_into_start = curwp->w_doto; if(starts_midline) lnewline(); /* Now insert it back wrapped */ spaces = word_len = word_ind = line_len = same_word = 0; qlen = qstr ? ucs4_strlen(qstr) : 0; /* Beginning with leading quoting... */ if(qstr){ i = 0; while(qstr[i]){ ww = wcellwidth(qstr[i]); line_len += (ww >= 0 ? ww : 1); linsert(1, qstr[i++]); } line_last = ' '; /* no word-flush space! */ } /* remove first leading quotes if any */ if(starts_midline) i = 0; else for(i = qlen; (c = fremove(i)) == ' ' || c == TAB; i++){ linsert(1, line_last = (UCS) c); line_len += ((c == TAB) ? (~line_len & 0x07) + 1 : 1); } /* then digest the rest... */ while((c = fremove(i++)) >= 0){ last_char = c; switch(c){ case '\n' : /* skip next quote string */ j = 0; while(j < qlen && ((c = fremove(i+j)) == qstr[j] || c == ' ')) j++; i += j; if(!spaces) spaces++; same_word = 0; break; case TAB : case ' ' : spaces++; same_word = 0; break; default : if(spaces){ /* flush word? */ if((line_len - qlen > 0) && line_len + word_len + 1 > fillcol && ((ucs4_isspace(line_last)) || (linsert(1, ' '))) && (line_len = fpnewline(qstr))) line_last = ' '; /* no word-flush space! */ if(word_len){ /* word to write? */ if(line_len && !ucs4_isspace(line_last)){ linsert(1, ' '); /* need padding? */ line_len++; } line_len += word_len; for(j = 0; j < word_ind; j++) linsert(1, line_last = word[j]); if(spaces > 1 && strchr(".?!:;\")", line_last)){ linsert(2, line_last = ' '); line_len += 2; } word_len = word_ind = 0; } spaces = 0; } if(word_ind + 1 >= NSTRING){ /* Magic! Fake that we output a wrapped word */ if((line_len - qlen > 0) && !same_word++){ if(!ucs4_isspace(line_last)) linsert(1, ' '); line_len = fpnewline(qstr); } line_len += word_len; for(j = 0; j < word_ind; j++) linsert(1, word[j]); word_len = word_ind = 0; line_last = ' '; } word[word_ind++] = (UCS) c; ww = wcellwidth((UCS) c); word_len += (ww >= 0 ? ww : 1); break; } } if(word_len){ if((line_len - qlen > 0) && (line_len + word_len + 1 > fillcol)){ if(!ucs4_isspace(line_last)) linsert(1, ' '); (void) fpnewline(qstr); } else if(line_len && !ucs4_isspace(line_last)) linsert(1, ' '); for(j = 0; j < word_ind; j++) linsert(1, word[j]); } if(last_char == '\n') lnewline(); if(ends_midline) (void) fpnewline(qstr); /* * Calculate the size of the region that was added. */ swapmark(0,1); /* mark current location after adds */ addedregion->r_linep = lforw(line_before_start); addedregion->r_offset = offset_into_start; lp = addedregion->r_linep; sz = llength(lp) - addedregion->r_offset; if(lforw(lp) != curwp->w_markp->l_fp){ lp = lforw(lp); while(lp != curwp->w_markp->l_fp){ sz += llength(lp) + 1; lp = lforw(lp); } } sz -= llength(curwp->w_markp) - curwp->w_marko; addedregion->r_size = sz; swapmark(0,1); if(ends_midline){ /* * We want to back up to the end of the original * region instead of being here after the added newline. */ curwp->w_doto = 0; backchar(0, 1); unmarkbuffer(); markregion(1); } return(TRUE); }
/* lineeditor(): * This function is fed a pointer to a command line. * It sets up a command line editor for that particular line. * The line is modified in place so, if successful, the function * returns the same pointer but with its contents modified based * on the editor commands executed. * If failure, the function returns (char *)0. */ static char * lineeditor(char *line_to_edit,int type) { lMode = CMD; startOfLine = line_to_edit; curPos = line_to_edit; while(*curPos != ESC) curPos++; *curPos = 0; /* Remove the escape character from the line */ lineLen = (ulong)curPos - (ulong)startOfLine; if (lineLen > 0) { curPos--; putstr(" \b\b"); } else putstr(" \b"); lastsize = 0; shwidx = stridx; srchidx = stridx; while(1) { curChar = getchar(); switch(curChar) { case ESC: if (lMode != CMD) { lMode = CMD; continue; } else { putchar('\n'); return((char *)0); } case '\r': case '\n': putchar('\n'); if (lineLen == 0) return((char *)0); *(char *)(startOfLine + lineLen) = '\0'; return(startOfLine); case CTLC: putchar('\n'); *startOfLine = 0; lineLen = 0; return((char *)0); } switch(lMode) { case CMD: lcmd(type); if (lMode == NEITHER) return((char *)0); break; case INSERT: linsert(); break; case EDIT1: ledit1(); break; case EDIT: ledit(); break; } if (lineLen >= (CMDLINESIZE - 2)) { printf("line overflow\n"); return((char *)0); } } }
int setquotelevelinregion(int quotelevel, REGION *addedregion) { int i, standards_based = 0; int quote_chars = 0, backuptoprevline = 0; int starts_midline = 0, ends_midline = 0, offset_into_start; long c, sz; UCS qstr_def1[] = { '>', ' ', 0}, qstr_def2[] = { '>', 0}; LINE *lp, *line_before_start; REGION region; if(curbp->b_mode&MDVIEW) /* don't allow this command if */ return(rdonly()); /* we are in read only mode */ if(!glo_quote_str || !ucs4_strcmp(glo_quote_str, qstr_def1) || !ucs4_strcmp(glo_quote_str, qstr_def2)) standards_based++; if(!standards_based){ emlwrite("Quote level setting only works with standard \"> \" quotes", NULL); return(FALSE); } /* if region starts midline insert a newline */ if(curwp->w_doto > 0 && curwp->w_doto < llength(curwp->w_dotp)) starts_midline++; /* if region ends midline insert a newline at end */ if(curwp->w_marko > 0 && curwp->w_marko < llength(curwp->w_markp)){ ends_midline++; backuptoprevline++; /* count quote chars for re-insertion */ for(i = 0; i < llength(curwp->w_markp); ++i) if(lgetc(curwp->w_markp, i).c != '>') break; quote_chars = i; } else if(curwp->w_marko == 0) backuptoprevline++; /* find the size of the region */ getregion(®ion, curwp->w_markp, curwp->w_marko); /* cut the paragraph into our fill buffer */ fdelete(); if(!ldelete(region.r_size, finsert)) return(FALSE); line_before_start = lback(curwp->w_dotp); offset_into_start = curwp->w_doto; /* if region starts midline add a newline */ if(starts_midline) lnewline(); i = 0; while(fremove(i) >= 0){ /* remove all quote strs from current line */ if(standards_based){ while((c = fremove(i)) == '>') i++; if(c == ' ') i++; } else{ } /* insert quotelevel quote strs */ if(standards_based){ linsert(quotelevel, '>'); if(quotelevel > 0) linsert(1, ' '); } else{ } /* put back the actual line */ while((c = fremove(i++)) >= 0 && c != '\n') linsert(1, (UCS) c); if(c == '\n') lnewline(); } /* if region ends midline add a newline */ if(ends_midline){ lnewline(); if(quote_chars){ linsert(quote_chars, '>'); if(curwp->w_doto < llength(curwp->w_dotp) && lgetc(curwp->w_dotp, curwp->w_doto).c != ' ') linsert(1, ' '); } } /* * Calculate the size of the region that was added. */ swapmark(0,1); /* mark current location after adds */ addedregion->r_linep = lforw(line_before_start); addedregion->r_offset = offset_into_start; lp = addedregion->r_linep; sz = llength(lp) - addedregion->r_offset; if(lforw(lp) != curwp->w_markp->l_fp){ lp = lforw(lp); while(lp != curwp->w_markp->l_fp){ sz += llength(lp) + 1; lp = lforw(lp); } } sz -= llength(curwp->w_markp) - curwp->w_marko; addedregion->r_size = sz; swapmark(0,1); /* * This puts us at the end of the quoted region instead * of on the following line. This makes it convenient * for the user to follow a quotelevel adjustment with * a Justify if desired. */ if(backuptoprevline){ curwp->w_doto = 0; backchar(0, 1); } if(ends_midline){ /* doesn't need fixing otherwise */ unmarkbuffer(); markregion(1); } return (TRUE); }
/* ARGSUSED */ int fillpara(int f, int n) { int c; /* current char during scan */ int wordlen; /* length of current word */ int clength; /* position on line during fill */ int i; /* index during word copy */ int eopflag; /* Are we at the End-Of-Paragraph? */ int firstflag; /* first word? (needs no space) */ int newlength; /* tentative new line length */ int eolflag; /* was at end of line */ int retval; /* return value */ struct line *eopline; /* pointer to line just past EOP */ char wbuf[MAXWORD]; /* buffer for current word */ if (n == 0) return (TRUE); undo_boundary_enable(FFRAND, 0); /* record the pointer to the line just past the EOP */ (void)gotoeop(FFRAND, 1); if (curwp->w_doto != 0) { /* paragraph ends at end of buffer */ (void)lnewline(); eopline = lforw(curwp->w_dotp); } else eopline = curwp->w_dotp; /* and back top the beginning of the paragraph */ (void)gotobop(FFRAND, 1); /* initialize various info */ while (inword() == 0 && forwchar(FFRAND, 1)); clength = curwp->w_doto; wordlen = 0; /* scan through lines, filling words */ firstflag = TRUE; eopflag = FALSE; while (!eopflag) { /* get the next character in the paragraph */ if ((eolflag = (curwp->w_doto == llength(curwp->w_dotp)))) { c = ' '; if (lforw(curwp->w_dotp) == eopline) eopflag = TRUE; } else c = lgetc(curwp->w_dotp, curwp->w_doto); /* and then delete it */ if (ldelete((RSIZE) 1, KNONE) == FALSE && !eopflag) { retval = FALSE; goto cleanup; } /* if not a separator, just add it in */ if (c != ' ' && c != '\t') { if (wordlen < MAXWORD - 1) wbuf[wordlen++] = c; else { /* * You lose chars beyond MAXWORD if the word * is too long. I'm too lazy to fix it now; it * just silently truncated the word before, * so I get to feel smug. */ ewprintf("Word too long!"); } } else if (wordlen) { /* calculate tentative new length with word added */ newlength = clength + 1 + wordlen; /* * if at end of line or at doublespace and previous * character was one of '.','?','!' doublespace here. * behave the same way if a ')' is preceded by a * [.?!] and followed by a doublespace. */ if (dblspace && (!eopflag && ((eolflag || curwp->w_doto == llength(curwp->w_dotp) || (c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' ' || c == '\t') && (ISEOSP(wbuf[wordlen - 1]) || (wbuf[wordlen - 1] == ')' && wordlen >= 2 && ISEOSP(wbuf[wordlen - 2])))) && wordlen < MAXWORD - 1)) wbuf[wordlen++] = ' '; /* at a word break with a word waiting */ if (newlength <= fillcol) { /* add word to current line */ if (!firstflag) { (void)linsert(1, ' '); ++clength; } firstflag = FALSE; } else { if (curwp->w_doto > 0 && lgetc(curwp->w_dotp, curwp->w_doto - 1) == ' ') { curwp->w_doto -= 1; (void)ldelete((RSIZE) 1, KNONE); } /* start a new line */ (void)lnewline(); clength = 0; } /* and add the word in in either case */ for (i = 0; i < wordlen; i++) { (void)linsert(1, wbuf[i]); ++clength; } wordlen = 0; } } /* and add a last newline for the end of our new paragraph */ (void)lnewline(); /* * We really should wind up where we started, (which is hard to keep * track of) but I think the end of the last line is better than the * beginning of the blank line. */ (void)backchar(FFRAND, 1); retval = TRUE; cleanup: undo_boundary_enable(FFRAND, 1); return (retval); }
/* * insert spaces forward into text * default flag and numeric argument */ void insspace(int f, int n) { linsert(n, ' '); backchar(f, n); }
void main() { int n,num,num1,flag=0; while(1) { clrscr(); printf("\n\t\t\t****** LINKED LIST OPERATION ******\n"); printf("\t\t\t......_________________________......\n"); printf("\nWELCOME,WHAT YOU WANT TO DO ?::"); printf("\n_____________________________\n\n"); printf("\nINSERTION--PRESS 1\n"); printf("\nDELETION --PRESS 2\n"); printf("\nSEARCH --PRESS 3\n"); printf("\nCOUNT --PRESS 4\n"); printf("\nDISPLAY --PRESS 5\n"); printf("\nREVERSE --PRESS 6\n"); printf("\nEXIT --PRESS 7\n"); printf("\n\nENTER YOUR CHOICE::\n"); scanf("%d",&n); switch(n) { case 1: while(1) { flag=0; clrscr(); printf("INSERT A NODE ::\n"); printf("\t\tAT FIRST -PRESS 1.\n"); printf("\t\tAFTER A NODE -PRESS 2.\n"); printf("\t\tBEFORE A NODE -PRESS 3.\n"); printf("\t\tAT LAST -PRESS 4.\n"); printf("\t\tEXIT FROM HERE-PRESS 5.\n"); printf("\n\nENTER YOUR CHOICE::\n"); scanf("%d",&n); switch(n) { case 1: printf("\nENTER A ELEMENT FOR INSERTION\n"); scanf("%d",&num); finsert(num); printf("\n%d IS INSERT AT FIRST PROPERLY\n",num); break; case 2: printf("\nENTER A ELEMENT FOR INSERTION\n"); scanf("%d",&num); printf("AFTER WHICH ELEMENT YOU WANT TO INSERT\n"); scanf("%d",&num1); ainsert(num,num1); break; case 3: printf("ENTER A ELEMENT FOR INSERTION\n"); scanf("%d",&num); printf("BEFORE WHICH ELEMENT YOU WANT TO INSERT\n"); scanf("%d",&num1); binsert(num,num1); break; case 4: printf("ENTER AN ELEMENT FOR INSERT IN LAST\n"); scanf("%d",&num); linsert(num); break; case 5: printf("\nTHANK YOU FOR USING INSERT OPERETION\n"); flag=1; break; } getch(); if(flag==1) break; } break; case 2: while(1) { flag=0; clrscr(); printf("DELETE A NODE ::\n"); printf("\t\tAT FIRST -PRESS 1.\n"); printf("\t\tAFTER A NODE -PRESS 2.\n"); printf("\t\tBEFORE A NODE -PRESS 3.\n"); printf("\t\tAT LAST -PRESS 4.\n"); printf("\t\tEXACT A NODE -PRESS 5.\n"); printf("\t\tEXIT FROM HERE-PRESS 6.\n"); printf("\n\nENTER YOUR CHOICE::\n"); scanf("%d",&n); switch(n) { case 1: fdelete(); break; case 2: printf("\nENTER AFTER WHICH ELEMENT YOU WANT TO DELETE A NODE\n"); scanf("%d",&num); adelete(num); break; case 3: printf("\nENTER BEFORE WHICH ELEMENT YOU WANT TO DELETE A NODE\n"); scanf("%d",&num); bdelete(num); break; case 4: ldelete(); break; case 5: printf("WHICH ELEMENT CONTAIN NODE YOU WANT TO DELETE:\n"); scanf("%d",&num); edelete(num); break; case 6: printf("THANK YOU FOR USING DELETE OPERETION"); flag=1; break; } getch(); if(flag==1) break; } break; case 3: printf("WHICH ELEMENT YOU WANT TO SEARCH ?"); scanf("%d",&num); search(num); break; case 4: num=count(); printf("AT PRESENT LINKLIST CONTAIN %d NODES\n",num); break; case 5: fdisplay(); break; case 6: reverse(); printf("\nREVERSE OPERATION IS COMPLETED SUCESSFULLY\n"); break; case 7: printf("\n\nTHANK YOU FOR USING THIS PROGRAM\n"); getch(); exit(0); } getch(); } }
/* * Insert a tab into file. * Bound to "C-I" */ int tab (int f, int n) { if (n < 0) return (FALSE); return (linsert (n, 9)); }
/* * This function serves two purposes, 1) to strip white space when * Pmaster asks that the composition have its trailing white space * stripped, or 2) to prepare the text as flowed text, as Pmaster * is telling us that we're working with flowed text. * * What flowed currently means to us is stripping all trailing white * space, except for one space if the following line is a continuation * of the paragraph. Also, we space-stuff all lines beginning * with white-space, and leave siglines alone. */ int cleanwhitespace(void) { LINE *cursor_dotp = NULL, **lp = NULL; int i = 0, cursor_doto = 0, is_cursor_line = 0; int do_space_stuffing = 0; if(Pmaster && Pmaster->allow_flowed_text && !(*Pmaster->user_says_noflow)()) do_space_stuffing++; cursor_dotp = curwp->w_dotp; cursor_doto = curwp->w_doto; gotobob(FALSE, 1); for(lp = &curwp->w_dotp; (*lp) != curbp->b_linep; (*lp) = lforw(*lp)){ if(!(llength(*lp) == 3 && lgetc(*lp, 0).c == '-' && lgetc(*lp, 1).c == '-' && lgetc(*lp, 2).c == ' ') && llength(*lp)){ is_cursor_line = (cursor_dotp == (*lp)); /* trim trailing whitespace, to be added back if flowing */ for(i = llength(*lp); i; i--) if(!ucs4_isspace(lgetc(*lp, i - 1).c)) break; if(i != llength(*lp)){ int flow_line = 0; if(Pmaster && !Pmaster->strip_ws_before_send && lforw(*lp) != curbp->b_linep && llength(lforw(*lp)) && !(ucs4_isspace(lgetc(lforw(*lp), 0).c) || isquotedspace(lforw(*lp))) && !(llength(lforw(*lp)) == 3 && lgetc(lforw(*lp), 0).c == '-' && lgetc(lforw(*lp), 1).c == '-' && lgetc(lforw(*lp), 2).c == ' ')) flow_line = 1; if(flow_line && i && lgetc(*lp, i).c == ' '){ /* flowed line ending with space */ i++; if(i != llength(*lp)){ curwp->w_doto = i; ldelete(llength(*lp) - i, NULL); } } else if(flow_line && i && ucs4_isspace(lgetc(*lp, i).c)){ /* flowed line ending with whitespace other than space*/ curwp->w_doto = i; ldelete(llength(*lp) - i, NULL); linsert(1, ' '); } else{ curwp->w_doto = i; ldelete(llength(*lp) - i, NULL); } } if(do_space_stuffing && llength(*lp) && ucs4_isspace(lgetc(*lp, 0).c)){ /* space-stuff only if flowed */ if(Pmaster) Pmaster->space_stuffed = 1; curwp->w_doto = 0; if(is_cursor_line && cursor_doto) cursor_doto++; linsert(1, ' '); } if(is_cursor_line) cursor_dotp = (*lp); } } /* put the cursor back where we found it */ gotobob(FALSE, 1); curwp->w_dotp = cursor_dotp; curwp->w_doto = (cursor_doto < llength(curwp->w_dotp)) ? cursor_doto : llength(curwp->w_dotp) - 1; return(0); }
/* * This is the general command execution routine. It handles the fake binding * of all the keys to "self-insert". It also clears out the "thisflag" word, * and arranges to move it to the "lastflag", so that the next command can * look at it. Return the status of command. */ int execute(UCS c, int f, int n) { KEYTAB *ktp; int status, ww; ktp = (Pmaster) ? &keytab[0] : &pkeytab[0]; while (ktp->k_fp != NULL) { if (ktp->k_code == c) { if(lastflag&CFFILL){ curwp->w_flag |= WFMODE; if(Pmaster == NULL) sgarbk = TRUE; } thisflag = 0; status = (*ktp->k_fp)(f, n); if((lastflag & CFFILL) && !(thisflag & CFFILL)) fdelete(); if((lastflag & CFFLBF) && !(thisflag & CFFLBF)) kdelete(); lastflag = thisflag; /* * Reset flag saying wrap should open a new line whenever * we execute a command (as opposed to just typing in text). * However, if that command leaves us in the same line on the * screen, then don't reset. */ if(curwp->w_flag & (WFMOVE | WFHARD)) curbp->b_flag |= BFWRAPOPEN; /* wrap should open new line */ return (status); } ++ktp; } if(lastflag & CFFILL) /* blat unusable fill data */ fdelete(); if(lastflag & CFFLBF) kdelete(); if (VALID_KEY(c)) { /* Self inserting. */ if (n <= 0) { /* Fenceposts. */ lastflag = 0; return (n<0 ? FALSE : TRUE); } thisflag = 0; /* For the future. */ /* do the appropriate insertion */ /* pico never does C mode, this is simple */ status = linsert(n, c); /* * Check to make sure we didn't go off of the screen * with that character. Take into account tab expansion. * If so wrap the line... */ if(curwp->w_bufp->b_mode & MDWRAP){ int j, wid; wid = 0; for(j = 0; j < llength(curwp->w_dotp); j++) if(ucs4_isspace(lgetc(curwp->w_dotp, j).c)){ if(lgetc(curwp->w_dotp, j).c == TAB){ ++wid; while(wid & 0x07) ++wid; } else ++wid; } else{ ww = wcellwidth((UCS) lgetc(curwp->w_dotp, j).c); wid += (ww >= 0 ? ww : 1); if(wid > fillcol){ wrapword(); break; } } } lastflag = thisflag; return (status); } unknown_command(c); lastflag = 0; /* Fake last flags. */ return (FALSE); }
PASCAL NEAR exitfold( int f, int n ) { BUFFER *bp; /* buffer being entered */ WINDOW *wp; /* windows to fix up pointers in as well */ LINE *lp; /* line limits of entered fold */ int i, j; char tmpstr[NSTRING]; LINE *flp; int fos; int chgflag, vewflag; int margval; /* find the proper buffer */ bp = curwp->w_bufp; if (bp->b_nfolds > 0) { /* need foldsymbol in an array */ strcpy(tmpstr, FOLDSYMBOL); /* decrement fold count */ bp->b_nfolds--; /* close any inner folds */ lp = bp->b_linep->l_fp; while (lp != bp->b_linep) { if (lp->l_type == LSOEFOLD) { lp->l_foldp->l_type = LEOFOLD; lp->l_type = LSOFOLD; i = indx(lp->l_text, BEGINFOLD); for (j = 0; j < strlen(FOLDSYMBOL); j ++) lp->l_text[i + j] = tmpstr[j]; } lp = lp->l_fp; } /* restore previous buffer values, for top */ lp = bp->b_folds[bp->b_nfolds].f_topline; while (lp->l_fp != (LINE *)NULL) lp = lp->l_fp; lp->l_fp = bp->b_linep->l_fp; lp->l_fp->l_bp = lp; bp->b_linep->l_fp = bp->b_folds[bp->b_nfolds].f_topline; bp->b_folds[bp->b_nfolds].f_topline->l_bp = bp->b_linep; /* and bottom */ lp = bp->b_folds[bp->b_nfolds].f_botline; while (lp->l_fp != (LINE *)NULL) lp = lp->l_fp; lp->l_fp = bp->b_linep; bp->b_linep->l_bp->l_fp = bp->b_folds[bp->b_nfolds].f_botline; bp->b_folds[bp->b_nfolds].f_botline->l_bp = bp->b_linep->l_bp; bp->b_linep->l_bp = lp; /* Move cursor to the beginning of next line */ curwp->w_dotp = bp->b_folds[bp->b_nfolds].f_botline->l_foldp->l_fp; curwp->w_doto = 0; /* record if buffer changed yet since this will */ chgflag = bp->b_flag & BFCHG; vewflag = bp->b_mode & MDVIEW; /* no good in view mode */ bp->b_mode &= ~MDVIEW; /* restore prefix - copy in from fold line - maybe ' ' & '\t' */ flp = bp->b_folds[bp->b_nfolds].f_botline->l_foldp; fos = loffset(flp); margval = curwp->w_dotp->l_omargin; while (curwp->w_dotp != bp->b_folds[bp->b_nfolds].f_botline) { curwp->w_doto = 0; for (i = 0; i < fos; i++) linsert(1, flp->l_text[i], FALSE); curwp->w_dotp->l_lmargin = margval; if (curwp->w_dotp->l_type == LSOFOLD) curwp->w_dotp = curwp->w_dotp->l_foldp; curwp->w_dotp = curwp->w_dotp->l_fp; } /* reset change flag? */ if (!chgflag) bp->b_flag &= ~BFCHG; if (vewflag) /* reset view flag */ bp->b_mode |= MDVIEW; /* Move cursor to the beginning of next line */ curwp->w_dotp = bp->b_folds[bp->b_nfolds].f_botline->l_foldp; curwp->w_doto = loffset(curwp->w_dotp); /* let all the proper windows be updated */ wp = wheadp; while (wp) { if (wp->w_bufp == bp) { wp->w_flag |= (WFHARD|WFMODE|WFFORCE); /* enter all windows containing fold */ wp->w_linep = curwp->w_linep; wp->w_dotp = curwp->w_dotp; wp->w_doto = curwp->w_doto; } wp = wp->w_wndp; } mlwrite(TEXT231); /* "[Fold Exited]" */ return(TRUE); } else { mlwrite(TEXT238); /* "%%Not within an entered fold" */ return(FALSE); } }
/* * Yank text back from the kill buffer. This is really easy. All of the work * is done by the standard insert routines. All you do is run the loop, and * check for errors. Bound to "C-Y". */ int yank(int f, int n) { int c, i; REGION region, *added_region; LINE *dotp; if (curbp->b_mode&MDVIEW) /* don't allow this command if */ return(rdonly()); /* we are in read only mode */ if (n < 0) return (FALSE); if(TERM_OPTIMIZE && (curwp->w_dotp != curwp->w_bufp->b_linep)){ int l; if(worthit(&l) && !(lastflag&CFFILL)){ register int t = 0; register int i = 0; register int ch; while((ch=fremove(i++)) >= 0) if(ch == '\n') t++; if(t+l < curwp->w_toprow+curwp->w_ntrows) scrolldown(curwp, l, t); } } if(lastflag & CFFILL){ /* if last command was fillpara() */ if(lastflag & CFFLBF){ gotoeob(FALSE, 1); dotp = curwp->w_dotp; gotobob(FALSE, 1); curwp->w_doto = 0; getregion(®ion, dotp, llength(dotp)); } else{ added_region = get_last_region_added(); if(added_region){ curwp->w_dotp = added_region->r_linep; curwp->w_doto = added_region->r_offset; region = (*added_region); } else return(FALSE); } if(!ldelete(region.r_size, NULL)) return(FALSE); } /* then splat out the saved buffer */ while (n--) { i = 0; while ((c = ((lastflag&CFFILL) ? ((lastflag & CFFLBF) ? kremove(i) : fremove(i)) : kremove(i))) >= 0) { if (c == '\n') { if (lnewline() == FALSE) return (FALSE); } else { if (linsert(1, c) == FALSE) return (FALSE); } ++i; } } if(lastflag&CFFLPA){ /* if last command was fill paragraph */ curwp->w_dotp = lforw(curwp->w_dotp); curwp->w_doto = 0; curwp->w_flag |= WFMODE; if(!Pmaster){ sgarbk = TRUE; emlwrite("", NULL); } } return (TRUE); }
/* * Set a variable. * * @var: variable to set. * @value: value to set to. */ int svar(struct variable_description *var, char *value) { int vnum; /* ordinal number of var refrenced */ int vtype; /* type of variable to set */ int status; /* status return */ int c; /* translated character */ char *sp; /* scratch string pointer */ /* simplify the vd structure (we are gonna look at it a lot) */ vnum = var->v_num; vtype = var->v_type; /* and set the appropriate value */ status = TRUE; switch (vtype) { case TKVAR: /* set a user variable */ if (uv[vnum].u_value != NULL) free(uv[vnum].u_value); sp = malloc(strlen(value) + 1); if (sp == NULL) return FALSE; strcpy(sp, value); uv[vnum].u_value = sp; break; case TKENV: /* set an environment variable */ status = TRUE; /* by default */ switch (vnum) { case EVFILLCOL: fillcol = atoi(value); break; case EVPAGELEN: status = newsize(TRUE, atoi(value)); break; case EVCURCOL: status = setccol(atoi(value)); break; case EVCURLINE: status = gotoline(TRUE, atoi(value)); break; case EVRAM: break; case EVFLICKER: flickcode = stol(value); break; case EVCURWIDTH: status = newwidth(TRUE, atoi(value)); break; case EVCBUFNAME: strcpy(curbp->b_bname, value); curwp->w_flag |= WFMODE; break; case EVCFNAME: strcpy(curbp->b_fname, value); curwp->w_flag |= WFMODE; break; case EVSRES: status = TTrez(value); break; case EVDEBUG: macbug = stol(value); break; case EVSTATUS: cmdstatus = stol(value); break; case EVASAVE: gasave = atoi(value); break; case EVACOUNT: gacount = atoi(value); break; case EVLASTKEY: lastkey = atoi(value); break; case EVCURCHAR: ldelchar(1, FALSE); /* delete 1 char */ c = atoi(value); if (c == '\n') lnewline(); else linsert(1, c); backchar(FALSE, 1); break; case EVDISCMD: discmd = stol(value); break; case EVVERSION: break; case EVPROGNAME: break; case EVSEED: seed = atoi(value); break; case EVDISINP: disinp = stol(value); break; case EVWLINE: status = resize(TRUE, atoi(value)); break; case EVCWLINE: status = forwline(TRUE, atoi(value) - getwpos()); break; case EVTARGET: curgoal = atoi(value); thisflag = saveflag; break; case EVSEARCH: strcpy(pat, value); rvstrcpy(tap, pat); #if MAGIC mcclear(); #endif break; case EVREPLACE: strcpy(rpat, value); break; case EVMATCH: break; case EVKILL: break; case EVCMODE: curbp->b_mode = atoi(value); curwp->w_flag |= WFMODE; break; case EVGMODE: gmode = atoi(value); break; case EVTPAUSE: term.t_pause = atoi(value); break; case EVPENDING: break; case EVLWIDTH: break; case EVLINE: putctext(value); case EVGFLAGS: gflags = atoi(value); break; case EVRVAL: break; case EVTAB: tabmask = atoi(value) - 1; if (tabmask != 0x07 && tabmask != 0x03) tabmask = 0x07; curwp->w_flag |= WFHARD; break; case EVOVERLAP: overlap = atoi(value); break; case EVSCROLLCOUNT: scrollcount = atoi(value); break; case EVSCROLL: #if SCROLLCODE if (!stol(value)) term.t_scroll = NULL; #endif break; } break; } return status; }