home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / text / jed / src / jed.lha / minrexx.c < prev    next >
C/C++ Source or Header  |  1993-01-05  |  5KB  |  254 lines
  1.  
  2. /*
  3.  * MINREXX.C
  4.  *
  5.  * By Radical Eye Software, slightly altered by me.
  6.  */
  7.  
  8. static char *blurb = "Radical Eye MinRexx 0.4.jsh";
  9.  
  10. #include "jed.h"
  11. #include "jed_protos.h"
  12.  
  13. Prototype   VALUE *        cmd_rexx    (LONG, VALUE *);
  14. Prototype   LONG        upRexxPort    (STRPTR, STRPTR);
  15. Prototype   VOID        dnRexxPort    (VOID);
  16. Prototype   VOID        dispRexxPort    (VOID);
  17. Local        struct RexxMsg *    sendRexxCmd    (STRPTR, int(*)(), STRPTR, STRPTR, STRPTR, LONG);
  18. Prototype   struct RexxMsg *    syncRexxCmd    (STRPTR, struct RexxMsg *);
  19. Prototype   struct RexxMsg *    asyncRexxCmd    (STRPTR);
  20. Prototype   struct RexxMsg *    asyncRexxString (STRPTR);
  21. Prototype   VOID        replyRexxCmd    (struct RexxMsg *, LONG, LONG, STRPTR);
  22. Local        VOID        closeRexxLib    (VOID);
  23. Local        BOOL        openRexxLib    (VOID);
  24. Local        VOID        replytoit    (struct RexxMsg *);
  25.  
  26. /*
  27.  * (rexx `m' `macroName')
  28.  * (rexx `s' `rexxString')
  29.  */
  30. VALUE *
  31. cmd_rexx(LONG argc, VALUE *argv)
  32. {
  33.     if(TPLATE2(VTF_STRING, VTF_STRING))
  34.     {
  35.     BOOL rc;
  36.     if(*(argv[1].val_Value.String) == 'm')
  37.         rc = (BOOL)asyncRexxCmd(argv[2].val_Value.String);
  38.     else
  39.         rc = (BOOL)asyncRexxString(argv[2].val_Value.String);
  40.     setnumres(rc);
  41.     }
  42.     return(&RES);
  43. }
  44.  
  45. #define MAXRXOUTSTANDING (300)
  46. #define RXERRORIMGONE (100)
  47. #define RXERRORNOCMD (30)
  48.  
  49. Local struct MsgPort *rexxPort;
  50. Local BOOL bringerdown;
  51. Local LONG stillNeedReplies;
  52. Local LONG rexxPortBit;
  53. Local STRPTR extension;
  54. Local struct RexxMsg *oRexxMsg;
  55.  
  56. struct RxsLib *RexxSysBase;
  57.  
  58. /*
  59.  *   This is the main entry point into this code.
  60.  */
  61. LONG
  62. upRexxPort(STRPTR name, STRPTR exten)
  63. {
  64.     if(rexxPort == NULL)
  65.     {
  66.     Forbid();
  67.     if(!(FindPort(name)))
  68.     {
  69.         rexxPort = CreateMsgPort();
  70.         rexxPort->mp_Node.ln_Name = name;
  71.         rexxPort->mp_Node.ln_Pri = 1;
  72.         AddPort(rexxPort);
  73.     }
  74.     Permit();
  75.     if(rexxPort)
  76.         rexxPortBit = 1L << rexxPort->mp_SigBit;
  77.     }
  78.     extension = exten;
  79.     return(rexxPortBit);
  80. }
  81.  
  82. Local VOID
  83. closeRexxLib(VOID)
  84. {
  85.     if((!stillNeedReplies) && RexxSysBase)
  86.     {
  87.     CloseLibrary((struct Library *)RexxSysBase);
  88.     RexxSysBase = NULL;
  89.     }
  90. }
  91.  
  92. VOID
  93. dnRexxPort(VOID)
  94. {
  95.     if(rexxPort)
  96.     {
  97.     RemPort(rexxPort);
  98.     bringerdown = TRUE;
  99.  
  100.     if(oRexxMsg)
  101.     {
  102.         oRexxMsg->rm_Result1 = RXERRORIMGONE;
  103.         ReplyMsg((struct Message *)oRexxMsg);
  104.         oRexxMsg = NULL;
  105.     }
  106.     while(stillNeedReplies)
  107.     {
  108.         WaitPort(rexxPort);
  109.         dispRexxPort();
  110.     }
  111.     closeRexxLib();
  112.     DeleteMsgPort(rexxPort);
  113.     rexxPort = NULL;
  114.     }
  115.     rexxPortBit = 0;
  116. }
  117.  
  118. VOID
  119. dispRexxPort(VOID)
  120. {
  121.     struct RexxMsg *RexxMsg;
  122.     STRPTR cmd;
  123.     BOOL dontreply;
  124.  
  125.     if(!rexxPort)
  126.     return;
  127.  
  128.     while(RexxMsg = (struct RexxMsg *)GetMsg(rexxPort))
  129.     {
  130.     if(RexxMsg->rm_Node.mn_Node.ln_Type == NT_REPLYMSG)
  131.     {
  132.         if (RexxMsg->rm_Args[1])
  133.         {
  134.         ((int (*)(struct RexxMsg *))(RexxMsg->rm_Args[1]))(RexxMsg);
  135.         }
  136.         DeleteArgstring(RexxMsg->rm_Args[0]);
  137.         DeleteRexxMsg(RexxMsg);
  138.         stillNeedReplies--;
  139.         closeRexxLib();
  140.     }
  141.     else
  142.     {
  143.         cmd = (STRPTR)RexxMsg->rm_Args[0];
  144.         while (*cmd > 0 && *cmd <= ' ')
  145.         cmd++;
  146.         RexxMsg->rm_Result1 = 0;
  147.         RexxMsg->rm_Result2 = 0;
  148.  
  149.         dontreply = FALSE;
  150.  
  151.         if(bringerdown)
  152.         RexxMsg->rm_Result1 = RXERRORIMGONE;
  153.  
  154.         else
  155.         {
  156.         oRexxMsg = RexxMsg ;
  157.         rxexecstring(cmd, RexxMsg);
  158.         }
  159.         oRexxMsg = NULL ;
  160.         if(!dontreply)
  161.         ReplyMsg((struct Message *)RexxMsg) ;
  162.     }
  163.     }
  164. }
  165.  
  166. Local BOOL
  167. openRexxLib(VOID)
  168. {
  169.     if(RexxSysBase)
  170.     return(TRUE);
  171.     return((BOOL)(RexxSysBase = (struct RxsLib *)OpenLibrary(RXSNAME, 0L)));
  172. }
  173.  
  174. Local struct RexxMsg *
  175. sendRexxCmd(STRPTR s, int(*f)(), STRPTR p1, STRPTR p2, STRPTR p3, LONG m)
  176. {
  177.     struct MsgPort *rexxport;
  178.     struct RexxMsg *RexxMsg;
  179.  
  180.     if((!rexxPort) || (stillNeedReplies > MAXRXOUTSTANDING-1))
  181.     return(FALSE);
  182.     RexxMsg = NULL;
  183.     if(openRexxLib() && (RexxMsg =
  184.          CreateRexxMsg(rexxPort, extension, rexxPort->mp_Node.ln_Name)) &&
  185.          (RexxMsg->rm_Args[0] = CreateArgstring(s, (long)strlen(s))))
  186.     {
  187.     RexxMsg->rm_Action = RXCOMM | m;
  188.     RexxMsg->rm_Args[1] = (STRPTR)f;
  189.     RexxMsg->rm_Args[2] = p1;
  190.     RexxMsg->rm_Args[3] = p2;
  191.     RexxMsg->rm_Args[4] = p3;
  192.     RexxMsg->rm_Node.mn_Node.ln_Name = RXSDIR;
  193.     Forbid();
  194.     if(rexxport = FindPort(RXSDIR))
  195.         PutMsg(rexxport, (struct Message *)RexxMsg);
  196.     Permit();
  197.     if(rexxport)
  198.     {
  199.         stillNeedReplies++;
  200.         return(RexxMsg);
  201.     }
  202.     else
  203.         DeleteArgstring(RexxMsg->rm_Args[0]);
  204.     }
  205.     if(RexxMsg)
  206.     DeleteRexxMsg(RexxMsg);
  207.     closeRexxLib();
  208.     return(FALSE);
  209. }
  210.  
  211. struct RexxMsg *
  212. asyncRexxCmd(STRPTR s)
  213. {
  214.     return(sendRexxCmd(s, NULL, NULL, NULL, NULL, NULL));
  215. }
  216.  
  217. struct RexxMsg *
  218. asyncRexxString(STRPTR s)
  219. {
  220.     return(sendRexxCmd(s, NULL, NULL, NULL, NULL, RXFF_STRING));
  221. }
  222.  
  223. Local VOID
  224. replytoit(struct RexxMsg *msg)
  225. {
  226.     struct RexxMsg *omsg;
  227.  
  228.     omsg = (struct RexxMsg *)(msg->rm_Args[2]);
  229.     replyRexxCmd(omsg, msg->rm_Result1, msg->rm_Result2, NULL);
  230.     ReplyMsg((struct Message *)omsg);
  231. }
  232.  
  233. struct RexxMsg *
  234. syncRexxCmd(STRPTR s, struct RexxMsg *msg)
  235. {
  236.     return(sendRexxCmd(s, replytoit, (char *)msg, NULL, NULL, NULL));
  237. }
  238.  
  239. VOID
  240. replyRexxCmd(struct RexxMsg *msg, LONG primary, LONG secondary, STRPTR string)
  241. {
  242.     if(!primary && (msg->rm_Action & (1L << RXFB_RESULT)))
  243.     {
  244.     if(string && openRexxLib())
  245.         secondary = (long)CreateArgstring(string, (long)strlen(string));
  246.     else
  247.         secondary = 0L;
  248.     }
  249.     msg->rm_Result1 = primary;
  250.     msg->rm_Result2 = secondary;
  251.     closeRexxLib();
  252. }
  253.  
  254.