home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Spezial / SPEZIAL2_97.zip / SPEZIAL2_97.iso / ANWEND / EDITOR / NVI179B / NVI179B.ZIP / tcl_api / tcl.c
C/C++ Source or Header  |  1996-10-16  |  18KB  |  853 lines
  1. /*-
  2.  * Copyright (c) 1992, 1993, 1994
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  * Copyright (c) 1992, 1993, 1994, 1995
  5.  *    Keith Bostic.  All rights reserved.
  6.  * Copyright (c) 1995
  7.  *    George V. Neville-Neil. All rights reserved.
  8.  *
  9.  * See the LICENSE file for redistribution information.
  10.  */
  11.  
  12. #include "config.h"
  13.  
  14. #ifndef lint
  15. static const char sccsid[] = "@(#)tcl.c    8.16 (Berkeley) 10/16/96";
  16. #endif /* not lint */
  17.  
  18. #include <sys/types.h>
  19. #include <sys/queue.h>
  20. #include <sys/time.h>
  21.  
  22. #include <bitstring.h>
  23. #include <errno.h>
  24. #include <limits.h>
  25. #include <signal.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <tcl.h>
  30. #include <termios.h>
  31. #include <unistd.h>
  32.  
  33. #include "../common/common.h"
  34. #include "tcl_extern.h"
  35.  
  36. static int  getint __P((Tcl_Interp *, char *, char *, int *));
  37. static int  getscreenid __P((Tcl_Interp *, SCR **, char *, char *));
  38. static void msghandler __P((SCR *, mtype_t, char *, size_t));
  39.  
  40. extern GS *__global_list;            /* XXX */
  41.  
  42. /*
  43.  * INITMESSAGE --
  44.  *    Macros to point messages at the Tcl message handler.
  45.  */
  46. #define    INITMESSAGE                            \
  47.     scr_msg = __global_list->scr_msg;                \
  48.     __global_list->scr_msg = msghandler;
  49. #define    ENDMESSAGE                            \
  50.     __global_list->scr_msg = scr_msg;
  51.  
  52. /*
  53.  * tcl_fscreen --
  54.  *    Return the screen id associated with file name.
  55.  *
  56.  * Tcl Command: viFindScreen
  57.  * Usage: viFindScreen file
  58.  */
  59. static int
  60. tcl_fscreen(clientData, interp, argc, argv)
  61.     ClientData clientData;
  62.     Tcl_Interp *interp;
  63.     int argc;
  64.     char **argv;
  65. {
  66.     SCR *sp;
  67.  
  68.     if (argc != 2) {
  69.         Tcl_SetResult(interp, "Usage: viFindScreen file", TCL_STATIC);
  70.         return (TCL_ERROR);
  71.     }
  72.  
  73.     if (getscreenid(interp, &sp, NULL, argv[1]))
  74.         return (TCL_ERROR);
  75.  
  76.     (void)sprintf(interp->result, "%d", sp->id);
  77.     return (TCL_OK);
  78. }
  79.  
  80. /*
  81.  * tcl_aline --
  82.  *    -- Append the string text after the line in lineNumber.
  83.  *
  84.  * Tcl Command: viAppendLine
  85.  * Usage: viAppendLine screenId lineNumber text
  86.  */
  87. static int
  88. tcl_aline(clientData, interp, argc, argv)
  89.     ClientData clientData;
  90.     Tcl_Interp *interp;
  91.     int argc;
  92.     char **argv;
  93. {
  94.     SCR *sp;
  95.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  96.     int lno, rval;
  97.  
  98.     if (argc != 4) {
  99.         Tcl_SetResult(interp,
  100.             "Usage: viAppendLine screenId lineNumber text", TCL_STATIC);
  101.         return (TCL_ERROR);
  102.     }
  103.  
  104.     if (getscreenid(interp, &sp, argv[1], NULL) ||
  105.         getint(interp, "line number", argv[2], &lno))
  106.         return (TCL_ERROR);
  107.     INITMESSAGE;
  108.     rval = api_aline(sp, (recno_t)lno, argv[3], strlen(argv[3]));
  109.     ENDMESSAGE;
  110.  
  111.     return (rval ? TCL_ERROR : TCL_OK);
  112. }
  113.  
  114. /*
  115.  * tcl_dline --
  116.  *    Delete lineNum.
  117.  *
  118.  * Tcl Command: viDelLine
  119.  * Usage: viDelLine screenId lineNum
  120.  */
  121. static int
  122. tcl_dline(clientData, interp, argc, argv)
  123.     ClientData clientData;
  124.     Tcl_Interp *interp;
  125.     int argc;
  126.     char **argv;
  127. {
  128.     SCR *sp;
  129.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  130.     int lno, rval;
  131.  
  132.     if (argc != 3) {
  133.         Tcl_SetResult(interp,
  134.             "Usage: viDelLine screenId lineNumber", TCL_STATIC);
  135.         return (TCL_ERROR);
  136.     }
  137.  
  138.     if (getscreenid(interp, &sp, argv[1], NULL) ||
  139.         getint(interp, "line number", argv[2], &lno))
  140.         return (TCL_ERROR);
  141.     INITMESSAGE;
  142.     rval = api_dline(sp, (recno_t)lno);
  143.     ENDMESSAGE;
  144.  
  145.     return (rval ? TCL_ERROR : TCL_OK);
  146. }
  147.  
  148. /*
  149.  * tcl_gline --
  150.  *    Return lineNumber.
  151.  *
  152.  * Tcl Command: viGetLine
  153.  * Usage: viGetLine screenId lineNumber
  154.  */
  155. static int
  156. tcl_gline(clientData, interp, argc, argv)
  157.     ClientData clientData;
  158.     Tcl_Interp *interp;
  159.     int argc;
  160.     char **argv;
  161. {
  162.     SCR *sp;
  163.     size_t len;
  164.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  165.     int lno, rval;
  166.     char *line, *p;
  167.  
  168.     if (argc != 3) {
  169.         Tcl_SetResult(interp,
  170.             "Usage: viGetLine screenId lineNumber", TCL_STATIC);
  171.         return (TCL_ERROR);
  172.     }
  173.     if (getscreenid(interp, &sp, argv[1], NULL) ||
  174.         getint(interp, "line number", argv[2], &lno))
  175.         return (TCL_ERROR);
  176.     INITMESSAGE;
  177.     rval = api_gline(sp, (recno_t)lno, &p, &len);
  178.     ENDMESSAGE;
  179.  
  180.     if (rval)
  181.         return (TCL_ERROR);
  182.  
  183.     if ((line = malloc(len + 1)) == NULL)
  184.         exit(1);                /* XXX */
  185.     memmove(line, p, len);
  186.     line[len] = '\0';
  187.     Tcl_SetResult(interp, line, TCL_DYNAMIC);
  188.     return (TCL_OK);
  189. }
  190.  
  191. /*
  192.  * tcl_iline --
  193.  *    Insert the string text after the line in lineNumber.
  194.  *
  195.  * Tcl Command: viInsertLine
  196.  * Usage: viInsertLine screenId lineNumber text
  197.  */
  198. static int
  199. tcl_iline(clientData, interp, argc, argv)
  200.     ClientData clientData;
  201.     Tcl_Interp *interp;
  202.     int argc;
  203.     char **argv;
  204. {
  205.     SCR *sp;
  206.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  207.     int lno, rval;
  208.  
  209.     if (argc != 4) {
  210.         Tcl_SetResult(interp,
  211.             "Usage: viInsertLine screenId lineNumber text", TCL_STATIC);
  212.         return (TCL_ERROR);
  213.     }
  214.  
  215.     if (getscreenid(interp, &sp, argv[1], NULL) ||
  216.         getint(interp, "line number", argv[2], &lno))
  217.         return (TCL_ERROR);
  218.     INITMESSAGE;
  219.     rval = api_iline(sp, (recno_t)lno, argv[3], strlen(argv[3]));
  220.     ENDMESSAGE;
  221.  
  222.     return (rval ? TCL_ERROR : TCL_OK);
  223. }
  224.  
  225. /*
  226.  * tcl_lline --
  227.  *    Return the last line in the screen.
  228.  *
  229.  * Tcl Command: viLastLine
  230.  * Usage: viLastLine screenId
  231.  */
  232. static int
  233. tcl_lline(clientData, interp, argc, argv)
  234.     ClientData clientData;
  235.     Tcl_Interp *interp;
  236.     int argc;
  237.     char **argv;
  238. {
  239.     SCR *sp;
  240.     recno_t last;
  241.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  242.     int rval;
  243.  
  244.     if (argc != 2) {
  245.         Tcl_SetResult(interp, "Usage: viLastLine screenId", TCL_STATIC);
  246.         return (TCL_ERROR);
  247.     }
  248.  
  249.     if (getscreenid(interp, &sp, argv[1], NULL))
  250.         return (TCL_ERROR);
  251.     INITMESSAGE;
  252.     rval = api_lline(sp, &last);
  253.     ENDMESSAGE;
  254.     if (rval)
  255.         return (TCL_ERROR);
  256.  
  257.     (void)sprintf(interp->result, "%lu", (unsigned long)last);
  258.     return (TCL_OK);
  259. }
  260.  
  261. /*
  262.  * tcl_sline --
  263.  *    Set lineNumber to the text supplied.
  264.  *
  265.  * Tcl Command: viSetLine
  266.  * Usage: viSetLine screenId lineNumber text
  267.  */
  268. static int
  269. tcl_sline(clientData, interp, argc, argv)
  270.     ClientData clientData;
  271.     Tcl_Interp *interp;
  272.     int argc;
  273.     char **argv;
  274. {
  275.     SCR *sp;
  276.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  277.     int lno, rval;
  278.  
  279.     if (argc != 4) {
  280.         Tcl_SetResult(interp,
  281.             "Usage: viSetLine screenId lineNumber text", TCL_STATIC);
  282.         return (TCL_ERROR);
  283.     }
  284.  
  285.     if (getscreenid(interp, &sp, argv[1], NULL) ||
  286.         getint(interp, "line number", argv[2], &lno))
  287.         return (TCL_ERROR);
  288.     INITMESSAGE;
  289.     rval = api_sline(sp, (recno_t)lno, argv[3], strlen(argv[3]));
  290.     ENDMESSAGE;
  291.  
  292.     return (rval ? TCL_ERROR : TCL_OK);
  293. }
  294.  
  295. /*
  296.  * tcl_getmark --
  297.  *    Return the mark's cursor position as a list with two elements.
  298.  *    {line, column}.
  299.  *
  300.  * Tcl Command: viGetMark
  301.  * Usage: viGetMark screenId mark
  302.  */
  303. static int
  304. tcl_getmark(clientData, interp, argc, argv)
  305.     ClientData clientData;
  306.     Tcl_Interp *interp;
  307.     int argc;
  308.     char **argv;
  309. {
  310.     MARK cursor;
  311.     SCR *sp;
  312.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  313.     int rval;
  314.     char buf[20];
  315.  
  316.     if (argc != 3) {
  317.         Tcl_SetResult(interp,
  318.             "Usage: viGetMark screenId mark", TCL_STATIC);
  319.         return (TCL_ERROR);
  320.     }
  321.  
  322.     if (getscreenid(interp, &sp, argv[1], NULL))
  323.         return (TCL_ERROR);
  324.     INITMESSAGE;
  325.     rval = api_getmark(sp, (int)argv[2][0], &cursor);
  326.     ENDMESSAGE;
  327.  
  328.     if (rval)
  329.         return (TCL_ERROR);
  330.  
  331.     (void)snprintf(buf, sizeof(buf), "%lu", (u_long)cursor.lno);
  332.     Tcl_AppendElement(interp, buf);
  333.     (void)snprintf(buf, sizeof(buf), "%lu", (u_long)cursor.cno);
  334.     Tcl_AppendElement(interp, buf);
  335.     return (TCL_OK);
  336. }
  337.  
  338. /*
  339.  * tcl_setmark --
  340.  *    Set the mark to the line and column numbers supplied.
  341.  *
  342.  * Tcl Command: viSetMark
  343.  * Usage: viSetMark screenId mark line column
  344.  */
  345. static int
  346. tcl_setmark(clientData, interp, argc, argv)
  347.     ClientData clientData;
  348.     Tcl_Interp *interp;
  349.     int argc;
  350.     char **argv;
  351. {
  352.     MARK cursor;
  353.     SCR *sp;
  354.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  355.     int i, rval;
  356.  
  357.     if (argc != 5) {
  358.         Tcl_SetResult(interp,
  359.             "Usage: viSetMark screenId mark line column", TCL_STATIC);
  360.         return (TCL_ERROR);
  361.     }
  362.  
  363.     if (getscreenid(interp, &sp, argv[1], NULL))
  364.         return (TCL_ERROR);
  365.     if (getint(interp, "line number", argv[3], &i))
  366.         return (TCL_ERROR);
  367.     cursor.lno = i;
  368.     if (getint(interp, "column number", argv[4], &i))
  369.         return (TCL_ERROR);
  370.     cursor.cno = i;
  371.     INITMESSAGE;
  372.     rval = api_setmark(sp, (int)argv[2][0], &cursor);
  373.     ENDMESSAGE;
  374.  
  375.     return (rval ? TCL_ERROR : TCL_OK);
  376. }
  377.  
  378. /*
  379.  * tcl_getcursor --
  380.  *    Return the current cursor position as a list with two elements.
  381.  *    {line, column}.
  382.  *
  383.  * Tcl Command: viGetCursor
  384.  * Usage: viGetCursor screenId
  385.  */
  386. static int
  387. tcl_getcursor(clientData, interp, argc, argv)
  388.     ClientData clientData;
  389.     Tcl_Interp *interp;
  390.     int argc;
  391.     char **argv;
  392. {
  393.     MARK cursor;
  394.     SCR *sp;
  395.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  396.     int rval;
  397.     char buf[20];
  398.  
  399.     if (argc != 2) {
  400.         Tcl_SetResult(interp,
  401.             "Usage: viGetCursor screenId", TCL_STATIC);
  402.         return (TCL_ERROR);
  403.     }
  404.  
  405.     if (getscreenid(interp, &sp, argv[1], NULL))
  406.         return (TCL_ERROR);
  407.     INITMESSAGE;
  408.     rval = api_getcursor(sp, &cursor);
  409.     ENDMESSAGE;
  410.  
  411.     if (rval)
  412.         return (TCL_ERROR);
  413.  
  414.     (void)snprintf(buf, sizeof(buf), "%lu", (u_long)cursor.lno);
  415.     Tcl_AppendElement(interp, buf);
  416.     (void)snprintf(buf, sizeof(buf), "%lu", (u_long)cursor.cno);
  417.     Tcl_AppendElement(interp, buf);
  418.     return (TCL_OK);
  419. }
  420.  
  421. /*
  422.  * tcl_setcursor --
  423.  *    Set the cursor to the line and column numbers supplied.
  424.  *
  425.  * Tcl Command: viSetCursor
  426.  * Usage: viSetCursor screenId line column
  427.  */
  428. static int
  429. tcl_setcursor(clientData, interp, argc, argv)
  430.     ClientData clientData;
  431.     Tcl_Interp *interp;
  432.     int argc;
  433.     char **argv;
  434. {
  435.     MARK cursor;
  436.     SCR *sp;
  437.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  438.     int i, rval;
  439.  
  440.     if (argc != 4) {
  441.         Tcl_SetResult(interp,
  442.             "Usage: viSetCursor screenId line column", TCL_STATIC);
  443.         return (TCL_ERROR);
  444.     }
  445.  
  446.     if (getscreenid(interp, &sp, argv[1], NULL))
  447.         return (TCL_ERROR);
  448.     if (getint(interp, "screen id", argv[2], &i))
  449.         return (TCL_ERROR);
  450.     cursor.lno = i;
  451.     if (getint(interp, "screen id", argv[3], &i))
  452.         return (TCL_ERROR);
  453.     cursor.cno = i;
  454.     INITMESSAGE;
  455.     rval = api_setcursor(sp, &cursor);
  456.     ENDMESSAGE;
  457.  
  458.     return (rval ? TCL_ERROR : TCL_OK);
  459. }
  460.  
  461. /*
  462.  * tcl_msg --
  463.  *    Set the message line to text.
  464.  *
  465.  * Tcl Command: viMsg
  466.  * Usage: viMsg screenId text
  467.  */
  468. static int
  469. tcl_msg(clientData, interp, argc, argv)
  470.     ClientData clientData;
  471.     Tcl_Interp *interp;
  472.     int argc;
  473.     char **argv;
  474. {
  475.     SCR *sp;
  476.  
  477.     if (argc != 3) {
  478.         Tcl_SetResult(interp, "Usage: viMsg screenId text", TCL_STATIC);
  479.         return (TCL_ERROR);
  480.     }
  481.  
  482.     if (getscreenid(interp, &sp, argv[1], NULL))
  483.         return (TCL_ERROR);
  484.     api_imessage(sp, argv[2]);
  485.  
  486.     return (TCL_OK);
  487. }
  488.  
  489. /*
  490.  * tcl_iscreen --
  491.  *    Create a new screen.  If a filename is specified then the screen
  492.  *    is opened with that file.
  493.  *
  494.  * Tcl Command: viNewScreen
  495.  * Usage: viNewScreen screenId [file]
  496.  */
  497. static int
  498. tcl_iscreen(clientData, interp, argc, argv)
  499.     ClientData clientData;
  500.     Tcl_Interp *interp;
  501.     int argc;
  502.     char **argv;
  503. {
  504.     SCR *sp, *nsp;
  505.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  506.     int rval;
  507.  
  508.     if (argc != 2 && argc != 3) {
  509.         Tcl_SetResult(interp,
  510.             "Usage: viNewScreen screenId [file]", TCL_STATIC);
  511.         return (TCL_ERROR);
  512.     }
  513.  
  514.     if (getscreenid(interp, &sp, argv[1], NULL))
  515.         return (TCL_ERROR);
  516.     INITMESSAGE;
  517.     rval = api_edit(sp, argv[2], &nsp, 1);
  518.     ENDMESSAGE;
  519.  
  520.     if (rval)
  521.         return (TCL_ERROR);
  522.  
  523.     (void)sprintf(interp->result, "%d", nsp->id);
  524.     return (TCL_OK);
  525. }
  526.  
  527. /*
  528.  * tcl_escreen --
  529.  *    End a screen.
  530.  *
  531.  * Tcl Command: viEndScreen
  532.  * Usage: viEndScreen screenId
  533.  */
  534. static int
  535. tcl_escreen(clientData, interp, argc, argv)
  536.     ClientData clientData;
  537.     Tcl_Interp *interp;
  538.     int argc;
  539.     char **argv;
  540. {
  541.     SCR *sp;
  542.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  543.     int rval;
  544.  
  545.     if (argc != 2) {
  546.         Tcl_SetResult(interp,
  547.              "Usage: viEndScreen screenId", TCL_STATIC);
  548.         return (TCL_ERROR);
  549.     }
  550.  
  551.     if (getscreenid(interp, &sp, argv[1], NULL))
  552.         return (TCL_ERROR);
  553.     INITMESSAGE;
  554.     rval = api_escreen(sp);
  555.     ENDMESSAGE;
  556.  
  557.     return (rval ? TCL_ERROR : TCL_OK);
  558. }
  559.  
  560. /*
  561.  * tcl_swscreen --
  562.  *    Change the current focus to screen.
  563.  *
  564.  * Tcl Command: viSwitchScreen
  565.  * Usage: viSwitchScreen screenId screenId
  566.  */
  567. static int
  568. tcl_swscreen(clientData, interp, argc, argv)
  569.     ClientData clientData;
  570.     Tcl_Interp *interp;
  571.     int argc;
  572.     char **argv;
  573. {
  574.     SCR *sp, *new;
  575.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  576.     int rval;
  577.  
  578.     if (argc != 3) {
  579.         Tcl_SetResult(interp,
  580.             "Usage: viSwitchScreen cur_screenId new_screenId",
  581.             TCL_STATIC);
  582.         return (TCL_ERROR);
  583.     }
  584.  
  585.     if (getscreenid(interp, &sp, argv[1], NULL))
  586.         return (TCL_ERROR);
  587.     if (getscreenid(interp, &new, argv[2], NULL))
  588.         return (TCL_ERROR);
  589.     INITMESSAGE;
  590.     rval = api_swscreen(sp, new);
  591.     ENDMESSAGE;
  592.  
  593.     return (rval ? TCL_ERROR : TCL_OK);
  594. }
  595.  
  596. /*
  597.  * tcl_map --
  598.  *    Associate a key with a tcl procedure.
  599.  *
  600.  * Tcl Command: viMapKey
  601.  * Usage: viMapKey screenId key tclproc
  602.  */
  603. static int
  604. tcl_map(clientData, interp, argc, argv)
  605.     ClientData clientData;
  606.     Tcl_Interp *interp;
  607.     int argc;
  608.     char **argv;
  609. {
  610.     SCR *sp;
  611.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  612.     int rval;
  613.     char command[256];
  614.  
  615.     if (argc != 4) {
  616.         Tcl_SetResult(interp,
  617.             "Usage: viMapKey screenId key tclproc", TCL_STATIC);
  618.         return (TCL_ERROR);
  619.     }
  620.  
  621.     if (getscreenid(interp, &sp, argv[1], NULL))
  622.         return (TCL_ERROR);
  623.     INITMESSAGE;
  624.     (void)snprintf(command, sizeof(command), ":tcl %s\n", argv[3]);
  625.     rval = api_map(sp, argv[2], command, strlen(command));
  626.     ENDMESSAGE;
  627.  
  628.     return (rval ? TCL_ERROR : TCL_OK);
  629. }
  630.  
  631. /*
  632.  * tcl_unmap --
  633.  *    Unmap a key.
  634.  *
  635.  * Tcl Command: viUnmapKey
  636.  * Usage: viUnmMapKey screenId key
  637.  */
  638. static int
  639. tcl_unmap(clientData, interp, argc, argv)
  640.     ClientData clientData;
  641.     Tcl_Interp *interp;
  642.     int argc;
  643.     char **argv;
  644. {
  645.     SCR *sp;
  646.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  647.     int rval;
  648.  
  649.     if (argc != 3) {
  650.         Tcl_SetResult(interp,
  651.             "Usage: viUnmapKey screenId key", TCL_STATIC);
  652.         return (TCL_ERROR);
  653.     }
  654.  
  655.     if (getscreenid(interp, &sp, argv[1], NULL))
  656.         return (TCL_ERROR);
  657.     INITMESSAGE;
  658.     rval = api_unmap(sp, argv[2]);
  659.     ENDMESSAGE;
  660.  
  661.     return (rval ? TCL_ERROR : TCL_OK);
  662. }
  663.  
  664. /*
  665.  * tcl_opts_set --
  666.  *    Set an option.
  667.  *
  668.  * Tcl Command: viSetOpt
  669.  * Usage: viSetOpt screenId command
  670.  */
  671. static int
  672. tcl_opts_set(clientData, interp, argc, argv)
  673.     ClientData clientData;
  674.     Tcl_Interp *interp;
  675.     int argc;
  676.     char **argv;
  677. {
  678.     SCR *sp;
  679.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  680.     int rval;
  681.     char *setting;
  682.  
  683.     if (argc != 3) {
  684.         Tcl_SetResult(interp,
  685.             "Usage: viSetOpt screenId command", TCL_STATIC);
  686.         return (TCL_ERROR);
  687.     }
  688.  
  689.     if (getscreenid(interp, &sp, argv[1], NULL))
  690.         return (TCL_ERROR);
  691.     INITMESSAGE;
  692.     /*rval = api_opts_set(sp, argv[2]);*/
  693.     MALLOC(sp, setting, char *, strlen(argv[2])+6);
  694.     strcpy(setting, ":set ");
  695.     strcpy(setting+5, argv[2]);
  696.     rval=api_run_str(sp, setting);
  697.     free(setting);
  698.     ENDMESSAGE;
  699.  
  700.     return (rval ? TCL_ERROR : TCL_OK);
  701. }
  702.  
  703. /*
  704.  * tcl_opts_get --
  705.      Return the value of an option.
  706.  *    
  707.  * Tcl Command: viGetOpt
  708.  * Usage: viGetOpt screenId option
  709.  */
  710. static int
  711. tcl_opts_get(clientData, interp, argc, argv)
  712.     ClientData clientData;
  713.     Tcl_Interp *interp;
  714.     int argc;
  715.     char **argv;
  716. {
  717.     SCR *sp;
  718.     void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
  719.     int rval;
  720.     char *value;
  721.  
  722.     if (argc != 3) {
  723.         Tcl_SetResult(interp,
  724.             "Usage: viGetOpt screenId option", TCL_STATIC);
  725.         return (TCL_ERROR);
  726.     }
  727.  
  728.     if (getscreenid(interp, &sp, argv[1], NULL))
  729.         return (TCL_ERROR);
  730.     INITMESSAGE;
  731.     rval = api_opts_get(sp, argv[2], &value, NULL);
  732.     ENDMESSAGE;
  733.     if (rval)
  734.         return (TCL_ERROR);
  735.  
  736.     Tcl_SetResult(interp, value, TCL_DYNAMIC);
  737.     return (TCL_OK);
  738. }
  739.  
  740. /*
  741.  * tcl_init --
  742.  *    Create the TCL commands used by nvi.
  743.  *
  744.  * PUBLIC: int tcl_init __P((GS *));
  745.  */
  746. int
  747. tcl_init(gp)
  748.     GS *gp;
  749. {
  750.     gp->tcl_interp = Tcl_CreateInterp();
  751.     if (Tcl_Init(gp->tcl_interp) == TCL_ERROR)
  752.         return (1);
  753.  
  754. #define    TCC(name, function) {                        \
  755.     Tcl_CreateCommand(gp->tcl_interp, name, function,        \
  756.         (ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);        \
  757. }
  758.     TCC("viAppendLine", tcl_aline);
  759.     TCC("viDelLine", tcl_dline);
  760.     TCC("viEndScreen", tcl_escreen);
  761.     TCC("viFindScreen", tcl_fscreen);
  762.     TCC("viGetCursor", tcl_getcursor);
  763.     TCC("viGetLine", tcl_gline);
  764.     TCC("viGetMark", tcl_getmark);
  765.     TCC("viGetOpt", tcl_opts_get);
  766.     TCC("viInsertLine", tcl_iline);
  767.     TCC("viLastLine", tcl_lline);
  768.     TCC("viMapKey", tcl_map);
  769.     TCC("viMsg", tcl_msg);
  770.     TCC("viNewScreen", tcl_iscreen);
  771.     TCC("viSetCursor", tcl_setcursor);
  772.     TCC("viSetLine", tcl_sline);
  773.     TCC("viSetMark", tcl_setmark);
  774.     TCC("viSetOpt", tcl_opts_set);
  775.     TCC("viSwitchScreen", tcl_swscreen);
  776.     TCC("viUnmapKey", tcl_unmap);
  777.  
  778.     return (0);
  779. }
  780.  
  781. /*
  782.  * getscreenid --
  783.  *    Get the specified screen pointer.
  784.  *
  785.  * XXX
  786.  * This is fatal.  We can't post a message into vi that we're unable to find
  787.  * the screen without first finding the screen... So, this must be the first
  788.  * thing a Tcl routine does, and, if it fails, the last as well.
  789.  */
  790. static int 
  791. getscreenid(interp, spp, id, name)
  792.     Tcl_Interp *interp;
  793.     SCR **spp;
  794.     char *id, *name;
  795. {
  796.     int scr_no;
  797.     char buf[64];
  798.  
  799.     if (id != NULL && getint(interp, "screen id", id, &scr_no))
  800.         return (1);
  801.     if ((*spp = api_fscreen(scr_no, name)) == NULL) {
  802.         (void)snprintf(buf, sizeof(buf),
  803.             "unknown screen id: %s", name == NULL ? id : name);
  804.         Tcl_SetResult(interp, buf, TCL_VOLATILE);
  805.         return (1);
  806.     }
  807.     return (0);
  808. }
  809.  
  810. /*
  811.  * getint --
  812.  *    Get a Tcl integer.
  813.  *
  814.  * XXX
  815.  * This code assumes that both recno_t and size_t are larger than ints.
  816.  */
  817. static int
  818. getint(interp, msg, s, intp)
  819.     Tcl_Interp *interp;
  820.     char *msg, *s;
  821.     int *intp;
  822. {
  823.     char buf[64];
  824.  
  825.     if (Tcl_GetInt(interp, s, intp) == TCL_ERROR)
  826.         return (1);
  827.     if (*intp < 0) {
  828.         (void)snprintf(buf, sizeof(buf),
  829.             "illegal %s %s: may not be negative", msg, s);
  830.         Tcl_SetResult(interp, buf, TCL_VOLATILE);
  831.         return (1);
  832.     }
  833.     return (0);
  834. }
  835.  
  836. /*
  837.  * msghandler --
  838.  *    Tcl message routine so that error messages are processed in
  839.  *    Tcl, not in nvi.
  840.  */
  841. static void
  842. msghandler(sp, mtype, msg, len)
  843.     SCR *sp;
  844.     mtype_t mtype;
  845.     char *msg;
  846.     size_t len;
  847. {
  848.     /* Replace the trailing <newline> with an EOS. */
  849.     msg[len - 1] = '\0';
  850.  
  851.     Tcl_SetResult(sp->gp->tcl_interp, msg, TCL_VOLATILE);
  852. }
  853.