[BACK]Return to modes.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mg

Annotation of src/usr.bin/mg/modes.c, Revision 1.20

1.20    ! bcallah     1: /*     $OpenBSD: modes.c,v 1.19 2014/03/20 07:47:29 lum Exp $  */
1.11      kjell       2:
                      3: /* This file is in the public domain. */
1.4       niklas      4:
1.1       deraadt     5: /*
1.5       mickey      6:  * Commands to toggle modes.   Without an argument, these functions will
                      7:  * toggle the given mode.  A negative or zero argument will turn the mode
1.3       millert     8:  * off.  A positive argument will turn the mode on.
1.1       deraadt     9:  */
1.20    ! bcallah    10:
        !            11: #include <sys/queue.h>
        !            12: #include <signal.h>
        !            13: #include <stdio.h>
        !            14: #include <string.h>
1.1       deraadt    15:
                     16: #include "def.h"
                     17: #include "kbd.h"
                     18:
1.17      kjell      19: int    changemode(int, int, char *);
1.3       millert    20:
                     21: int     defb_nmodes = 0;
1.13      deraadt    22: struct maps_s  *defb_modes[PBMODES] = { &fundamental_mode };
1.3       millert    23: int     defb_flag = 0;
1.2       millert    24:
1.17      kjell      25: int
1.8       vincent    26: changemode(int f, int n, char *mode)
1.2       millert    27: {
1.3       millert    28:        int      i;
1.13      deraadt    29:        struct maps_s   *m;
1.2       millert    30:
                     31:        if ((m = name_mode(mode)) == NULL) {
1.19      lum        32:                dobeep();
1.2       millert    33:                ewprintf("Can't find mode %s", mode);
1.10      db         34:                return (FALSE);
1.2       millert    35:        }
                     36:        if (!(f & FFARG)) {
                     37:                for (i = 0; i <= curbp->b_nmodes; i++)
                     38:                        if (curbp->b_modes[i] == m) {
1.3       millert    39:                                /* mode already set */
                     40:                                n = 0;
1.2       millert    41:                                break;
                     42:                        }
                     43:        }
                     44:        if (n > 0) {
                     45:                for (i = 0; i <= curbp->b_nmodes; i++)
                     46:                        if (curbp->b_modes[i] == m)
1.3       millert    47:                                /* mode already set */
1.10      db         48:                                return (TRUE);
1.2       millert    49:                if (curbp->b_nmodes >= PBMODES - 1) {
1.19      lum        50:                        dobeep();
1.2       millert    51:                        ewprintf("Too many modes");
1.10      db         52:                        return (FALSE);
1.2       millert    53:                }
                     54:                curbp->b_modes[++(curbp->b_nmodes)] = m;
                     55:        } else {
                     56:                /* fundamental is b_modes[0] and can't be unset */
1.5       mickey     57:                for (i = 1; i <= curbp->b_nmodes && m != curbp->b_modes[i];
1.3       millert    58:                    i++);
1.2       millert    59:                if (i > curbp->b_nmodes)
1.10      db         60:                        return (TRUE);  /* mode wasn't set */
1.2       millert    61:                for (; i < curbp->b_nmodes; i++)
                     62:                        curbp->b_modes[i] = curbp->b_modes[i + 1];
                     63:                curbp->b_nmodes--;
                     64:        }
                     65:        upmodes(curbp);
1.10      db         66:        return (TRUE);
1.1       deraadt    67: }
                     68:
1.3       millert    69: int
1.8       vincent    70: indentmode(int f, int n)
1.1       deraadt    71: {
1.10      db         72:        return (changemode(f, n, "indent"));
1.1       deraadt    73: }
                     74:
1.3       millert    75: int
1.8       vincent    76: fillmode(int f, int n)
1.1       deraadt    77: {
1.10      db         78:        return (changemode(f, n, "fill"));
1.1       deraadt    79: }
                     80:
1.3       millert    81: #ifdef NOTAB
                     82: int
1.8       vincent    83: notabmode(int f, int n)
1.1       deraadt    84: {
1.2       millert    85:        if (changemode(f, n, "notab") == FALSE)
1.10      db         86:                return (FALSE);
1.2       millert    87:        if (f & FFARG) {
                     88:                if (n <= 0)
                     89:                        curbp->b_flag &= ~BFNOTAB;
                     90:                else
                     91:                        curbp->b_flag |= BFNOTAB;
                     92:        } else
                     93:                curbp->b_flag ^= BFNOTAB;
1.10      db         94:        return (TRUE);
1.1       deraadt    95: }
1.3       millert    96: #endif /* NOTAB */
1.1       deraadt    97:
1.3       millert    98: int
1.15      kjell      99: overwrite_mode(int f, int n)
1.1       deraadt   100: {
1.2       millert   101:        if (changemode(f, n, "overwrite") == FALSE)
1.10      db        102:                return (FALSE);
1.2       millert   103:        if (f & FFARG) {
                    104:                if (n <= 0)
                    105:                        curbp->b_flag &= ~BFOVERWRITE;
                    106:                else
                    107:                        curbp->b_flag |= BFOVERWRITE;
                    108:        } else
                    109:                curbp->b_flag ^= BFOVERWRITE;
1.10      db        110:        return (TRUE);
1.1       deraadt   111: }
                    112:
1.3       millert   113: int
1.8       vincent   114: set_default_mode(int f, int n)
1.1       deraadt   115: {
1.3       millert   116:        int      i;
1.13      deraadt   117:        struct maps_s   *m;
1.16      kjell     118:        char     modebuf[32], *bufp;
1.2       millert   119:
1.16      kjell     120:        if ((bufp = eread("Set Default Mode: ", modebuf, sizeof(modebuf),
1.12      kjell     121:            EFNEW)) == NULL)
1.10      db        122:                return (ABORT);
1.9       vincent   123:        else if (bufp[0] == '\0')
1.10      db        124:                return (FALSE);
1.16      kjell     125:        if ((m = name_mode(modebuf)) == NULL) {
1.19      lum       126:                dobeep();
1.16      kjell     127:                ewprintf("can't find mode %s", modebuf);
1.10      db        128:                return (FALSE);
1.2       millert   129:        }
                    130:        if (!(f & FFARG)) {
                    131:                for (i = 0; i <= defb_nmodes; i++)
                    132:                        if (defb_modes[i] == m) {
1.3       millert   133:                                /* mode already set */
                    134:                                n = 0;
1.2       millert   135:                                break;
                    136:                        }
                    137:        }
                    138:        if (n > 0) {
                    139:                for (i = 0; i <= defb_nmodes; i++)
                    140:                        if (defb_modes[i] == m)
1.3       millert   141:                                /* mode already set */
1.10      db        142:                                return (TRUE);
1.2       millert   143:                if (defb_nmodes >= PBMODES - 1) {
1.19      lum       144:                        dobeep();
1.2       millert   145:                        ewprintf("Too many modes");
1.10      db        146:                        return (FALSE);
1.2       millert   147:                }
                    148:                defb_modes[++defb_nmodes] = m;
                    149:        } else {
                    150:                /* fundamental is defb_modes[0] and can't be unset */
1.3       millert   151:                for (i = 1; i <= defb_nmodes && m != defb_modes[i]; i++);
1.2       millert   152:                if (i > defb_nmodes)
1.3       millert   153:                        /* mode was not set */
1.10      db        154:                        return (TRUE);
1.2       millert   155:                for (; i < defb_nmodes; i++)
                    156:                        defb_modes[i] = defb_modes[i + 1];
                    157:                defb_nmodes--;
                    158:        }
1.16      kjell     159:        if (strcmp(modebuf, "overwrite") == 0) {
1.5       mickey    160:                if (n <= 0)
1.2       millert   161:                        defb_flag &= ~BFOVERWRITE;
1.5       mickey    162:                else
1.2       millert   163:                        defb_flag |= BFOVERWRITE;
1.3       millert   164:        }
1.1       deraadt   165: #ifdef NOTAB
1.16      kjell     166:        if (strcmp(modebuf, "notab") == 0) {
1.2       millert   167:                if (n <= 0)
                    168:                        defb_flag &= ~BFNOTAB;
                    169:                else
                    170:                        defb_flag |= BFNOTAB;
1.14      kjell     171:        }
1.3       millert   172: #endif /* NOTAB */
1.10      db        173:        return (TRUE);
1.1       deraadt   174: }