home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Sound / MidI / SYNTHLIB.LHA / Synth_Librarian / sources / SY22 / SY22.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-22  |  17.7 KB  |  682 lines
  1. /**************************************************************/
  2. /* $VER: SY22.c Revison 1.1                                   */
  3. /* This file is part of Synth Librarian v1.1                  */
  4. /* ©1993-1994 Jean-Alexis MONTIGNIES                          */
  5. /* This file must not be distributed modified or separatly    */
  6. /* without my written permission                              */
  7. /* See Synth_Librarian.guide for more details                 */
  8. /**************************************************************/
  9.  
  10. #include <proto/exec.h>
  11. #include <stdlib.h>
  12. #include <math.h>
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include <intuition/intuition.h>
  16. #include <proto/intuition.h>
  17.  
  18. #include "SynthLib.h"
  19. #include <libraries/locale.h>
  20. #include <proto/locale.h>
  21. #define CATCOMP_BLOCK
  22. #define CATCOMP_NUMBERS
  23. #include "Sy22loc.h"
  24.  
  25. #define STEPD_CHECK_YAMAHA   0
  26. #define STEPD_G1P            1
  27. #define STEPD_G1P_DATA      2
  28. #define STEPD_GP_LENGTH      3
  29. #define STEPD_GP_DATA       4
  30.  
  31. #define STEPD_WAIT_SYSEX     5
  32. #define STEPD_WAIT_YAMAHA    6
  33.  
  34. #define STEPD_WAIT100         0
  35. #define STEPD_S1P             1
  36. #define STEPD_SEND_END        2
  37.  
  38. #define TYPE_VOICE           &SY22TypesNodes[0]
  39. #define TYPE_ALL             &SY22TypesNodes[1]
  40.  
  41. #define BUFFER_SIZE         40000L
  42.  
  43. struct LocaleInfo DLi;
  44. #ifndef DEBUG_SL
  45. struct Library *LocaleBase;
  46. struct DosBase *DOSBase;
  47. struct ExecBase *SysBase;
  48. struct IntuitionBase *IntuitionBase ;
  49. #endif
  50.  
  51. char Message[256];
  52. static struct DriverData DD;
  53. extern struct MinList SY22TypesList;
  54. struct Node SY22TypesNodes[] = {
  55.         &SY22TypesNodes[1], ( struct Node * )&SY22TypesList.mlh_Head, 0, 0, "SY22 Voice",
  56.         ( struct Node * )&SY22TypesList.mlh_Tail, &SY22TypesNodes[0], 0, 0, "SY22 All" };
  57.  
  58. struct MinList SY22TypesList = {
  59.         ( struct MinNode * )&SY22TypesNodes[0], ( struct MinNode * )NULL, ( struct MinNode * )&SY22TypesNodes[1] };
  60. struct EasyStruct AboutES_SY22 = {
  61.     sizeof (struct EasyStruct),
  62.     0,
  63.     NULL,
  64.     NULL,
  65.     NULL
  66.  };
  67.  
  68.  
  69. struct DriverData * InitDriver(ULONG (*GetData)(ULONG Number));
  70. void Close(void);
  71. STRPTR GetString_SY22(struct LocaleInfo *li, LONG stringNum);
  72. ULONG Driver(ULONG *StepPtr,struct Exchange *Ex);
  73. STRPTR About(void);
  74. struct Node* RecognizeNode2(struct DumpNode *Node,int *Error);
  75. struct Node* RecognizeNode(struct DumpNode *Node);
  76. int CheckYamaha(struct DumpNode *Node);
  77.  
  78. __saveds struct DriverData *InitDriver(ULONG (*GetData)(ULONG Number))
  79.  {
  80. #ifndef DEBUG_SL
  81.   DOSBase=(struct DosBase *)GetData(GTD_DosBase);
  82.   SysBase=(struct ExecBase *)GetData(GTD_ExecBase);
  83.   LocaleBase=(struct LocaleBase *)GetData(GTD_LocaleBase);
  84.   IntuitionBase=(struct IntuitionBase *)GetData(GTD_IntuitionBase);
  85. #endif
  86.  
  87.   if (DLi.li_LocaleBase=LocaleBase)
  88.     DLi.li_Catalog=OpenCatalog(NULL,"SynthLib/SY22.catalog",OC_BuiltInLanguage,"english",TAG_DONE);
  89.  
  90.   DD.Flags=0;
  91.   DD.Driver=Driver;
  92.   DD.Close=Close;
  93.   DD.About=About;
  94.   DD.TypeList=&SY22TypesList;
  95.   DD.Recognize=RecognizeNode;
  96.  
  97.   return(&DD);
  98.  }
  99.  
  100. __saveds void Close(void)
  101.  {if (LocaleBase)
  102.     CloseCatalog(DLi.li_Catalog);
  103.  }
  104.  
  105. __saveds STRPTR About()
  106.  {return(GetString_SY22(&DLi,MSGD_ABOUT));
  107.  }
  108.  
  109. __saveds ULONG Driver(ULONG *StepPtr,struct Exchange *Ex)
  110.  {static UBYTE * BufferSY22;
  111.   static StepD;
  112.   static USHORT PacketLength;
  113.   static struct Node *Type;
  114.   static struct DumpNode *Node;
  115.   static UBYTE NPackets;
  116.   static ULONG DataLength;
  117.   static UBYTE * DataPtr;
  118.   ULONG ReturnCode=0;
  119.   int Error;
  120.  
  121.   switch(*StepPtr)
  122.    {
  123.     case STEP_INIT_DRIVER:
  124.  
  125.       BufferSY22=NULL;
  126.  
  127.       break;
  128.  
  129.     case STEP_EXIT_DRIVER:
  130.     case STEP_ABORT:
  131.       if (BufferSY22)
  132.        {BufferSY22=0;
  133.         FreeMem(BufferSY22,BUFFER_SIZE);
  134.        }
  135.  
  136.     break;
  137.  
  138.     case STEP_START:
  139.       if (!BufferSY22)
  140.         BufferSY22=AllocMem(BUFFER_SIZE,0L);
  141.       if (BufferSY22)
  142.        {
  143.         BufferSY22[0]=0xF0;
  144.         Ex->DataPtr=BufferSY22+1;
  145.         Ex->Length=3;
  146.         *StepPtr=STEP_RECIEVE;
  147.         StepD=STEPD_CHECK_YAMAHA;
  148.        }
  149.        else
  150.        {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  151.         ReturnCode=1;
  152.         *StepPtr=STEP_WAIT;
  153.        }
  154.  
  155.       break;
  156.  
  157.     case STEP_CONTINUE:
  158.       switch(StepD)
  159.        {case STEPD_CHECK_YAMAHA:
  160.           if (Ex->DataPtr[-3]==0x43 && !(Ex->DataPtr[-2]&0xF0) && Ex->DataPtr[-1]==0x7E)
  161.            {StepD=STEPD_G1P;
  162.             Ex->Length=2;
  163.             *StepPtr=STEP_RECIEVE;
  164.            }
  165.            else
  166.             *StepPtr=STEP_WAIT;
  167.  
  168.           break;
  169.  
  170.         case STEPD_G1P:
  171.           PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  172.  
  173.           if (BUFFER_SIZE+(BufferSY22-Ex->DataPtr)<PacketLength+1)
  174.            {Ex->Message=GetString_SY22(&DLi,ERRORD_TOO_MANY_DATA);
  175.             ReturnCode=1;
  176.             *StepPtr=STEP_WAIT;
  177.            }
  178.            else
  179.            {*StepPtr=STEP_RECIEVE;
  180.             Ex->Length=PacketLength+1;
  181.             StepD=STEPD_G1P_DATA;
  182.             sprintf(Message,GetString_SY22(&DLi,MSGD_RECIEVEPACKET),1);
  183.             Ex->Message=Message;
  184.            }
  185.  
  186.           break;
  187.  
  188.         case STEPD_G1P_DATA:
  189.           Type=0;
  190.           NPackets=1;
  191.  
  192.           if (!memcmp(&(Ex->DataPtr[-PacketLength-1]),"PK  2203AE",10))
  193.             Type=TYPE_VOICE;
  194.            else
  195.             if (!memcmp(&(Ex->DataPtr[-PacketLength-1]),"PK  2203VM",10))
  196.               Type=TYPE_ALL;
  197.  
  198.           if (Type)
  199.            {
  200.             *StepPtr=STEP_RECIEVE_EOF;
  201.             Ex->Length=2;
  202.             Ex->Data1=0xF7F7F7F7;
  203.             StepD=STEPD_GP_LENGTH;
  204.            }
  205.            else
  206.            {*StepPtr=STEP_WAIT;
  207.             Ex->Message=GetString_SY22(&DLi,ERRORD_UNKNOWN_FORMAT);
  208.             ReturnCode=1;
  209.            }
  210.  
  211.           break;
  212.  
  213.         case STEPD_GP_LENGTH:
  214.  
  215.           if (Ex->DataPtr[-1]!=0xF7)
  216.            {PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  217.  
  218.             if (BUFFER_SIZE+(BufferSY22-Ex->DataPtr)<PacketLength+1)
  219.              {Ex->Message=GetString_SY22(&DLi,ERRORD_TOO_MANY_DATA);
  220.               ReturnCode=1;
  221.               *StepPtr=STEP_WAIT;
  222.              }
  223.              else
  224.              {*StepPtr=STEP_RECIEVE;
  225.               Ex->Length=PacketLength+1;
  226.               StepD=STEPD_GP_DATA;
  227.               sprintf(Message,GetString_SY22(&DLi,MSGD_RECIEVEPACKET),NPackets+1);
  228.               Ex->Message=Message;
  229.              }
  230.            }
  231.            else
  232.            {DataLength=Ex->DataPtr-BufferSY22;
  233.             if (Node=AllocMem(sizeof(struct DumpNode),0L))
  234.              {
  235.               Node->Data=NULL;
  236.               Node->DataLength=0;
  237.               Node->DumpLength=DataLength;
  238.               Node->Name[0]='\0';
  239.               Node->Flags=0;
  240.               Ex->Node=Node;
  241.               strcpy(Node->Type,Type->ln_Name);
  242.               if (Type==TYPE_VOICE)
  243.                {Ex->Message=GetString_SY22(&DLi,MSGD_RECIEVEENDVOICE);
  244.                 memcpy(Node->Name,BufferSY22+19,8);
  245.                 Node->Name[8]='\0';
  246.                }
  247.               if (Type==TYPE_ALL)
  248.                {Ex->Message=GetString_SY22(&DLi,MSGD_RECIEVEENDALL);
  249.                }
  250.               if (Node->Dump=AllocMem(DataLength,0L))
  251.                {memcpy(Node->Dump,BufferSY22,DataLength);
  252.  
  253.                 Ex->DataPtr=(APTR)Node;
  254.                 *StepPtr=STEP_RECIEVE_COMPLETE;
  255.                }
  256.                else
  257.                {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  258.                 ReturnCode=1;
  259.                 *StepPtr=STEP_WAIT;
  260.                 FreeMem(Node,sizeof(struct DumpNode));
  261.                }
  262.              }
  263.              else
  264.              {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  265.               ReturnCode=1;
  266.               *StepPtr=STEP_WAIT;
  267.              }
  268.             FreeMem(BufferSY22,BUFFER_SIZE);
  269.             BufferSY22=0;
  270.            }
  271.  
  272.           break;
  273.  
  274.         case STEPD_GP_DATA:
  275.           NPackets++;
  276.  
  277.           *StepPtr=STEP_RECIEVE_EOF;
  278.           Ex->Length=2;
  279.           Ex->Data1=0xF7F7F7F7;
  280.           StepD=STEPD_GP_LENGTH;
  281.  
  282.           break;
  283.        }
  284.       break;
  285.  
  286.     case STEP_SEND_ABORT:
  287.  
  288.     break;
  289.  
  290.  
  291.     case STEP_SEND_START:
  292.       Node=(struct DumpNode *)Ex->Node;
  293.       Type=0;
  294.       NPackets=0;
  295.  
  296.       Type=RecognizeNode2(Node,&Error);
  297.  
  298.       if (Error)
  299.         { Ex->Message=GetString_SY22(&DLi,Error);
  300.           ReturnCode=1;
  301.           *StepPtr=STEP_SEND_COMPLETE;
  302.         }
  303.  
  304.       if (Type==TYPE_VOICE)
  305.        {sprintf(Message,GetString_SY22(&DLi,MSGD_SENDVOICE),Node->Name);
  306.         Ex->Message=Message;
  307.        }
  308.         
  309.       if (Type==TYPE_ALL)
  310.        {sprintf(Message,GetString_SY22(&DLi,MSGD_SENDALLPACKET),1);
  311.         Ex->Message=Message;
  312.        }
  313.  
  314.       if (Type)
  315.        {DataPtr=Node->Dump;
  316.         Ex->DataPtr=DataPtr;
  317.         PacketLength=(((UWORD)Ex->DataPtr[4])<<7)+Ex->DataPtr[5];
  318.         Ex->Length=PacketLength+7;
  319.         DataPtr+=Ex->Length;
  320.         *StepPtr=STEP_SEND_SEND;
  321.         StepD=STEPD_WAIT100;
  322.        }
  323.        
  324.        break;
  325.  
  326.     case STEP_SEND_CONTINUE:
  327.       switch(StepD)
  328.        {case STEPD_WAIT100:
  329.  
  330.           NPackets++;
  331.  
  332.           if (DataPtr[0]==0xF7)
  333.            {Ex->Length=1;
  334.             Ex->DataPtr=DataPtr;
  335.             *StepPtr=STEP_SEND_SEND;
  336.             StepD=STEPD_SEND_END;
  337.            }
  338.            else
  339.            {
  340.             Ex->Data1=100000;
  341.             *StepPtr=STEP_SEND_DELAY;
  342.             StepD=STEPD_S1P;
  343.            }
  344.  
  345.           break;
  346.  
  347.         case STEPD_S1P:
  348.           PacketLength=(((UWORD)DataPtr[0])<<7)+DataPtr[1];
  349.           Ex->Length=PacketLength+3;
  350.           Ex->DataPtr=DataPtr;
  351.           DataPtr+=Ex->Length;
  352.  
  353.           Ex->Message=Message;
  354.           sprintf(Message,GetString_SY22(&DLi,MSGD_SENDALLPACKET),NPackets+1);
  355.  
  356.           *StepPtr=STEP_SEND_SEND;
  357.           StepD=STEPD_WAIT100;
  358.  
  359.           break;
  360.  
  361.         case STEPD_SEND_END:
  362.           *StepPtr=STEP_SEND_COMPLETE;
  363.           Ex->Message=Message;
  364.           sprintf(Message,GetString_SY22(&DLi,MSGD_SENDEND),Node->Name);
  365.  
  366.        }
  367.       break;
  368.  
  369.     case STEP_REQ_START:
  370.       Node=Ex->Node;
  371.       Ex->Node=NULL;
  372.       Type=0;
  373.       NPackets=0;
  374.  
  375.       if (!strcmp(((struct Node *)Node)->ln_Name,"SY22 Voice"))
  376.        {Ex->DataPtr="\xF0\x43 \x7EPK  2203AE\xF7";
  377.         Type=TYPE_VOICE;
  378.        }
  379.        else
  380.         if (!strcmp(((struct Node *)Node)->ln_Name,"SY22 All"))
  381.          {Ex->DataPtr="\xF0\x43 \x7EPK  2203VM\xF7";
  382.           Type=TYPE_ALL;
  383.          }
  384.  
  385.       if (Type)
  386.        {
  387.         Ex->Length=15;
  388.         *StepPtr=STEP_REQ_SEND;
  389.         StepD=STEPD_WAIT_SYSEX;
  390.        }
  391.        else
  392.        {Ex->Message=GetString_SY22(&DLi,ERRORD_UNKNOWN_TYPE);
  393.         ReturnCode=1;
  394.         *StepPtr=STEP_REQ_COMPLETE;
  395.        }
  396.  
  397.       break;
  398.  
  399.     case STEP_REQ_ABORT:
  400.       if (BufferSY22)
  401.        {BufferSY22=0;
  402.         FreeMem(BufferSY22,BUFFER_SIZE);
  403.        }
  404.  
  405.       break;
  406.  
  407.     case STEP_REQ_CONTINUE:
  408.       switch(StepD)
  409.        {
  410.         case STEPD_WAIT_SYSEX:
  411.           if (!BufferSY22)
  412.             BufferSY22=AllocMem(BUFFER_SIZE,0L);
  413.           if (!BufferSY22)
  414.            {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  415.             ReturnCode=1;
  416.             *StepPtr=STEP_REQ_COMPLETE;
  417.            }
  418.            else
  419.            {*StepPtr=STEP_REQ_WAIT;
  420.             StepD=STEPD_WAIT_YAMAHA;
  421.            }
  422.  
  423.           break;
  424.  
  425.         case STEPD_WAIT_YAMAHA:
  426.           BufferSY22[0]=0xF0;
  427.           Ex->DataPtr=BufferSY22+1;
  428.           Ex->Length=3;
  429.           *StepPtr=STEP_REQ_RECIEVE;
  430.           StepD=STEPD_CHECK_YAMAHA;
  431.  
  432.           break;
  433.  
  434.         case STEPD_CHECK_YAMAHA:
  435.           if (Ex->DataPtr[-3]==0x43 && !(Ex->DataPtr[-2]&0xF0) && Ex->DataPtr[-1]==0x7E)
  436.            {StepD=STEPD_G1P;
  437.             Ex->Length=2;
  438.             *StepPtr=STEP_REQ_RECIEVE;
  439.            }
  440.            else
  441.            {
  442.             *StepPtr=STEP_REQ_COMPLETE;
  443.             Ex->Message=GetString_SY22(&DLi,ERRORD_UNEXPECTED_ANSWER);
  444.             ReturnCode=1;
  445.            }
  446.  
  447.           break;
  448.  
  449.         case STEPD_G1P:
  450.           PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  451.  
  452.           if (BUFFER_SIZE+(BufferSY22-Ex->DataPtr)<PacketLength+1)
  453.            {
  454.             Ex->Message=GetString_SY22(&DLi,ERRORD_TOO_MANY_DATA);
  455.             ReturnCode=1;
  456.             *StepPtr=STEP_REQ_COMPLETE;
  457.            }
  458.            else
  459.            {*StepPtr=STEP_REQ_RECIEVE;
  460.             Ex->Length=PacketLength+1;
  461.             StepD=STEPD_G1P_DATA;
  462.             Ex->Message=Message;
  463.             sprintf(Message,GetString_SY22(&DLi,MSGD_RECIEVEPACKET),1);
  464.            }
  465.  
  466.           break;
  467.  
  468.         case STEPD_G1P_DATA:
  469.           NPackets=1;
  470.  
  471.           if (Type==TYPE_VOICE)
  472.             if (memcmp(&(Ex->DataPtr[-PacketLength-1]),"PK  2203AE",10))
  473.               Type=0;
  474.  
  475.           if (Type==TYPE_ALL)
  476.             if (memcmp(&(Ex->DataPtr[-PacketLength-1]),"PK  2203VM",10))
  477.               Type=0;
  478.  
  479.           if (Type)
  480.            {
  481.             *StepPtr=STEP_REQ_RECIEVE_EOF;
  482.             Ex->Length=2;
  483.             Ex->Data1=0xF7F7F7F7;
  484.             StepD=STEPD_GP_LENGTH;
  485.            }
  486.            else
  487.            {*StepPtr=STEP_REQ_COMPLETE;
  488.             ReturnCode=1;
  489.             Ex->Message=GetString_SY22(&DLi,ERRORD_UNEXPECTED_ANSWER);
  490.            }
  491.  
  492.           break;
  493.  
  494.         case STEPD_GP_LENGTH:
  495.  
  496.           if (Ex->DataPtr[-1]!=0xF7)
  497.            {PacketLength=(((UWORD)Ex->DataPtr[-2])<<7)+Ex->DataPtr[-1];
  498.  
  499.             if (BUFFER_SIZE+(BufferSY22-Ex->DataPtr)<PacketLength+1)
  500.              {Ex->Message=GetString_SY22(&DLi,ERRORD_TOO_MANY_DATA);
  501.               ReturnCode=1;
  502.               *StepPtr=STEP_REQ_COMPLETE;
  503.              }
  504.              else
  505.              {*StepPtr=STEP_REQ_RECIEVE;
  506.               Ex->Length=PacketLength+1;
  507.               StepD=STEPD_GP_DATA;
  508.               Ex->Message=Message;
  509.               sprintf(Message,GetString_SY22(&DLi,MSGD_RECIEVEPACKET),NPackets+1);
  510.              }
  511.            }
  512.            else
  513.            {DataLength=Ex->DataPtr-BufferSY22;
  514.             if (Node=AllocMem(sizeof(struct DumpNode),0L))
  515.              {
  516.               Node->Data=NULL;
  517.               Node->DataLength=0;
  518.               Node->DumpLength=DataLength;
  519.               Node->Name[0]='\0';
  520.               Node->Flags=0;
  521.               Ex->Node=Node;
  522.               strcpy(Node->Type,Type->ln_Name);
  523.               if (Type==TYPE_VOICE)
  524.                {Ex->Message=GetString_SY22(&DLi,MSGD_RECIEVEENDVOICE);
  525.                 memcpy(Node->Name,BufferSY22+19,8);
  526.                 Node->Name[8]='\0';
  527.                }
  528.               if (Type==TYPE_ALL)
  529.                {Ex->Message=GetString_SY22(&DLi,MSGD_RECIEVEENDALL);
  530.                }
  531.               if (Node->Dump=AllocMem(DataLength,0L))
  532.                {memcpy(Node->Dump,BufferSY22,DataLength);
  533.  
  534.                 Ex->DataPtr=(APTR)Node;
  535.                 *StepPtr=STEP_REQ_COMPLETE;
  536.                }
  537.                else
  538.                {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  539.                 ReturnCode=1;
  540.                 *StepPtr=STEP_REQ_COMPLETE;
  541.                 FreeMem(Node,sizeof(struct DumpNode));
  542.                }
  543.              }
  544.              else
  545.              {Ex->Message=GetString_SY22(&DLi,ERRORD_OUT_OF_MEMORY);
  546.               ReturnCode=1;
  547.               *StepPtr=STEP_REQ_COMPLETE;
  548.              }
  549.             FreeMem(BufferSY22,BUFFER_SIZE);
  550.             BufferSY22=0;
  551.            }
  552.  
  553.           break;
  554.  
  555.         case STEPD_GP_DATA:
  556.           NPackets++;
  557.  
  558.           *StepPtr=STEP_REQ_RECIEVE_EOF;
  559.           Ex->Length=2;
  560.           Ex->Data1=0xF7F7F7F7;
  561.           StepD=STEPD_GP_LENGTH;
  562.  
  563.           break;
  564.        }
  565.       break;
  566.  
  567.    }
  568.   return(ReturnCode);
  569. }
  570.  
  571. __saveds struct Node* RecognizeNode(struct DumpNode *Node)
  572. {
  573.   int Dummy;
  574.  
  575.   return (RecognizeNode2(Node,&Dummy));
  576. }
  577.  
  578. struct Node* RecognizeNode2(struct DumpNode *Node,int *Error)
  579. {
  580.   struct Node *Type=NULL;
  581.  
  582.   if (!(*Error=CheckYamaha(Node)))
  583.     if (Node->DumpLength>=18)
  584.       {
  585.         if (!memcmp(&(Node->Dump[6]),"PK  2203AE",10))
  586.             Type=TYPE_VOICE;
  587.            else
  588.             if (!memcmp(&(Node->Dump[6]),"PK  2203VM",10))
  589.               Type=TYPE_ALL;
  590.              else
  591.               *Error=ERRORD_UNKNOWN_TYPE;
  592.       }
  593.  
  594.   return (Type);
  595. }
  596.  
  597. int CheckYamaha(struct DumpNode *Node)
  598. {
  599.   char *Dump;
  600.   char CheckSum;
  601.   short Length;
  602.   char *End;
  603.   int ReturnCode=0;
  604.   int Stop=0;
  605.   long i;
  606.  
  607.   if (Node)
  608.     {
  609.       Dump=Node->Dump;
  610.  
  611.       if (Dump)
  612.         { End=Dump+Node->DumpLength;
  613.           
  614.           if (Node->DumpLength>7)
  615.             if (Dump[1]==0x43)
  616.               if (!(Dump[2]&0xF))
  617.                 if (Dump[3]==0x7E)
  618.                   { Dump+=4;
  619.                     do
  620.                       {
  621.                         CheckSum=0;
  622.                         if (Dump+2<=End)
  623.                           { Length=Dump[1]+(Dump[0]<<7);
  624.                             Dump+=2;
  625.  
  626.                             if (Dump+Length+2<=End)
  627.                               {
  628.                                 for (i=0;i<Length;i++)
  629.                                   CheckSum+=Dump[i];
  630.  
  631.                                 Dump+=Length;
  632.                                 if ((*(Dump++)+CheckSum)& 0x7F)
  633.                                   ReturnCode=ERRORD_BAD_CHECKSUM;
  634.  
  635.                                 if (*Dump=='\xF7')
  636.                                   Stop=1;
  637.                               }
  638.                              else
  639.                               ReturnCode=ERRORD_UNKNOWN_TYPE;
  640.                           }
  641.                          else
  642.                           ReturnCode=ERRORD_UNKNOWN_TYPE;
  643.                       }
  644.                     while (!ReturnCode && !Stop);
  645.                   }
  646.                  else
  647.                   ReturnCode=ERRORD_UNKNOWN_TYPE;
  648.                else
  649.                 ReturnCode=ERRORD_UNKNOWN_TYPE;
  650.              else
  651.               ReturnCode=ERRORD_UNKNOWN_TYPE;
  652.            else
  653.             ReturnCode=ERRORD_UNKNOWN_TYPE;
  654.         }
  655.     }
  656.    else
  657.     ReturnCode=ERRORD_UNKNOWN_TYPE;
  658.  
  659.   return ReturnCode;
  660. }
  661.  
  662. STRPTR GetString_SY22(struct LocaleInfo *li, LONG stringNum)
  663. {
  664. LONG   *l;
  665. UWORD  *w;
  666. STRPTR  builtIn;
  667.  
  668.     l = (LONG *)CatCompBlock;
  669.  
  670.     while (*l != stringNum)
  671.     {
  672.         w = (UWORD *)((ULONG)l + 4);
  673.         l = (LONG *)((ULONG)l + (ULONG)*w + 6);
  674.     }
  675.     builtIn = (STRPTR)((ULONG)l + 6);
  676.  
  677.     if (LocaleBase)
  678.         return(GetCatalogStr(li->li_Catalog,stringNum,builtIn));
  679.  
  680.     return(builtIn);
  681. }
  682.