home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 4 / CD_Magazyn_EXEC_nr_4.iso / Recent / dev / c / GSys.lha / gsys / gmisc / GChunkHandler.cpp next >
Encoding:
C/C++ Source or Header  |  2000-09-17  |  4.9 KB  |  284 lines
  1.  
  2. /* Author Anders Kjeldsen */
  3.  
  4. #ifndef GCHUNKHANDLER_CPP
  5. #define GCHUNKHANDLER_CPP
  6.  
  7. GChunkHandler(GSTRPTR filename, GUWORD sizeid, GUWORD sizesize, BOOL backwards);        // String 
  8. {
  9.     memset((void *)this, 0, sizeof(this));
  10.     if ( InitGBuffer(filename) )
  11.     {
  12.         Current = &Root;
  13.         SizeOfID = sizeid;
  14.         SizeOfSize = sizesize;
  15.         Backwards = backwards;
  16.         Root.Start = Buffer;
  17.         Root.End = (APTR) ((GUBYTE *)Buffer + SizeOfID + SizeOfSize + GetSIZE() );
  18.         return true;
  19.     }
  20.     return false;
  21. }
  22.  
  23. GChunkHandler::~GChunkHandler()
  24. {
  25.     class GChunk *First = Root.Next;
  26.     class GChunk *Next = First->Next;
  27.     while (First)
  28.     {
  29.         delete First;
  30.         First = Next;
  31.         Next = First->Next;
  32.     }
  33. }
  34.  
  35. APTR GChunkHandler::Adjust(LONG Size)
  36. {
  37. //#ifdef GDEBUG
  38.     printf("Adjusting current Chunk by %i\n", Size);
  39. //#endif
  40.     LONG New = (LONG) Current->Start;
  41.     New+=Size;
  42.     Current->Start = (APTR) New;
  43.     return Current;
  44. }
  45.  
  46. APTR GChunkHandler::EnterChunk()
  47. {
  48. //#ifdef GDEBUG
  49.     char TempText[5];
  50.     TempText[4] = 0;
  51.     
  52.     ((ULONG *)TempText)[0] = GetID();
  53.     printf("Entering Chunk '");
  54.     printf(TempText);
  55.     printf("'.\n");
  56. //#endif
  57.     class GChunk *Prev = Current;
  58.     Current->Next = new GChunk;
  59.     Current->Next->Prev = Current;
  60.     Current = Current->Next;
  61.     Current->Start = (APTR) ((UBYTE *)Prev->Start + SizeOfID + SizeOfSize);
  62.     Current->End = (APTR) ((UBYTE *)Current->Start + SizeOfID + SizeOfSize + GetSIZE() );
  63.  
  64. //#ifdef GDEBUG
  65.     ((ULONG *)TempText)[0] = GetID();
  66.     printf("First chunk found is '");
  67.     printf(TempText);
  68.     printf("'.\n");
  69. //#endif
  70.  
  71.     return Current->Start;
  72. }
  73.  
  74. APTR GChunkHandler::NextChunk()
  75. {
  76.     char TempText[5];
  77.     TempText[4] = 0;
  78.  
  79.     if (Current->Start < Current->Prev->End)
  80.     {
  81.         Current->Start = (APTR) ( (UBYTE *)Current->Start + SizeOfID + SizeOfSize + GetSIZE() );
  82.         Current->End = (APTR) ((UBYTE *)Current->Start + SizeOfID + SizeOfSize + GetSIZE() );
  83.         if (Current->Start < Current->Prev->End)
  84.         {
  85.  
  86. //#ifdef GDEBUG
  87.             ((ULONG *)TempText)[0] = GetID();
  88.             printf("Jumped to Chunk '");
  89.             printf(TempText);
  90.             printf("'.\n");
  91. //#endif
  92.             return Current->Start;
  93.         }
  94.         else
  95.         {
  96. //#ifdef GDEBUG
  97.             ((ULONG *)TempText)[0] = GetID();
  98.             printf("Could NOT jump to Chunk '");
  99.             printf(TempText);
  100.             printf("'!\n");
  101. //#endif
  102.  
  103.             return NULL;
  104.         }
  105.     }
  106.     else
  107.     {
  108. //#ifdef GDEBUG
  109.         ((ULONG *)TempText)[0] = GetID();
  110.         printf("Could NOT jump to Chunk '");
  111.         printf(TempText);
  112.         printf("'!\n");
  113. //#endif
  114.  
  115.         return NULL;
  116.     }
  117. }
  118.  
  119. APTR GChunkHandler::ParentChunk()
  120. {
  121. //#ifdef GDEBUG
  122.     char TempText[5];
  123.     TempText[4] = 0;
  124. //#endif
  125.  
  126.     if (Current->Prev)
  127.     {
  128.         Current = Current->Prev;
  129.         delete Current->Next;
  130.         Current->Next = NULL;
  131.  
  132. //#ifdef GDEBUG
  133.         ((ULONG *)TempText)[0] = GetID();
  134.         printf("Returned to Chunk '");
  135.         printf(TempText);
  136.         printf("'!\n");
  137. //#endif
  138.  
  139.  
  140.         return Current->Start;
  141.     }
  142.     else return NULL;
  143. }
  144.  
  145. APTR GChunkHandler::FindChunk(ULONG FindID)
  146. {
  147. //#ifdef GDEBUG
  148.     char TempText[5];
  149.     TempText[4] = 0;
  150.     
  151.     ((ULONG *)TempText)[0] = FindID;
  152.     printf("Searching for Chunk '");
  153.     printf(TempText);
  154.     printf("'.\n");
  155. //#endif
  156.  
  157.     ULONG IDtemp = GetID();
  158.  
  159.     while (IDtemp != FindID)
  160.     {
  161.         if (NextChunk())
  162.         {
  163.             IDtemp = GetID();
  164.         }
  165.         else
  166.         {
  167. #ifdef GDEBUG
  168.             printf("Search for '");
  169.             printf(TempText);
  170.             printf("' was NOT succesfull!\n");
  171. #endif
  172.             return NULL;
  173.         }
  174.     }
  175. //#ifdef GDEBUG
  176.     printf("Search for '");
  177.     printf(TempText);
  178.     printf("' was succesfull.\n");
  179. //#endif
  180.  
  181.     return Current->Start;
  182. }
  183.  
  184. APTR GChunkHandler::FindChunk(char *FindTextID, ULONG SIZE)    // MAX 4 CHARS
  185. {
  186. //#ifdef GDEBUG
  187.     printf("Searching for Chunk '");
  188.     printf(FindTextID);
  189.     printf("'.\n");
  190. //#endif
  191.     ULONG FindID = NULL;
  192.     switch (SIZE)
  193.     {
  194.         case SIZELONG:
  195.             FindID = (ULONG) ((ULONG *)FindTextID)[0];
  196.         break;
  197.         case SIZEWORD:
  198.             FindID = (ULONG) ((UWORD *)FindTextID[0]);
  199.         break;
  200.     }
  201.  
  202.     ULONG IDtemp = GetID();
  203.  
  204.     while (IDtemp != FindID)
  205.     {
  206.         if (NextChunk())
  207.         {
  208.             IDtemp = GetID();
  209.         }
  210.         else 
  211.         {
  212. //#ifdef GDEBUG
  213.             printf("Search for Chunk '");
  214.             printf(FindTextID);
  215.             printf("'. was NOT succesful!\n");
  216. //#endif
  217.             return NULL;
  218.         }
  219.     }
  220. //#ifdef GDEBUG
  221.     printf("Search for Chunk '");
  222.     printf(FindTextID);
  223.     printf("' was succesful.\n");
  224. //#endif
  225.  
  226.     return Current->Start;
  227. }
  228.  
  229.  
  230. ULONG GChunkHandler::GetID()
  231. {
  232.     switch (SizeOfID)
  233.     {
  234.         case SIZELONG:
  235.             return GetLong(Current->Start);
  236.         break;
  237.         case SIZEWORD:
  238.             return (ULONG) GetWord(Current->Start);
  239.         break;
  240.     }
  241. }
  242.  
  243. ULONG GChunkHandler::GetSIZE()
  244. {
  245.     switch (SizeOfSize)
  246.     {
  247.         case SIZELONG:
  248.             return GetLong( (APTR) ((UBYTE*)Current->Start + SizeOfID) );
  249.         break;
  250.         case SIZEWORD:
  251.             return (ULONG) GetWord( (APTR) ((UBYTE*)Current->Start + SizeOfID) );
  252.         break;
  253.     }
  254. }
  255.  
  256. APTR GChunkHandler::GetEND()
  257. {
  258.     return Current->End;
  259. }
  260.  
  261. ULONG GChunkHandler::GetLong(APTR DATA)
  262. {
  263.     UBYTE *data = (UBYTE *)DATA;
  264.  
  265.     if (Backwards)
  266.     return    ( ((ULONG)data[3])<<24 ) +
  267.         ( ((ULONG)data[2])<<16 ) +
  268.         ( ((ULONG)data[1])<<8 ) +
  269.         (ULONG)data[0];
  270.     else
  271.     return    ( (ULONG *) DATA)[0];
  272. }
  273.  
  274. UWORD GChunkHandler::GetWord(APTR DATA)
  275. {
  276.     UBYTE *data = (UBYTE *)DATA;
  277.     if (Backwards)
  278.     return    ( ((UWORD)data[1])<<8 ) +
  279.         (WORD)data[0];
  280.     else
  281.     return    ((WORD *) DATA)[0];
  282. }
  283.  
  284. #endif /* GCHUNKHANDLER_CPP */