home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / XDME / Src / drexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  11.9 KB  |  560 lines
  1. /******************************************************************************
  2.  
  3.     MODUL
  4.     drexx.c
  5.  
  6.     DESCRIPTION
  7.     Another AREXX interface for the XDME. Uses HRexx.c, some tools, I
  8.     wrote for a easier AREXX-usage.
  9.  
  10.     This module implements the same commands as "rexx.c", so it works
  11.     with a minimum of changes in the real XDME sources.
  12.  
  13.     Because I want to implement a, which is ALWAYS calleble from the
  14.     outer world (other tasks), I was forced to made some minor changes
  15.     in main.c (marked with "/ * HD " as comment ). Further I had to add
  16.     an Activate Window to cmd1.c's QUIT command , because it dosen't
  17.     work proper if it was called with a deactivated window.
  18.  
  19.     In addition I added my new commands in the commandtable in
  20.     "command.c"
  21.  
  22.     NOTES
  23.  
  24.     BUGS
  25.  
  26.     TODO
  27.  
  28.     EXAMPLES
  29.  
  30.     SEE ALSO
  31.  
  32.     INDEX
  33.  
  34.     HISTORY
  35.     dirk    26. Dec 1991    created
  36.  
  37. ******************************************************************************/
  38.  
  39. /**************************************
  40.         Includes
  41. **************************************/
  42. #include "defs.h"
  43. #include "hrexx.h"
  44. #include "rexx/storage.h"
  45. #include "rexx/rxslib.h"
  46. #include "rexx/rexxio.h"
  47. #include "rexx/errors.h"
  48. #define  MYDEBUG      0
  49. #include "debug.h"
  50.  
  51.  
  52. /**************************************
  53.         Globale Variable
  54. **************************************/
  55. Prototype ULONG RexxMask;
  56. Prototype int foundcmd; /* control for implicit ARexx macro invocation     */
  57. Prototype int cmderr;    /* global command error flag for do_rexx()'s use */
  58.  
  59. Prototype void     openrexx         (void);
  60. Prototype void     closerexx         (void);
  61. Prototype void     do_rx             (void);
  62. Prototype void     do_rx1          (void);
  63. Prototype void     do_rx2          (void);
  64. Prototype long     do_rxImplied         (char *, char *);
  65. Prototype void     extern_rexx_command (void);
  66. Prototype void     to_port         (void);
  67. Prototype void     select_window         (void);
  68. Prototype void     project_info         (void);
  69. Prototype int     load_project         (void);
  70. Prototype void     save_project         (void);
  71. Prototype void     put_rexx_result     (void);
  72. Prototype char * get_rexx_result     (void);
  73. Prototype long     do_rexx         (const char * port, const char *fmt, ...);
  74.  
  75.  
  76. ULONG RexxMask;     /* ArexxPort signalmask for Wait        */
  77. int   foundcmd;     /* control for implicit ARexx macro invocation    */
  78. int   cmderr;        /* global command error flag for do_rexx's use  */
  79.  
  80. static char rexx_result[256];    /* hier wird das Rexxresult untergerbracht */
  81.  
  82.  
  83. /**************************************
  84.       Interne Defines & Strukturen
  85. **************************************/
  86.  
  87.  
  88. /**************************************
  89.         Interne Variable
  90. **************************************/
  91.  
  92.  
  93. /**************************************
  94.        Interne Prototypes
  95. **************************************/
  96. __stkargs static void in_rexx (struct RexxMsg *);
  97.  
  98.  
  99. /************************************************************************/
  100. /*               lokale  Funktionen                */
  101. /************************************************************************/
  102.  
  103. __stkargs static void in_rexx (struct RexxMsg *rmsg)
  104. /*
  105.  * this function is called with incomming Rexxmessages, while
  106.  * processing SyncRexxCommand
  107.  *
  108.  * --> rmsg    pointer to the RexxMessage
  109.  */
  110. {
  111.    long ret;
  112.    foundcmd = 0;
  113.  
  114.    *rexx_result = 0;
  115.  
  116. //   currentmsg = (MSG*)rmsg;           /* PATCH_RXADD */
  117.  
  118.    ret = !do_command ((char *)ARG0(rmsg));
  119.  
  120. //   currentmsg = NULL;         /* PATCH_RXADD */
  121.  
  122.    if (rexx_result[0])
  123.       ReplyRexxMsg (rmsg, ret, rexx_result);
  124.    else
  125.       ReplyRexxMsg (rmsg, ret, 0);
  126.  
  127.    *rexx_result= 0;
  128.  
  129.    do_command ("null");     /* reset foundcommand */
  130. }
  131.  
  132.  
  133. /************************************************************************/
  134. /*               globale Funktionen                */
  135. /************************************************************************/
  136.  
  137. long do_rexx (const char * port, const char *fmt,...)
  138. /*
  139.  * This command transmittes the command, printf-style, to a named
  140.  * port.
  141.  *
  142.  * --> port    name of port
  143.  * --> fmt    printf-like format string for the command
  144.  * --> ...    the args for the command
  145.  */
  146. {
  147.     va_list va;
  148.     char macro[256];
  149.  
  150.     va_start (va, fmt);
  151.     vsprintf (macro, fmt, va);
  152.     va_end (va);
  153.  
  154.     return (SyncRexxCommand (port, macro, rexx_result, sizeof(rexx_result), 0));
  155. }
  156.  
  157.  
  158. void put_rexx_result (void)
  159. /*
  160.     Copy a string to rexx_result
  161. */
  162. {
  163.     strcpy (rexx_result, av[1]);
  164. }
  165.  
  166.  
  167. char * get_rexx_result (void)
  168. /*
  169.     Get Contents of rexx_result
  170. */
  171. {
  172.     puts (rexx_result);
  173.  
  174.     return (rexx_result);
  175. }
  176.  
  177.  
  178. void openrexx (void)
  179. /* initalizes the Arexx-stuff */
  180. {
  181.    int number;
  182.  
  183.    number = 1;
  184.  
  185.    Forbid ();
  186.  
  187.    do
  188.    {
  189.     sprintf (RexxPortName, "XDME.%d", number ++);
  190.    } while (FindPort (RexxPortName) && number < 1000);
  191.  
  192.    Permit ();
  193.  
  194.    RexxMask = OpenRexx (RexxPortName, "XDME", in_rexx, 0, 0);
  195.  
  196.    if (!RexxMask)
  197.     exiterr ("Cannot open AREXX-Port");
  198. }
  199.  
  200.  
  201. void closerexx (void)
  202. /* shut down the Arexx-stuff */
  203. {
  204.    CloseRexx ();
  205. }
  206.  
  207.  
  208. void  do_rx (void)
  209. /*
  210.  *  explicit invocation interface between do_command() and do_rexx
  211.  *  for ARexx macros having NO arguments (i.e., for the "rx" command)
  212.  */
  213. {
  214.     do_rexx (0,"%s",av[1]);
  215. }
  216.  
  217.  
  218. void do_rx1 (void)
  219. /*
  220.  *  explicit invocation interface between do_command() and do_rexx
  221.  *  for ARexx macros having ONE argument (i.e., for the "rx1" command)
  222.  */
  223. {
  224.     do_rexx (0,"%s %s",av[1],av[2]);
  225. }
  226.  
  227.  
  228. void do_rx2 (void)
  229. /*
  230.  *  explicit invocation interface between do_command() and do_rexx
  231.  *  for ARexx macros having TWO arguments (i.e., for the "rx2" command)
  232.  */
  233. {
  234.     do_rexx (0,"%s %s %s",av[1],av[2],av[3]);
  235. }
  236.  
  237.  
  238. long do_rxImplied (char * cmd,char * args)
  239. /*
  240.  *  implicit invocation interface between do_command() and do_rexx
  241.  *  for ARexx macros implicitly called; arbitrary number of arguments
  242.  */
  243. {
  244.     return (do_rexx (0,"%s %s",cmd,args));
  245. }
  246.  
  247. /***********************************************************************/
  248. /***********           New Commands            *************/
  249. /***********************************************************************/
  250.  
  251. void extern_rexx_command (void)
  252. /*
  253.  * executes a command, comming in from an external port
  254.  */
  255. {
  256.     long         ret;
  257.     struct RexxMsg * rmsg;
  258.  
  259.     *rexx_result = 0;
  260.  
  261. //    if (Debug) printf("extern_rexx_command\n"); /* */
  262.  
  263.     rmsg = GetRexxMsg ();
  264.  
  265. //    currentmsg = (MSG*)rmsg;        /* PATCH_RXADD */
  266.  
  267.     ret = !do_command ((char *)ARG0(rmsg));
  268.  
  269. //    currentmsg = NULL;            /* PATCH_RXADD */
  270.  
  271.     if (rexx_result[0])
  272.     ReplyRexxMsg (rmsg, ret, rexx_result);
  273.     else
  274.     ReplyRexxMsg (rmsg, ret, 0);
  275.  
  276.     *rexx_result = 0;
  277. } /* extern_rexx_command */
  278.  
  279.  
  280. void to_port (void)
  281. /*
  282.  * simply passes a command to another named port
  283.  */
  284. {
  285.     do_rexx (av[1], "%s", av[2]);
  286. } /* to_port */
  287.  
  288.  
  289. void select_window (void)
  290. /*
  291.  * selects another window FIRST LAST NEXT PREVIOUS WINDOW=<NAME> SAVE LOAD
  292.  * every command can be abreviated by its first character:
  293.  *  "select window=cmd1.c" = "select w=cmd1.c"
  294.  */
  295. {
  296.     ED          * ed     = NULL;
  297.     static ED * sto_ed = NULL;
  298.  
  299.     switch (av[1][0])
  300.     {
  301.     case ('l') :
  302.     {
  303.         if (av[1][1] == 'a')
  304.         ed = (ED *)GetTail (&DBase);
  305.         else
  306.         ed = sto_ed;
  307.     break; } /* case ('l') */
  308.  
  309.     case ('f') :
  310.     {
  311.         ed = (ED *)GetHead (&DBase);
  312.     break; } /* case ('f') */
  313.  
  314.     case ('n') :
  315.     {
  316.         ed = (ED *)GetSucc (Ep);
  317.  
  318.         if (ed == NULL && globalflags.Windowcycling)
  319.         {  /* PATCH_NULL */
  320.         ed = (ED *)GetHead (&DBase);    /* PATCH_NULL */
  321.         } /* if */                /* PATCH_NULL */
  322.     break; } /* case ('n') */
  323.  
  324.     case ('p') :
  325.     {
  326.         ed = (ED *)GetPred (Ep);
  327.  
  328.         if (ed == NULL && globalflags.Windowcycling)
  329.         {  /* PATCH_NULL */
  330.         ed = (ED *)GetTail (&DBase);    /* PATCH_NULL */
  331.         } /* if */                /* PATCH_NULL */
  332.     break; } /* case ('p') */
  333.  
  334.     case ('a') :
  335.     {
  336.         ActivateWindow (Ep->win);
  337.  
  338.         if (globalflags.ActivateToFront)
  339.         {           /* PATCH_NULL */
  340.         WindowToFront (Ep->win);        /* PATCH_NULL */
  341.         } /* if */                /* PATCH_NULL */
  342.     break; } /* case ('a') */
  343.  
  344.     case ('s') :
  345.     {
  346.         sto_ed = Ep;
  347.         return;
  348.     break; } /* case ('s') */
  349.  
  350.     case ('w') :
  351.     {
  352.         char * ptr;
  353.  
  354.         ptr = av[1];
  355.  
  356.         while (*ptr && *ptr != '=')
  357.         ptr ++;
  358.  
  359.         if (*ptr)
  360.         ptr ++;
  361.         else
  362.         break;
  363.  
  364.         D(bug("looking for `%s'\n", ptr));
  365.  
  366.         for (ed=(ED *)GetHead(&DBase); ed; ed=(ED *)GetSucc(ed))
  367.         if (!stricmp (ed->name, ptr))   /* found it */
  368.             break;
  369.  
  370.         D(bug("Found %08x\n", ed));
  371.     break; } /* case ('w') */
  372.  
  373.     } /* switch (av[1][0]) */
  374.  
  375.     if (ed)
  376.     {
  377.     switch_ed (ed);
  378.  
  379.     ActivateWindow (ed->win);
  380.  
  381.     if (globalflags.ActivateToFront)
  382.     {           /* PATCH_NULL */
  383.         WindowToFront (ed->win);            /* PATCH_NULL */
  384.     } /* if */                /* PATCH_NULL */
  385.     } else
  386.     {
  387.     globalflags.Abortcommand = 1;
  388.     }
  389. } /* select_window */
  390.  
  391.  
  392. void project_info (void)
  393. /*
  394.  * builds the following string:
  395.  * path <name> <left> <top> <width> <height> <iconleft> <iconright>
  396.  * if Rexx called this string is return as resultstring
  397.  */
  398. {
  399.     char path[PATHSIZE];        /* Puffer für Pfad */
  400.  
  401.     getpathto (Ep->dirlock, NULL, path);
  402.  
  403.     /* Read values from Window-Struct */
  404.     if (Ep->iconmode)
  405.     {
  406.     Ep->config.iwinx     = Ep->win->LeftEdge;
  407.     Ep->config.iwiny     = Ep->win->TopEdge;
  408.     } else
  409.     {
  410.     Ep->config.winx      = Ep->win->LeftEdge;
  411.     Ep->config.winy      = Ep->win->TopEdge;
  412.     Ep->config.winwidth  = Ep->win->Width;
  413.     Ep->config.winheight = Ep->win->Height;
  414.     }
  415.  
  416.     sprintf (rexx_result, "\"%s\" \"%s\" %d %d %d %d %d %d %d",
  417.                path,    Ep->name,
  418.                      Ep->config.winx,
  419.                         Ep->config.winy,
  420.                            Ep->config.winwidth,
  421.                           Ep->config.winheight,
  422.                              Ep->config.iwinx,
  423.                             Ep->config.iwiny,
  424.                                Ep->line
  425.     );
  426. } /* project_info */
  427.  
  428.  
  429. void save_project (void)
  430. /*
  431.  * saves all opened files in the directory of the currently active
  432.  * editor to a file name XDMEArgs.projectfilename.
  433.  * The lines are in the same format as returned from project_info
  434.  */
  435. {
  436.     ED * ed;                /* Currenteditor */
  437.     ED * act_ed;            /* active Editor */
  438.     BPTR old_lock;            /* Active dirlock */
  439.     BPTR file;                /* our PRJ file */
  440.  
  441.     old_lock = CurrentDir (Ep->dirlock); /* change dir */
  442.     act_ed   = Ep;             /* save active Editor */
  443.  
  444.     file = Open (XDMEArgs.projectfilename, MODE_NEWFILE);
  445.  
  446.     if (file)
  447.     {
  448.     Write (file, "# path name x y w h ix iy line\n", 31L);
  449.  
  450.     for (ed=(ED *)GetHead(&DBase); ed; ed=(ED *)GetSucc((struct Node *)ed))
  451.     {
  452.         switch_ed (ed);              /* change current ed */
  453.  
  454.         project_info ();             /* build info text */
  455.  
  456.         Write (file, rexx_result, strlen (rexx_result));
  457.         Write (file, "\n", 1L);
  458.     }
  459.  
  460.     Close (file);
  461.     } /* if (file) */
  462.  
  463.     switch_ed (act_ed);                  /* restore actuall editor */
  464.  
  465.     CurrentDir (old_lock);               /* go back to old dir */
  466. } /* project_save */
  467.  
  468.  
  469. int load_project (void)
  470. {
  471.     FILE * file;
  472.     char   path[PATHSIZE];        /* Puffer für Pfad */
  473.     char   name[60];            /* file name */
  474.     char * ptr;
  475.     long   t, il, it, line;        /* window & icon & line */
  476.  
  477.     file = fopen (XDMEArgs.projectfilename, "r");  /* Open ProjectFile */
  478.  
  479.     if (file)
  480.     {
  481.     while (fgets (tmp_buffer, 256, file))
  482.     {
  483.         if (*tmp_buffer == '#')
  484.         continue;
  485.  
  486.         ptr = skip_whitespace (tmp_buffer);
  487.  
  488.         if (*ptr == '"')
  489.         {
  490.         ptr ++;
  491.  
  492.         for (t=0; *ptr != '"'; )
  493.             path[t ++] = *ptr ++;
  494.  
  495.         ptr ++;
  496.         } else
  497.         for (t=0; !isspace(*ptr); )
  498.             path[t ++] = *ptr ++;
  499.  
  500.         path[t] = 0;
  501.         ptr = skip_whitespace (ptr);
  502.  
  503.         if (*ptr == '"')
  504.         {
  505.         ptr ++;
  506.  
  507.         for (t=0; *ptr != '"'; )
  508.             name[t ++] = *ptr ++;
  509.  
  510.         ptr ++;
  511.         } else
  512.         for (t=0; !isspace(*ptr); )
  513.             name[t ++] = *ptr ++;
  514.  
  515.         name[t] = 0;
  516.  
  517.         av[1] = ptr;
  518.         do_openwindow ();
  519.  
  520.         av[1] = path;
  521.         do_cd ();
  522.  
  523.         av[0] = "newfile";
  524.         av[1] = name;
  525.         do_edit ();
  526.  
  527.         sscanf (ptr, " %d  %d  %d  %d  %d   %d   %d\n",
  528.                &t, &t, &t, &t, &il, &it, &line);
  529.  
  530.         if (line >= Ep->lines)
  531.         line = Ep->lines - 1;
  532.  
  533.         Ep->line = line;
  534.  
  535.         text_load ();
  536.         text_adjust (FALSE);
  537.  
  538.         Ep->config.iwinx = il;
  539.         Ep->config.iwiny = it;
  540.  
  541.         do_iconify ();
  542.     }
  543.  
  544.     fclose (file);
  545.  
  546.     t = TRUE;
  547.     } else
  548.     {
  549.     warn ("projectload: Cannot find file `%s'", XDMEArgs.projectfilename);
  550.     t = FALSE;
  551.     }
  552.  
  553.     return (t);
  554. } /* load_project */
  555.  
  556.  
  557. /******************************************************************************
  558. *****  ENDE drexx.c
  559. ******************************************************************************/
  560.