eefill.c

minix软件源代码

	else
	  {	ed_insn(c, exp);

		/* Keep track of indent, once we have a grip on it */
		if (last_cmd == INSCMD && curr_indent != -1)
		  {	this_cmd = INSCMD;  /* Keep the ball rolling */
			if (c == TAB)
				curr_indent = ((curr_indent + 8) & ~7)
						 + 8 * (exp - 1);
			else if (c == '\n')
				curr_indent = 0;
			else if (c < SP || c > 0176)
				curr_indent += (2 * exp);
			else
				curr_indent += exp;
		  }
	  }
}

/* Fill-mode version of "Delete Character" */

fim_dchar()
{	/* In C mode, deleting at BOL should do fake TAB preservation */
	if (cur_buf->b_flags & B_CMODE)
	  {	chroff savdot;
		register int c, indent;

		if (e_rgetc() != LF)
		  {	/* Only hack this at BOL */
			e_getc();
			goto normal;
	    	  }
		e_getc();
		savdot = e_dot();
		indent = 0;
		while ((c = e_getc()) == SP || c == TAB)
			if (c == SP)
				++indent;
		else
			indent = (indent + 8) & ~7;
		e_rgetc();
		if (indent >= 4)
		  {	ed_delete(savdot, e_dot());
			ed_indto((indent - 4) & ~3);
			f_begline();		/* HACK!!!! */
		  }
		else
		  {	e_go(savdot);
			ef_deln(exp);
		  }
	  }
	else
 normal:	return (ef_deln(exp));
}

/* Fill-mode version of "Backward Delete Character" */

fim_bdchar()
{	register int ind;

	/* If in C mode, and deleting into white space at BOL, hack tabs */
	if (exp == 1 && cur_buf->b_flags & B_CMODE &&
			(ind = magic_backto_bol()) > 0)
		ed_indto(ind < 4 ? ind - 1 : ((ind - 4) & ~3));
	else
		return (ef_deln (-exp));
}

/* Fill-mode version of "CRLF" */
fim_crlf()
{	register int i;

	if(e_getc() == LF
	  && exp == 1
	  && e_lblankp() && e_lblankp())
	  {	e_gocur();
		e_gonl();
		e_setcur();
		ed_delete(e_dot(), e_eoldot());
	  }
	else
	  {	e_gocur();
#if IMAGEN
		if (cur_buf->b_flags & B_TEXTMODE && exp == 1 &&
		    magic_wrap('\n'))
			return;
		else
#endif /*IMAGEN*/
		if((i = exp) > 0)
			do ed_crins();
			while(--i);
	  }
}

/* Do all magic for auto-wrap in Text mode:
 * return as did wrap (i.e., everything is taken care of)
 */
magic_wrap(tc)
int tc;				/* "trigger char" */
{
	register int c, indent, i, nc;
	chroff savdot, modstart, breakdot;
    
	savdot = e_dot();
	nc = 0;
	if (last_cmd == INSCMD && curr_indent != -1)
	  {	indent = curr_indent;		/* Already know our indent */
		breakdot = best_break;
	  }
	else
	  {
#ifdef INDENTDEBUG
		barf2("Full indent calculation");
#endif
		for (nc = 0; (c = e_rgetc()) != EOF && c != '\n'; ++nc)
		    ;				/* nc: # chars to look at */
		if (c == '\n')			/* Go back over NL */
			e_getc();
		indent = 0;
    
		/* Search for last line break point, leaving it in breakdot */
		breakdot = (chroff)0;
		while (--nc >= 0)
		  {	c = e_getc();
			if (c == TAB)
				indent = (indent + 8) & ~7;
			else if (c < SP || c > 0176)
				indent += 2;
			else
				++indent;
			if ((c == SP || c == TAB) &&
			  (breakdot == (chroff)0 || (indent <= ev_fcolumn)))
				breakdot = e_dot();
		  }
	  }

    /* If there is nothing to do, get out */
	if (indent <= ev_fcolumn)
	  {	e_go(savdot);
		if (tc == SP)
		  {	curr_indent = indent;
			best_break = (chroff)(savdot + 1); /* Remember here, also */
			this_cmd = INSCMD;		/* We do know current indent */
		  }
		else if (tc == '\n')
		  {	curr_indent = 0;
			best_break = (chroff)0;
			this_cmd = INSCMD;
		  }
		else
			errbarf("bad trigger");
		return(0);
	  }

	if (breakdot == (chroff)0)
	  {
	/* No breakpoint found or none needed, just break line at end
	 */
		e_go(savdot);
		modstart = savdot;
		e_putc('\n');
	  }
	else
	  {
	/* Get to breakpoint and replace with newline
	 */
		e_go(breakdot);
		e_rdelc();
		modstart = e_dot();		/* Remember where changes start */
		e_putc('\n');			/* Insert line break */
		e_go(savdot);			/* Get back to trigger point */
	  }
	if (e_rgetc() != '\n')
	  {		/* If not at line start, */
		e_getc();
		e_putc(tc);			/*  insert trigger character */

	/* Once again, compute new indent by backing up to BOL */
		for (nc = 0; (c = e_rgetc()) != EOF && c != '\n'; ++nc)
			;
		if (c == '\n')			/* Go back over NL */
			e_getc();
		indent = 0;
		breakdot = (chroff)0;
		while (--nc >= 0)
		  {		/* Get back to current dot */
			c = e_getc();
			if (c == TAB)
				indent = (indent + 8) & ~7;
			else if (c < SP || c > 0176)
				indent += 2;
			else
				++indent;
			if ((c == SP || c == TAB) &&
			  (breakdot == (chroff)0 || (indent <= ev_fcolumn)))
				breakdot = e_dot();
		  }
		if (breakdot == (chroff)0)	/* If no good break found, use dot */
			breakdot = e_dot();
		curr_indent = indent;		/* Now we know where we are */
		if (tc == '\n')			/* If trigger was NL */
			best_break = (chroff)0;	/*  indent is 0, and no best break */
		else
			best_break = breakdot;	/* This is best break so far */
	  }
	else
	  {	e_getc();
		curr_indent = 0;		/* At line start, no indent */
		best_break = (chroff)0;		/* Do not have a best break so far */
	  }
	ed_setcur();
	buf_tmat(modstart);			/* Alert to potential changes */
	this_cmd = INSCMD;			/* Say we know where we are */
	return(1);
}

/* Do lots of magic things for C-mode indent:
 * erase back to BOL iff we are looking back at white space only,
 * returning the indent level of the original dot
 * (< 0 means no erasure done)
 */
/*#define MYDEBUG /* */
#ifdef MYDEBUG
reveal(msg, v1, v2, v3)
char *msg;
{
	char ahint[128];
	sprintf(ahint, msg, v1, v2, v3);
	barf2(ahint);
}
#endif

magic_backto_bol()
{
	chroff savdot;
	register int c, indent, nc, i;

	savdot = e_dot();
        nc = 0;
	while ((c = e_rgetc()) != EOF && c != LF)
	  {	++nc;			/* Count # chars */
		if (c != SP && c != TAB)
		  {	e_go(savdot);
#ifdef MYDEBUG
			reveal("fail: nc: %d", nc);
#endif
			return -1;
        	  }
    	  }
	if (c == LF)			/* Go back over the LF */
		e_getc();
    	indent = 0;			/* (zero-based indent) */
    	savdot = e_dot();		/* BOL is now origin for delete */
    	for (i = 1; i <= nc; ++i)
    		if ((c = e_getc()) == SP)
			++indent;
		else 			/* (tab) */
			indent = (indent + 8) & ~7;
    	if (nc > 0)			/* Don't bother deleting nothing */
		ed_delete(savdot, e_dot());
#ifdef MYDEBUG
	reveal("indent: %d, nc: %d, foo: %d", indent, nc, 234);
#endif
	return(indent);
}
#endif /*IMAGEN*/

#if ICONOGRAPHICS
/* Iconographics hack for Auto-Fill mode.  Too big and clumsy, but
 * retained for posterity in case it has some obscure feature.
 */

fill_current_line ()
{
        chroff startpos, endpos, savepos, limitpos;
        int i, foundit;
        SBSTR *savep;

        foundit = 0;
        while (d_curind() > ev_fcolumn)
           {
            foundit = 1;
            startpos = e_dot ();
            e_bwsp ();
            while (d_curind() > ev_fcolumn) /* back up to ends of wds*/
               {                                /* until <= fill column */
                while (!c_wsp (e_rgetc ())) ;
                e_bwsp ();
               }
            if (e_dot () == e_boldot ())
               { /*	ding ("Word does not fit in fill column"); */
	                return(0);
               }
            savep = e_copyn (startpos - e_dot ());
            e_setcur ();                /* ed_delete does gocur */
            ed_delete (savepos = e_dot (), startpos);

		f_crlf();		/* Now insert newline */
		e_sputz(fill_prefix);	/* With fill prefix */
            startpos += e_dot () - savepos;
            if (d_curind() > ev_fcolumn)
               {	ed_delete (savepos, e_dot ());
	                sb_sins (cur_buf, savep);
	                e_setcur ();
        	        ding ("Fill prefix > fill column???");
                	return(0);
               }
            savepos = e_dot ();         /* gun inherited initial whitespace */
            sb_sins (cur_buf, savep);
            e_go (savepos);
            e_fwsp ();
            if ((limitpos = e_dot ()) > startpos) limitpos = startpos;
                                        /* in case rest of line was white */
            ed_delete (savepos, limitpos);
            e_gosetcur (startpos + savepos - limitpos);
           }

        return foundit;
  }
#endif /*ICONOGRAPHICS*/