![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to macros.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to macros.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 ! root 1: /*************************************************************************** ! 2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE * ! 3: * is provided to you without charge, and with no warranty. You may give * ! 4: * away copies of JOVE, including sources, provided that this notice is * ! 5: * included in all the files. * ! 6: ***************************************************************************/ ! 7: ! 8: #include "jove.h" ! 9: #include "ctype.h" ! 10: #include "io.h" ! 11: ! 12: #ifdef MAC ! 13: # undef private ! 14: # define private ! 15: #endif ! 16: ! 17: #ifdef LINT_ARGS ! 18: private void ! 19: add_mac(struct macro *), ! 20: del_mac(struct macro *), ! 21: pop_macro_stack(void), ! 22: push_macro_stack(struct macro *, int); ! 23: ! 24: private int ! 25: PrefChar(int); ! 26: ! 27: private struct macro * mac_exists(char *); ! 28: #else ! 29: private void ! 30: add_mac(), ! 31: del_mac(), ! 32: pop_macro_stack(), ! 33: push_macro_stack(); ! 34: ! 35: private int ! 36: PrefChar(); ! 37: ! 38: private struct macro * mac_exists(); ! 39: #endif /* LINT_ARGS */ ! 40: ! 41: #ifdef MAC ! 42: # undef private ! 43: # define private static ! 44: #endif ! 45: ! 46: struct macro *macros = 0; /* macros */ ! 47: int InMacDefine = NO; ! 48: ! 49: private void ! 50: add_mac(new) ! 51: struct macro *new; ! 52: { ! 53: register struct macro *mp, ! 54: *prev = 0; ! 55: ! 56: for (mp = macros; mp != 0; prev = mp, mp = mp->m_nextm) ! 57: if (mp == new) ! 58: return; ! 59: ! 60: if (prev) ! 61: prev->m_nextm = new; ! 62: else ! 63: macros = new; ! 64: new->m_nextm = 0; ! 65: new->Type = MACRO; ! 66: } ! 67: ! 68: private void ! 69: del_mac(mac) ! 70: struct macro *mac; ! 71: { ! 72: register struct macro *m; ! 73: ! 74: for (m = macros; m != 0; m = m->m_nextm) ! 75: if (m->m_nextm == mac) { ! 76: m->m_nextm = mac->m_nextm; ! 77: break; ! 78: } ! 79: free(mac->Name); ! 80: free(mac->m_body); ! 81: free((char *) mac); ! 82: } ! 83: ! 84: struct macro KeyMacro; /* Macro used for defining */ ! 85: ! 86: /* To execute a macro, we have a "stack" of running macros. Whenever ! 87: we execute a macro, we push it on the stack, run it, then pop it ! 88: from the stack. */ ! 89: struct m_thread { ! 90: struct m_thread *mt_prev; ! 91: struct macro *mt_mp; ! 92: int mt_offset, ! 93: mt_count; ! 94: }; ! 95: ! 96: private struct m_thread *mac_stack = 0; ! 97: ! 98: void ! 99: unwind_macro_stack() ! 100: { ! 101: while (mac_stack != 0) ! 102: pop_macro_stack(); ! 103: } ! 104: ! 105: private void ! 106: pop_macro_stack() ! 107: { ! 108: register struct m_thread *m; ! 109: ! 110: if ((m = mac_stack) == 0) ! 111: return; ! 112: mac_stack = m->mt_prev; ! 113: free_mthread(m); ! 114: } ! 115: ! 116: struct m_thread * ! 117: alloc_mthread() ! 118: { ! 119: return (struct m_thread *) emalloc(sizeof (struct m_thread)); ! 120: } ! 121: ! 122: void ! 123: free_mthread(t) ! 124: struct m_thread *t; ! 125: { ! 126: free((char *) t); ! 127: } ! 128: ! 129: private void ! 130: push_macro_stack(m, count) ! 131: struct macro *m; ! 132: { ! 133: struct m_thread *t; ! 134: ! 135: if (count <= 0) ! 136: complain("[Cannot execute macro a negative number of times]"); ! 137: t = alloc_mthread(); ! 138: t->mt_prev = mac_stack; ! 139: mac_stack = t; ! 140: t->mt_offset = 0; ! 141: t->mt_mp = m; ! 142: t->mt_count = count; ! 143: } ! 144: ! 145: void ! 146: do_macro(mac) ! 147: struct macro *mac; ! 148: { ! 149: push_macro_stack(mac, arg_value()); ! 150: } ! 151: ! 152: private struct macro * ! 153: mac_exists(name) ! 154: char *name; ! 155: { ! 156: register struct macro *mp; ! 157: ! 158: for (mp = macros; mp; mp = mp->m_nextm) ! 159: if (strcmp(mp->Name, name) == 0) ! 160: return mp; ! 161: return 0; ! 162: } ! 163: ! 164: void ! 165: mac_init() ! 166: { ! 167: add_mac(&KeyMacro); ! 168: KeyMacro.Name = "keyboard-macro"; ! 169: KeyMacro.m_len = 0; ! 170: KeyMacro.m_buflen = 16; ! 171: KeyMacro.m_body = emalloc(KeyMacro.m_buflen); ! 172: } ! 173: ! 174: void ! 175: mac_putc(c) ! 176: int c; ! 177: { ! 178: if (KeyMacro.m_len >= KeyMacro.m_buflen) { ! 179: KeyMacro.m_buflen += 16; ! 180: KeyMacro.m_body = realloc(KeyMacro.m_body, (unsigned) KeyMacro.m_buflen); ! 181: if (KeyMacro.m_body == 0) { ! 182: KeyMacro.m_buflen = KeyMacro.m_len = 0; ! 183: complain("[Can't allocate storage for keyboard macro]"); ! 184: } ! 185: } ! 186: KeyMacro.m_body[KeyMacro.m_len++] = c; ! 187: } ! 188: ! 189: int ! 190: in_macro() ! 191: { ! 192: return (mac_stack != 0); ! 193: } ! 194: ! 195: int ! 196: mac_getc() ! 197: { ! 198: struct m_thread *mthread; ! 199: struct macro *m; ! 200: ! 201: if ((mthread = mac_stack) == 0) ! 202: return -1; ! 203: m = mthread->mt_mp; ! 204: if (mthread->mt_offset == m->m_len) { ! 205: mthread->mt_offset = 0; ! 206: if (--mthread->mt_count == 0) ! 207: pop_macro_stack(); ! 208: return mac_getc(); ! 209: } ! 210: return m->m_body[mthread->mt_offset++]; ! 211: } ! 212: ! 213: void ! 214: NameMac() ! 215: { ! 216: char *name; ! 217: struct macro *m; ! 218: ! 219: if (KeyMacro.m_len == 0) ! 220: complain("[No keyboard macro to name!]"); ! 221: if (in_macro() || InMacDefine) ! 222: complain("[Can't name while defining/executing]"); ! 223: if ((m = mac_exists(name = ask((char *) 0, ProcFmt))) == 0) ! 224: m = (struct macro *) emalloc(sizeof *m); ! 225: else { ! 226: if (strcmp(name, KeyMacro.Name) == 0) ! 227: complain("[Can't name it that!]"); ! 228: free(m->Name); ! 229: free(m->m_body); ! 230: } ! 231: name = copystr(name); ! 232: m->Type = KeyMacro.Type; ! 233: m->m_len = KeyMacro.m_len; ! 234: m->m_buflen = KeyMacro.m_buflen; ! 235: m->m_body = emalloc(m->m_buflen); ! 236: byte_copy(KeyMacro.m_body, m->m_body, m->m_len); ! 237: m->m_flags = SAVE; ! 238: m->Name = name; ! 239: add_mac(m); ! 240: } ! 241: ! 242: void ! 243: RunMacro() ! 244: { ! 245: struct macro *m; ! 246: ! 247: if (m = (struct macro *) findmac(ProcFmt)) ! 248: do_macro(m); ! 249: } ! 250: ! 251: void ! 252: pr_putc(c, fp) ! 253: File *fp; ! 254: { ! 255: if (c == '\\' || c == '^') ! 256: putc('\\', fp); ! 257: else if (isctrl(c)) { ! 258: putc('^', fp); ! 259: c = (c == RUBOUT) ? '?' : (c + '@'); ! 260: } ! 261: putc(c, fp); ! 262: } ! 263: ! 264: void ! 265: WriteMacs() ! 266: { ! 267: struct macro *m; ! 268: char *file, ! 269: filebuf[FILESIZE]; ! 270: File *fp; ! 271: int i; ! 272: ! 273: file = ask_file((char *) 0, (char *) 0, filebuf); ! 274: fp = open_file(file, iobuff, F_WRITE, COMPLAIN, QUIET); ! 275: ! 276: /* Don't write the keyboard macro which is always the first */ ! 277: for (m = macros->m_nextm; m != 0; m = m->m_nextm) { ! 278: fprintf(fp, "define-macro %s ", m->Name); ! 279: for (i = 0; i < m->m_len; i++) ! 280: pr_putc(m->m_body[i], fp); ! 281: putc('\n', fp); ! 282: m->m_flags &= ~SAVE; ! 283: } ! 284: close_file(fp); ! 285: } ! 286: ! 287: void ! 288: DefKBDMac() ! 289: { ! 290: char *macro_name, ! 291: *macro_body, ! 292: nextc, ! 293: c, ! 294: macro_buffer[LBSIZE]; ! 295: int i; ! 296: struct macro *m; ! 297: ! 298: macro_name = do_ask(" \r\n", (int (*)()) 0, (char *) 0, ProcFmt); ! 299: if (macro_name == 0) ! 300: complain("[No default]"); ! 301: macro_name = copystr(macro_name); ! 302: if (m = mac_exists(macro_name)) ! 303: del_mac(m); ! 304: macro_body = ask((char *) 0, ": %f %s enter body: ", macro_name); ! 305: i = 0; ! 306: while ((c = *macro_body++) != '\0') { ! 307: if (c == '\\') { ! 308: if ((nextc = *macro_body++) == LF) ! 309: complain("[Premature end of line]"); ! 310: c = nextc; ! 311: } else if (c == '^') { ! 312: if ((nextc = *macro_body++) == '?') ! 313: c = RUBOUT; ! 314: else if (isalpha(nextc) || index("@[\\]^_", nextc)) ! 315: c = CTL(nextc); ! 316: else ! 317: complain("Bad control-character: '%c'", nextc); ! 318: } ! 319: macro_buffer[i++] = c; ! 320: } ! 321: m = (struct macro *) emalloc(sizeof (*m)); ! 322: m->Name = macro_name; ! 323: m->m_len = m->m_buflen = i; ! 324: m->m_body = emalloc(i); ! 325: m->m_flags = InJoverc ? 0 : SAVE; ! 326: byte_copy(macro_buffer, m->m_body, i); ! 327: add_mac(m); ! 328: } ! 329: ! 330: void ! 331: Remember() ! 332: { ! 333: /* We're already executing the macro; ignore any attempts ! 334: to define the keyboard macro while we are executing. */ ! 335: if (in_macro()) ! 336: return; ! 337: if (InMacDefine) ! 338: message("[Already defining ... continue with definition]"); ! 339: else { ! 340: UpdModLine = YES; ! 341: InMacDefine = YES; ! 342: KeyMacro.m_len = 0; ! 343: message("Defining..."); ! 344: } ! 345: } ! 346: ! 347: /* Is `c' a prefix character */ ! 348: ! 349: private int ! 350: PrefChar(c) ! 351: { ! 352: return (int) IsPrefix(mainmap[c]); ! 353: } ! 354: ! 355: void ! 356: Forget() ! 357: { ! 358: char *cp; ! 359: struct macro *m = &KeyMacro; ! 360: ! 361: UpdModLine = YES; ! 362: if (InMacDefine) { ! 363: message("Keyboard macro defined."); ! 364: InMacDefine = NO; ! 365: ! 366: /* try and strip off the key sequence that invoked us */ ! 367: cp = &m->m_body[m->m_len - 2]; ! 368: if (PrefChar(*cp)) ! 369: m->m_len -= 2; ! 370: else if (commands[cp[1]].c_proc == Forget) ! 371: m->m_len -= 1; ! 372: } else ! 373: complain("[end-kbd-macro: not currently defining macro!]"); ! 374: } ! 375: ! 376: void ! 377: ExecMacro() ! 378: { ! 379: do_macro(&KeyMacro); ! 380: } ! 381: ! 382: void ! 383: MacInter() ! 384: { ! 385: extern int Interactive; ! 386: ! 387: if (!Asking) ! 388: return; ! 389: Interactive = 1; ! 390: } ! 391: ! 392: int ! 393: ModMacs() ! 394: { ! 395: register struct macro *m; ! 396: ! 397: for (m = macros->m_nextm; m != 0; m = m->m_nextm) ! 398: if (m->m_flags & SAVE) ! 399: return YES; ! 400: return NO; ! 401: } ! 402: ! 403: data_obj * ! 404: findmac(prompt) ! 405: char *prompt; ! 406: { ! 407: char *strings[100]; ! 408: register char **strs = strings; ! 409: register int com; ! 410: register struct macro *m = macros; ! 411: ! 412: for (; m != 0; m = m->m_nextm) ! 413: *strs++ = m->Name; ! 414: *strs = 0; ! 415: ! 416: if ((com = complete(strings, prompt, NOTHING)) < 0) ! 417: return 0; ! 418: m = macros; ! 419: while (--com >= 0) ! 420: m = m->m_nextm; ! 421: return (data_obj *) m; ! 422: } ! 423: ! 424: void ! 425: DelMacro() ! 426: { ! 427: struct macro *m; ! 428: ! 429: if ((m = (struct macro *) findmac(ProcFmt)) == 0) ! 430: return; ! 431: if (m == &KeyMacro) ! 432: complain("[It's illegal to delete the keyboard-macro!]"); ! 433: del_mac(m); ! 434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.