home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Libraries / XL 1.0 / XL.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-29  |  8.0 KB  |  444 lines  |  [TEXT/MPS ]
  1. /*********************************************************************
  2. Project    :    XL                -    XCMDs for everyone
  3. File        :    XL.c            -    The implementation
  4. Author    :    Matthias Neeracher
  5. Started    :    10Sep92                                Language    :    MPW C
  6. Modified    :    10Sep92    MN    
  7. Last        :    10Sep92
  8. *********************************************************************/
  9.  
  10. #include <Memory.h>
  11. #include <StdIO.h>
  12. #include <TextUtils.h>
  13.  
  14. #include "XL.h"
  15.  
  16. static XLHandler *    XLglue;
  17. static XCmdPtr            XLparams;
  18.  
  19. #ifdef XLDEBUG
  20. XLDebugLevel            XLDebug    =    xl_NoDebug;
  21.  
  22. static char * Requests[] = {
  23.     0, 
  24.     "SendCardMessage",
  25.     "EvalExpr", 
  26.     "StringLength", 
  27.     "StringMatch", 
  28.     "SendHCMessage", 
  29.     "ZeroBytes",
  30.     "PasToZero",
  31.     "ZeroToPas",
  32.     "StrToLong",
  33.     "StrToNum",
  34.     "StrToBool", 
  35.     "StrToExt", 
  36.     "LongToStr", 
  37.     "NumToStr", 
  38.     "NumToHex", 
  39.     "BoolToStr", 
  40.     "ExtToStr", 
  41.     "GetGlobal", 
  42.     "SetGlobal",
  43.     "GetFieldByName", 
  44.     "GetFieldByNum", 
  45.     "GetFieldByID", 
  46.     "SetFieldByName", 
  47.     "SetFieldByNum", 
  48.     "SetFieldByID", 
  49.     "StringEqual", 
  50.     "ReturnToPas", 
  51.     "ScanToReturn", 
  52.     "GetMaskAndData", 
  53.     "ChangedMaskAndData",
  54.     0,
  55.     0,
  56.     0,
  57.     0,
  58.     0,
  59.     0,
  60.     0,
  61.     0,
  62.     "ScanToZero"
  63. };
  64. #endif
  65.  
  66. static pascal void XLCallBack()
  67. {
  68.     short    request    =    XLparams->request;
  69.  
  70.     memset(XLparams->outArgs, 0, 4 * sizeof(Handle));
  71.     
  72.     if (request < 1 || request >= XL_SIZE || !XLglue[request])
  73.         request    =    xl_Undefined;
  74.  
  75. #ifdef XLDEBUG
  76.     switch (XLDebug) {
  77.     case xl_NoDebug:
  78.         break;
  79.     case xl_DebugUndefined:
  80.         if (request != xl_Undefined)
  81.             break;
  82.         
  83.         /* Fall through */
  84.     case xl_DebugAll:
  85.         fprintf(stderr, "\nXL: Request %d (", XLparams->request);
  86.         if (XLparams->request > 0 && XLparams->request < XL_SIZE && Requests[XLparams->request]) {
  87.             if (request != XLparams->request)
  88.                 fprintf(stderr, "NOT IMPLEMENTED: ");
  89.                 
  90.             fprintf(stderr, "%s)\n", Requests[XLparams->request]);
  91.         } else
  92.             fprintf(stderr, "UNKNOWN%s)\n", (request != XLparams->request) ? ", NOT IMPLEMENTED" : "");
  93.         
  94.         fprintf(stderr, "XL: inArgs   %08X %08X %08X %08X %08X %08X %08X %08X\n",
  95.             XLparams->inArgs[0],
  96.             XLparams->inArgs[1],
  97.             XLparams->inArgs[2],
  98.             XLparams->inArgs[3],
  99.             XLparams->inArgs[4],
  100.             XLparams->inArgs[5],
  101.             XLparams->inArgs[6],
  102.             XLparams->inArgs[7]);
  103.     }
  104. #endif
  105.     
  106.     (*XLglue[request])(XLparams);
  107.     
  108. #ifdef XLDEBUG
  109.     if (XLDebug == xl_DebugAll) {
  110.         fprintf(stderr, "XL: result: %d\n", XLparams->result);
  111.         fprintf(stderr, "XL: outArgs  %08X %08X %08X %08X\n",
  112.             XLparams->outArgs[0],
  113.             XLparams->outArgs[1],
  114.             XLparams->outArgs[2],
  115.             XLparams->outArgs[3]);
  116.     }
  117. #endif
  118. }
  119.  
  120. void XLCall(Handle xcmd, XLHandler glue[], XCmdPtr params)
  121. {
  122.     char    state;
  123.     
  124.     XLparams    =    params;
  125.     XLglue    =    glue;
  126.     
  127.     params->returnValue    =    nil;
  128.     params->entryPoint    =    (Ptr) XLCallBack;
  129.     
  130.     state        =    HGetState(xcmd);
  131.     HLock(xcmd);
  132.     
  133.     ((XLHandler) *xcmd)(params);
  134.     
  135.     HSetState(xcmd, state);
  136. }
  137.  
  138. static void XLUndefined(XCmdPtr params)
  139. {
  140.     params->result    = xresNotImp;
  141. }
  142.  
  143. static void XLStringLength(XCmdPtr params)
  144. {
  145.     params->outArgs[0] = strlen((Ptr) params->inArgs[0]);
  146.     
  147.     params->result    = xresSucc;    
  148. }
  149.  
  150. static void XLStringMatch(XCmdPtr params)
  151. {
  152.     StringPtr    pattern    =    (StringPtr) params->inArgs[0];
  153.     char *        text        =    (char *)        params->inArgs[1];
  154.     
  155.     for (; *text; ++text) {
  156.         int        len    =    pattern[0];
  157.         
  158.         while (len--)
  159.             if (pattern[len+1] != text[len])
  160.                 goto nextChar;
  161.         
  162.         params->outArgs[0] = (long) text;
  163.         params->result    = xresSucc;    
  164.         
  165.         return;
  166. nextChar:
  167.         continue;
  168.     }
  169.     
  170.     params->outArgs[0] = 0;
  171.     params->result    = xresSucc;    
  172. }
  173.  
  174. static void XLZeroBytes(XCmdPtr params)
  175. {
  176.     char *    bytes    =    (char *) params->inArgs[0];
  177.     long *    longs;
  178.     long        len    =    (long) params->inArgs[1];
  179.     long        count;
  180.     
  181.     params->result    = xresSucc;
  182.  
  183.     /* handle short lengths */
  184.     
  185.     if (len<0)
  186.         return;
  187.     
  188.     switch (len) {
  189.     case 2:
  190.         *bytes++ = 0;
  191.     case 1:
  192.         *bytes++ = 0;
  193.     case 0:
  194.         return;
  195.     default:
  196.         break;
  197.     }
  198.     
  199.     /* Align bytes */
  200.     
  201.     switch ((long) bytes & 3) {
  202.     case 1:
  203.         *bytes++    =    0;
  204.         --len;
  205.     case 2:
  206.         *bytes++    =    0;
  207.         --len;
  208.     case 3:
  209.         *bytes++    =    0;
  210.         --len;
  211.     case 0:
  212.         break;
  213.     }
  214.     
  215.     longs = (long *) bytes;
  216.     count    = len >> 5;
  217.     
  218.     switch ((len >> 2) & 7) {
  219.         do {
  220.             *longs++ = 0;
  221.         case 7:
  222.             *longs++ = 0;
  223.         case 6:
  224.             *longs++ = 0;
  225.         case 5:
  226.             *longs++ = 0;
  227.         case 4:
  228.             *longs++ = 0;
  229.         case 3:
  230.             *longs++ = 0;
  231.         case 2:
  232.             *longs++ = 0;
  233.         case 1:
  234.             *longs++ = 0;
  235.         case 0:
  236.             ;
  237.         } while (count--);
  238.     }
  239.     
  240.     bytes = (char *) longs;
  241.     
  242.     while (len-- & 3)
  243.         *bytes++ = 0;
  244. }
  245.  
  246. static void XLPasToZero(XCmdPtr params)
  247. {
  248.     if (
  249.         PtrToHand(
  250.             (char *)params->inArgs[0] + 1, 
  251.             (Handle *) ¶ms->outArgs[0], 
  252.             *(StringPtr)params->inArgs[0]+1)
  253.     )
  254.         params->outArgs[0]    =    0;
  255.     else
  256.         (*(Handle)params->outArgs[0])[*(StringPtr)params->inArgs[0]] = 0;
  257.         
  258.     params->result    =    xresSucc;
  259. }
  260.  
  261. static void XLZeroToPas(XCmdPtr params)
  262. {
  263.     char * end;
  264.     
  265.     end = (char *) memccpy((char *)params->inArgs[1] + 1, (char *)params->inArgs[0], 0, 254);
  266.     
  267.     if (end)
  268.         *(char *)params->inArgs[1]    = end - (char *)params->inArgs[1] - 2;
  269.     else 
  270.         *(char *)params->inArgs[1]    = 254;
  271.         
  272.     params->result    =    xresSucc;
  273. }
  274.  
  275. static void XLStrToLong(XCmdPtr params)
  276. {
  277.     * (unsigned long *)params->outArgs = strtoul(p2cstr((StringPtr) params->inArgs[0]), 0, 10);
  278.     
  279.     c2pstr((StringPtr) params->inArgs[0]);
  280.     
  281.     params->result    = xresSucc;    
  282. }
  283.  
  284. static void XLStrToNum(XCmdPtr params)
  285. {
  286.     params->outArgs[0] = strtol(p2cstr((StringPtr) params->inArgs[0]), 0, 10);
  287.     
  288.     c2pstr((StringPtr) params->inArgs[0]);
  289.     
  290.     params->result    = xresSucc;    
  291. }
  292.  
  293. static void XLStrToBool(XCmdPtr params)
  294. {
  295.     params->result    = xresSucc;    
  296.  
  297.     if (EqualString((StringPtr) params->inArgs[0], "\ptrue", false, true))
  298.         params->outArgs[0]    =    1;
  299.     else if (EqualString((StringPtr) params->inArgs[0], "\pfalse", false, true))
  300.         params->outArgs[0]    =    0;
  301.     else
  302.         params->result    = xresFail;    
  303. }
  304.  
  305. static void XLStrToExt(XCmdPtr params)
  306. {
  307.     *(extended *) params->inArgs[1] = atof(p2cstr((StringPtr) params->inArgs[0]));
  308.     
  309.     c2pstr((StringPtr) params->inArgs[0]);
  310.     
  311.     params->result    = xresSucc;    
  312. }
  313.  
  314. static void XLLongToStr(XCmdPtr params)
  315. {
  316.     *(StringPtr)params->inArgs[1] = sprintf((char *)params->inArgs[1] + 1, "%u", params->inArgs[0]);
  317.     
  318.     params->result    = xresSucc;    
  319. }
  320.  
  321. static void XLNumToStr(XCmdPtr params)
  322. {
  323.     *(StringPtr)params->inArgs[1] = sprintf((char *)params->inArgs[1] + 1, "%d", params->inArgs[0]);
  324.     
  325.     params->result    = xresSucc;    
  326. }
  327.  
  328. static void XLNumToHex(XCmdPtr params)
  329. {
  330.     *(StringPtr)params->inArgs[2] = sprintf((char *)params->inArgs[2] + 1, "%0*X", params->inArgs[0], params->inArgs[1]);
  331.     
  332.     params->result    = xresSucc;    
  333. }
  334.  
  335. static void XLBoolToStr(XCmdPtr params)
  336. {
  337.     if (params->inArgs[0])
  338.         strcpy((char *) params->inArgs[1], "\ptrue");
  339.     else
  340.         strcpy((char *) params->inArgs[1], "\pfalse");
  341.     
  342.     params->result    = xresSucc;    
  343. }
  344.  
  345.  
  346. static void XLExtToStr(XCmdPtr params)
  347. {
  348.     *(StringPtr)params->inArgs[1] = sprintf((char *)params->inArgs[1] + 1, "%10G", *(extended *) params->inArgs[0]);
  349.     
  350.     params->result    = xresSucc;    
  351. }
  352.  
  353. static void XLStringEqual(XCmdPtr params)
  354. {
  355.     params->outArgs[0]     = 
  356.         EqualString((StringPtr)params->inArgs[0], (StringPtr)params->inArgs[1], false, true);
  357.     params->result            = xresSucc;    
  358. }
  359.  
  360. static void XLReturnToPas(XCmdPtr params)
  361. {
  362.     int     len;
  363.     char * end    =    strchr((char *) params->inArgs[0], '\n');
  364.     
  365.     if (end) {
  366.         if ((len = end - (char *) params->inArgs[0] - 1) > 254)
  367.             len = 254;
  368.     } else {
  369.         if ((len = strlen((char *) params->inArgs[0])) > 254)
  370.             len = 254;
  371.     }
  372.     
  373.     strncpy((char *) params->inArgs[1]+1, (char *) params->inArgs[0], len);
  374.  
  375.     *(StringPtr) params->inArgs[1] = len;    
  376.     params->result                         = xresSucc;    
  377. }
  378.  
  379. static void XLScanToReturn(XCmdPtr params)
  380. {
  381.     Ptr *    ptr    =    (Ptr *) params->inArgs[0];
  382.     
  383.     for (; **ptr; ++*ptr)
  384.         if (**ptr == '\n')
  385.             break;
  386.             
  387.     params->result = xresSucc;    
  388. }
  389.  
  390. static void XLScanToZero(XCmdPtr params)
  391. {
  392.     Ptr *    ptr    =    (Ptr *) params->inArgs[0];
  393.     
  394.     for (; **ptr; ++*ptr);
  395.             
  396.     params->result = xresSucc;    
  397. }
  398.  
  399. XLGlue XLDefaultGlue    =    {
  400.     XLUndefined,
  401.     nil,
  402.     nil,
  403.     XLStringLength,
  404.     XLStringMatch,
  405.     nil,
  406.     XLZeroBytes,
  407.     XLPasToZero,
  408.     XLZeroToPas,
  409.     XLStrToLong,
  410.  
  411.     XLStrToNum,
  412.     XLStrToBool,
  413.     XLStrToExt,
  414.     XLLongToStr,
  415.     XLNumToStr,
  416.     XLNumToHex,
  417.     XLBoolToStr,
  418.     XLExtToStr,
  419.     nil,
  420.     nil,
  421.  
  422.     nil,
  423.     nil,
  424.     nil,
  425.     nil,
  426.     nil,
  427.     nil,
  428.     XLStringEqual,
  429.     XLReturnToPas,
  430.     XLScanToReturn,
  431.     nil,
  432.  
  433.     nil,
  434.     nil,
  435.     nil,
  436.     nil,
  437.     nil,
  438.     nil,
  439.     nil,
  440.     nil,
  441.     nil,
  442.     XLScanToZero
  443. };
  444.