home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 18 REXX / 18-REXX.zip / rox.zip / roxsem.c < prev    next >
C/C++ Source or Header  |  1993-10-22  |  11KB  |  462 lines
  1. /*------------------------------------------------------------------
  2.  * roxsem.c :
  3.  *------------------------------------------------------------------
  4.  * 09-03-93 originally by Patrick J. Mueller
  5.  *------------------------------------------------------------------*/
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10.  
  11. /*------------------------------------------------------------------
  12.  * os/2 includes
  13.  *------------------------------------------------------------------*/
  14. #if defined(OPSYS_OS2)
  15.    #define INCL_BASE
  16.    #include <os2.h>
  17. #endif
  18.  
  19. /*------------------------------------------------------------------
  20.  * rexx includes
  21.  *------------------------------------------------------------------*/
  22. #define INCL_REXXSAA
  23. #if defined(OPSYS_AIX)
  24.    #include <rexxtype.h>
  25. #endif
  26. #include <rexxsaa.h>
  27.  
  28. /*------------------------------------------------------------------
  29.  * rox includes
  30.  *------------------------------------------------------------------*/
  31. #include "roxapi.h"
  32.  
  33. /*------------------------------------------------------------------
  34.  * write an integer to a pre-allocated REXX string
  35.  *------------------------------------------------------------------*/
  36. static void long2rxs(
  37.    long      val,
  38.    PRXSTRING pRxs
  39.    )
  40.    {
  41.    sprintf(pRxs->strptr,"%ld",(long)val);
  42.    pRxs->strlength = strlen(pRxs->strptr);
  43.    }
  44.  
  45. /*------------------------------------------------------------------
  46.  *
  47.  *------------------------------------------------------------------*/
  48. ULONG APIENTRY RoxSemMutexInit(
  49.    void      *object,
  50.    PUCHAR     methodName,
  51.    ULONG      argc,
  52.    PRXSTRING  argv,
  53.    PRXSTRING  retString
  54.    )
  55.    {
  56.    APIRET   rc;
  57.    HMTX     hMtx;
  58.    RXSTRING name;
  59.    RXSTRING valu;
  60.  
  61.    rc = DosCreateMutexSem(NULL,&hMtx,0,0);
  62.    if (rc)
  63.       hMtx = 0;
  64.  
  65.    name.strptr    = "handle";
  66.    name.strlength = strlen(name.strptr);
  67.  
  68.    valu.strptr    = malloc(4);
  69.    valu.strlength = 4;
  70.  
  71.    memcpy(valu.strptr,&hMtx,4);
  72.  
  73.    RoxVariableSet(object,&name,&valu);
  74.  
  75.    return 0;
  76.    }
  77.  
  78. /*------------------------------------------------------------------
  79.  *
  80.  *------------------------------------------------------------------*/
  81. ULONG APIENTRY RoxSemMutexDeinit(
  82.    void      *object,
  83.    PUCHAR     methodName,
  84.    ULONG      argc,
  85.    PRXSTRING  argv,
  86.    PRXSTRING  retString
  87.    )
  88.    {
  89.    HMTX     hMtx;
  90.    RXSTRING name;
  91.    RXSTRING valu;
  92.  
  93.    name.strptr    = "handle";
  94.    name.strlength = strlen(name.strptr);
  95.  
  96.    RoxVariableGet(object,&name,&valu);
  97.    memcpy(&hMtx,valu.strptr,4);
  98.  
  99.    DosCloseMutexSem(hMtx);
  100.  
  101.    return 0;
  102.    }
  103.  
  104. /*------------------------------------------------------------------
  105.  *
  106.  *------------------------------------------------------------------*/
  107. ULONG APIENTRY RoxSemMutexQuery(
  108.    void      *object,
  109.    PUCHAR     methodName,
  110.    ULONG      argc,
  111.    PRXSTRING  argv,
  112.    PRXSTRING  retString
  113.    )
  114.    {
  115.    HMTX     hMtx;
  116.    PID      pid;
  117.    TID      tid;
  118.    ULONG    count;
  119.    RXSTRING name;
  120.    RXSTRING valu;
  121.  
  122.    name.strptr    = "handle";
  123.    name.strlength = strlen(name.strptr);
  124.  
  125.    RoxVariableGet(object,&name,&valu);
  126.    memcpy(&hMtx,valu.strptr,4);
  127.  
  128.    count = 0;
  129.  
  130.    DosQueryMutexSem(hMtx,&pid,&tid,&count);
  131.  
  132.    long2rxs(count,retString);
  133.  
  134.    return 0;
  135.    }
  136.  
  137. /*------------------------------------------------------------------
  138.  *
  139.  *------------------------------------------------------------------*/
  140. ULONG APIENTRY RoxSemMutexRequest(
  141.    void      *object,
  142.    PUCHAR     methodName,
  143.    ULONG      argc,
  144.    PRXSTRING  argv,
  145.    PRXSTRING  retString
  146.    )
  147.    {
  148.    HMTX     hMtx;
  149.    APIRET   rc;
  150.    RXSTRING name;
  151.    RXSTRING valu;
  152.  
  153.    name.strptr    = "handle";
  154.    name.strlength = strlen(name.strptr);
  155.  
  156.    RoxVariableGet(object,&name,&valu);
  157.    memcpy(&hMtx,valu.strptr,4);
  158.  
  159.    rc = DosRequestMutexSem(hMtx,-1);
  160.  
  161.    long2rxs(rc,retString);
  162.  
  163.    return 0;
  164.    }
  165.  
  166. /*------------------------------------------------------------------
  167.  *
  168.  *------------------------------------------------------------------*/
  169. ULONG APIENTRY RoxSemMutexRelease(
  170.    void      *object,
  171.    PUCHAR     methodName,
  172.    ULONG      argc,
  173.    PRXSTRING  argv,
  174.    PRXSTRING  retString
  175.    )
  176.    {
  177.    HMTX     hMtx;
  178.    APIRET   rc;
  179.    RXSTRING name;
  180.    RXSTRING valu;
  181.  
  182.    name.strptr    = "handle";
  183.    name.strlength = strlen(name.strptr);
  184.  
  185.    RoxVariableGet(object,&name,&valu);
  186.    memcpy(&hMtx,valu.strptr,4);
  187.  
  188.    rc = DosReleaseMutexSem(hMtx);
  189.  
  190.    long2rxs(rc,retString);
  191.  
  192.    return 0;
  193.    }
  194.  
  195. /*------------------------------------------------------------------
  196.  *
  197.  *------------------------------------------------------------------*/
  198. ULONG APIENTRY RoxSemEventInit(
  199.    void      *object,
  200.    PUCHAR     methodName,
  201.    ULONG      argc,
  202.    PRXSTRING  argv,
  203.    PRXSTRING  retString
  204.    )
  205.    {
  206.    APIRET rc;
  207.    HEV    hEv;
  208.    RXSTRING name;
  209.    RXSTRING valu;
  210.  
  211.    rc = DosCreateEventSem(NULL,&hEv,0,1);
  212.    if (rc)
  213.       hEv = 0;
  214.  
  215.    name.strptr    = "handle";
  216.    name.strlength = strlen(name.strptr);
  217.  
  218.    valu.strptr    = malloc(4);
  219.    valu.strlength = 4;
  220.  
  221.    memcpy(valu.strptr,&hEv,4);
  222.  
  223.    RoxVariableSet(object,&name,&valu);
  224.  
  225.    return 0;
  226.    }
  227.  
  228. /*------------------------------------------------------------------
  229.  *
  230.  *------------------------------------------------------------------*/
  231. ULONG APIENTRY RoxSemEventDeinit(
  232.    void      *object,
  233.    PUCHAR     methodName,
  234.    ULONG      argc,
  235.    PRXSTRING  argv,
  236.    PRXSTRING  retString
  237.    )
  238.    {
  239.    HEV      hEv;
  240.    RXSTRING name;
  241.    RXSTRING valu;
  242.  
  243.    name.strptr    = "handle";
  244.    name.strlength = strlen(name.strptr);
  245.  
  246.    RoxVariableGet(object,&name,&valu);
  247.    memcpy(&hEv,valu.strptr,4);
  248.  
  249.    DosCloseEventSem(hEv);
  250.  
  251.    return 0;
  252.    }
  253.  
  254. /*------------------------------------------------------------------
  255.  *
  256.  *------------------------------------------------------------------*/
  257. ULONG APIENTRY RoxSemEventQuery(
  258.    void      *object,
  259.    PUCHAR     methodName,
  260.    ULONG      argc,
  261.    PRXSTRING  argv,
  262.    PRXSTRING  retString
  263.    )
  264.    {
  265.    HEV      hEv;
  266.    ULONG    count;
  267.    RXSTRING name;
  268.    RXSTRING valu;
  269.  
  270.    name.strptr    = "handle";
  271.    name.strlength = strlen(name.strptr);
  272.  
  273.    RoxVariableGet(object,&name,&valu);
  274.    memcpy(&hEv,valu.strptr,4);
  275.  
  276.    count = 0;
  277.  
  278.    DosQueryEventSem(hEv,&count);
  279.  
  280.    long2rxs(count,retString);
  281.  
  282.    return 0;
  283.    }
  284.  
  285. /*------------------------------------------------------------------
  286.  *
  287.  *------------------------------------------------------------------*/
  288. ULONG APIENTRY RoxSemEventReset(
  289.    void      *object,
  290.    PUCHAR     methodName,
  291.    ULONG      argc,
  292.    PRXSTRING  argv,
  293.    PRXSTRING  retString
  294.    )
  295.    {
  296.    HEV      hEv;
  297.    ULONG    count;
  298.    APIRET   rc;
  299.    RXSTRING name;
  300.    RXSTRING valu;
  301.  
  302.    name.strptr    = "handle";
  303.    name.strlength = strlen(name.strptr);
  304.  
  305.    RoxVariableGet(object,&name,&valu);
  306.    memcpy(&hEv,valu.strptr,4);
  307.  
  308.    rc = DosResetEventSem(hEv,&count);
  309.  
  310.    long2rxs(rc,retString);
  311.  
  312.    return 0;
  313.    }
  314.  
  315. /*------------------------------------------------------------------
  316.  *
  317.  *------------------------------------------------------------------*/
  318. ULONG APIENTRY RoxSemEventPost(
  319.    void      *object,
  320.    PUCHAR     methodName,
  321.    ULONG      argc,
  322.    PRXSTRING  argv,
  323.    PRXSTRING  retString
  324.    )
  325.    {
  326.    HEV      hEv;
  327.    APIRET   rc;
  328.    RXSTRING name;
  329.    RXSTRING valu;
  330.  
  331.    name.strptr    = "handle";
  332.    name.strlength = strlen(name.strptr);
  333.  
  334.    RoxVariableGet(object,&name,&valu);
  335.    memcpy(&hEv,valu.strptr,4);
  336.  
  337.    rc = DosPostEventSem(hEv);
  338.  
  339.    long2rxs(rc,retString);
  340.  
  341.    return 0;
  342.    }
  343.  
  344. /*------------------------------------------------------------------
  345.  *
  346.  *------------------------------------------------------------------*/
  347. ULONG APIENTRY RoxSemEventWait(
  348.    void      *object,
  349.    PUCHAR     methodName,
  350.    ULONG      argc,
  351.    PRXSTRING  argv,
  352.    PRXSTRING  retString
  353.    )
  354.    {
  355.    HEV      hEv;
  356.    APIRET   rc;
  357.    RXSTRING name;
  358.    RXSTRING valu;
  359.  
  360.    name.strptr    = "handle";
  361.    name.strlength = strlen(name.strptr);
  362.  
  363.    RoxVariableGet(object,&name,&valu);
  364.    memcpy(&hEv,valu.strptr,4);
  365.  
  366.    rc = DosWaitEventSem(hEv,-1);
  367.  
  368.    long2rxs(rc,retString);
  369.  
  370.    return 0;
  371.    }
  372.  
  373. /*------------------------------------------------------------------
  374.  *
  375.  *------------------------------------------------------------------*/
  376. void roxAddClass(
  377.    PSZ class
  378.    )
  379.    {
  380.    RXSTRING  parm[1];
  381.    RXSTRING  result;
  382.    void     *buff;
  383.  
  384.    parm[0].strptr      = class;
  385.    parm[0].strlength   = strlen(parm[0].strptr);
  386.  
  387.    buff                = malloc(256);
  388.    result.strptr       = buff;
  389.    result.strlength    = 0;
  390.  
  391.    RoxAddClass(NULL,1,parm,NULL,&result);
  392.  
  393.    if (result.strptr != buff)
  394.      osFree(result.strptr);
  395.  
  396.    free(buff);
  397.    }
  398.  
  399. /*------------------------------------------------------------------
  400.  *
  401.  *------------------------------------------------------------------*/
  402. void roxClassAddMethodDll(
  403.    PSZ class,
  404.    PSZ method,
  405.    PSZ dll,
  406.    PSZ entry
  407.    )
  408.    {
  409.    RXSTRING  parm[4];
  410.    RXSTRING  result;
  411.    void     *buff;
  412.  
  413.    parm[0].strptr      = class;
  414.    parm[0].strlength   = strlen(parm[0].strptr);
  415.    parm[1].strptr      = method;
  416.    parm[1].strlength   = strlen(parm[1].strptr);
  417.    parm[2].strptr      = dll;
  418.    parm[2].strlength   = strlen(parm[2].strptr);
  419.    parm[3].strptr      = entry;
  420.    parm[3].strlength   = strlen(parm[3].strptr);
  421.  
  422.    buff                = malloc(256);
  423.    result.strptr       = buff;
  424.    result.strlength    = 0;
  425.  
  426.    RoxClassAddMethodDll(NULL,4,parm,NULL,&result);
  427.  
  428.    if (result.strptr != buff)
  429.      osFree(result.strptr);
  430.  
  431.    free(buff);
  432.    }
  433.  
  434. /*------------------------------------------------------------------
  435.  * DLL entrypoint function named "RoxDLLEntryPoint"
  436.  *------------------------------------------------------------------*/
  437. ULONG APIENTRY RoxDllEntryPoint(
  438.    ULONG init
  439.    )
  440.    {
  441.    if (init)
  442.       {
  443.       roxAddClass("MutexSem");
  444.       roxClassAddMethodDll("MutexSem", "init",    "RoxSem", "RoxSemMutexInit");
  445.       roxClassAddMethodDll("MutexSem", "deinit",  "RoxSem", "RoxSemMutexDeinit");
  446.       roxClassAddMethodDll("MutexSem", "query",   "RoxSem", "RoxSemMutexQuery");
  447.       roxClassAddMethodDll("MutexSem", "request", "RoxSem", "RoxSemMutexRequest");
  448.       roxClassAddMethodDll("MutexSem", "release", "RoxSem", "RoxSemMutexRelease");
  449.  
  450.       roxAddClass("EventSem");
  451.       roxClassAddMethodDll("EventSem", "init",    "RoxSem", "RoxSemEventInit");
  452.       roxClassAddMethodDll("EventSem", "deinit",  "RoxSem", "RoxSemEventDeinit");
  453.       roxClassAddMethodDll("EventSem", "query",   "RoxSem", "RoxSemEventQuery");
  454.       roxClassAddMethodDll("EventSem", "reset",   "RoxSem", "RoxSemEventReset");
  455.       roxClassAddMethodDll("EventSem", "post",    "RoxSem", "RoxSemEventPost");
  456.       roxClassAddMethodDll("EventSem", "wait",    "RoxSem", "RoxSemEventWait");
  457.       }
  458.  
  459.    return 0;
  460.    }
  461.  
  462.