home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / w3_syst / setup.arj / PARSE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-25  |  13.0 KB  |  434 lines
  1. // PARSE.C  -- The code to parse .INF blocks into their respective
  2. //             data strcutures
  3.  
  4. /*****************************************************************************
  5.  
  6. Functions:
  7. ------------------------------------------------------------------------------
  8.  
  9. JunkCharacter                Returns TRUE if this is a white space char.
  10.  
  11. LoadLine                     Copies a single line from the cached .INF
  12.                              section into the Line array. Max 132 chars.
  13.  
  14. ParseLine                    Takes the next DoubleQuote delimited token
  15.                              from the Line array.
  16.  
  17. AddDiskInfo                  These routines fill the DiskInfo data structure
  18. FillDiskInfoStructures       [disks]
  19.  
  20. SetFlags                     These routines fill the FileInfo data structure
  21. AddFileInfo                  [apps]
  22. FillFileInfoStructures       
  23.  
  24. AddDirInfo                   These routines fill the DirInfo data structure
  25. FillDirInfoStructures        [directories]
  26.  
  27. AddProgmanInfo               These routines fill the PManInfo data strcutures
  28. FillProgmanInfoStructures    [progman]
  29.  
  30. TokenValue                   These routines fill the miscelleneous data
  31. FillGlobalInfoStructures     strucutres. [setup]
  32.  
  33. *****************************************************************************/
  34.  
  35.  
  36. #include <windows.h>
  37. #include <stdio.h>
  38. #include "bincode.h"
  39.  
  40. LPSTR   szCurrentBuffer;    // Points to the current line
  41. char    Line[132];          // Holds the current line
  42.  
  43. /********************************************************************/
  44. BOOL JunkCharacter ( char Letter )
  45. {
  46.   // Returns TRUE if character is whitespace.
  47.  
  48.  
  49.   switch ( Letter )
  50.     {
  51.     case ' ' :
  52.     case '\t':
  53.     case 10  :
  54.     case 13  : return TRUE;
  55.     default  : return FALSE;
  56.     }
  57. } 
  58. /********************************************************************/
  59. BOOL LoadLine (void)
  60. {
  61.   // returns TRUE if line loaded, FALSE if EOF
  62.  
  63.   BOOL ValidLine = TRUE;
  64.   int  LineIndex = 0;
  65.  
  66.   // This will load in the next non-comment line
  67.  
  68.   // First, skip the spaces and CR/LF's, and comments
  69.   
  70.   do
  71.     {
  72.     while (JunkCharacter(*szCurrentBuffer) && (*szCurrentBuffer)) szCurrentBuffer++;
  73.  
  74.     if (!(*szCurrentBuffer)) return FALSE;
  75.  
  76.     ValidLine = TRUE;
  77.     if (';' == *szCurrentBuffer)
  78.       {
  79.       ValidLine = FALSE;
  80.       while (*szCurrentBuffer != 13) szCurrentBuffer++;  // skip to EOLN
  81.       }
  82.     }
  83.   while (!ValidLine);
  84.  
  85.   do
  86.     {
  87.     Line[LineIndex] = *szCurrentBuffer;
  88.     szCurrentBuffer++;
  89.     LineIndex++;
  90.     }
  91.   while ((*szCurrentBuffer) && (*szCurrentBuffer != 13));
  92.  
  93.   // Even if this is EOF, nect call with return the false OK.
  94.  
  95.   Line[LineIndex] = 0;
  96.  
  97.   return TRUE;
  98. }  
  99. /********************************************************************/
  100. void ParseLine ( char *DestBuffer, int *Index )
  101. {
  102.   // This will grab the next QUOTED string
  103.   
  104.   *DestBuffer = 0;
  105.  
  106.   // Move to the first quote;
  107.  
  108.   while (( Line[*Index] ) && (Line[*Index] != '\"')) (*Index)++;
  109.  
  110.   if (!(Line[*Index])) return;  // NULL String, item doesn't exist
  111.  
  112.   (*Index)++;  // Start at next character
  113.  
  114.   while (( Line[*Index] ) && (Line[*Index] != '\"')) 
  115.     {
  116.     *DestBuffer = Line[*Index];
  117.     DestBuffer++;
  118.     (*Index)++;
  119.     }
  120.  
  121.   *DestBuffer = 0;  // Add a terminating char
  122.   if (*Index) (*Index)++;  // Advance over ending quote if possible
  123. }    
  124. /********************************************************************/
  125. void AddDiskInfo ( void )
  126. {
  127.   // This will parse out whatever is in Line, and add it to
  128.   // the DISKINFO structure...
  129.  
  130.   int   LineIndex;
  131.   char  Item[80];
  132.  
  133.   LineIndex = 0;
  134.  
  135.   ParseLine ( Item, &LineIndex );
  136.   DiskInfo[NumDisks].DiskNumber = *Item;
  137.   ParseLine ( DiskInfo[NumDisks].szSrcDir, &LineIndex );
  138.   ParseLine ( DiskInfo[NumDisks].szDiskTitle, &LineIndex );
  139.   NumDisks++;
  140. }
  141. /********************************************************************/
  142. /*                                                                  */
  143. /*   FillDiskInfoStructures (void)                                  */
  144. /*                                                                  */
  145. /*   This routine reads the [disks] section and fills the           */
  146. /*   structures appropriately.                                      */
  147. /*                                                                  */
  148. /********************************************************************/
  149. void FillDiskInfoStructures ( void )
  150. {
  151.  
  152.   NumDisks = 0;
  153.  
  154.   hBuffer = GlobalAlloc ( GMEM_MOVEABLE | GMEM_ZEROINIT, SECTIONSIZE+1 );
  155.  
  156.   PositionInfPointer ( (LPSTR)"disks" );
  157.  
  158.   szCurrentBuffer = GlobalLock ( hBuffer );
  159.  
  160.   while ( LoadLine()) AddDiskInfo ();       // Fill the structrures
  161.  
  162.   GlobalUnlock ( hBuffer );
  163.   GlobalFree ( hBuffer );
  164. }
  165. /********************************************************************/
  166. void SetFlags ( char *Item, int *ListBoxIndex )
  167. {
  168.   // Defaults...
  169.  
  170. #ifdef COMPLEXSETUP
  171.   FileInfo[NumFiles].bSelected    = FALSE;
  172. #endif
  173. #ifdef SIMPLESETUP
  174.   FileInfo[NumFiles].bSelected    = TRUE;
  175. #endif
  176.   FileInfo[NumFiles].bInvisible   = TRUE;
  177.   FileInfo[NumFiles].bProgmanIcon = FALSE;
  178.   FileInfo[NumFiles].ExtraFiles   = 0;
  179.   FileInfo[NumFiles].bCompressed  = FALSE; 
  180.  
  181.   while (*Item)
  182.     {
  183.     switch (toupper(*Item))
  184.       {
  185.       case 'R': FileInfo[NumFiles].bSelected  = TRUE;  
  186.                 Item++; 
  187.                 break;
  188.  
  189.       case 'C': FileInfo[NumFiles].bCompressed = TRUE;  
  190.                 Item++; 
  191.                 break;
  192.  
  193.       case 'D': (*ListBoxIndex)++;
  194.                 FileInfo[NumFiles].bInvisible = FALSE; 
  195.                 Item++; 
  196.                 break;
  197.  
  198.       case 'I': FileInfo[NumFiles].bProgmanIcon = TRUE;
  199.                 Item++;
  200.                 FileInfo[NumFiles].ProgmanGroupNumber = *Item;
  201.                 Item++;
  202.                 break;
  203.  
  204.       case '0':
  205.       case '1':
  206.       case '2':
  207.       case '3':
  208.       case '4':
  209.       case '5':
  210.       case '6':
  211.       case '7':
  212.       case '8':
  213.       case '9': FileInfo[NumFiles].ExtraFiles = ((*Item)-'0') * 10;
  214.                 Item++;
  215.                 FileInfo[NumFiles].ExtraFiles = ((*Item)-'0');
  216.                 Item++;
  217.                 break;
  218.  
  219.       default : Item++; break;  // Skip over bogus flags
  220.  
  221.       }   // switch
  222.     }  // while
  223. }
  224. /********************************************************************/
  225. void AddFileInfo ( int *ListBoxIndex )
  226. {
  227.   // This will parse out whatever is in Line, and add it to
  228.   // the FILEINFO structure...
  229.  
  230.   int   LineIndex;
  231.   char  Item[80];
  232.  
  233.   LineIndex = 0;
  234.  
  235.   ParseLine ( Item, &LineIndex );
  236.   FileInfo[NumFiles].DiskNumber = *Item;
  237.  
  238.   ParseLine ( Item, &LineIndex );    // Get the Flags
  239.   SetFlags ( Item, ListBoxIndex );  // Go figure them out!
  240.  
  241.   FileInfo[NumFiles].Index = *ListBoxIndex;
  242.  
  243.   ParseLine ( Item, &LineIndex );  // Get the Flags
  244.   FileInfo[NumFiles].DirectoryNumber = *Item;
  245.  
  246.   ParseLine ( FileInfo[NumFiles].szMasterSrcDir, &LineIndex );
  247.   ParseLine ( FileInfo[NumFiles].szFileName, &LineIndex );
  248.   ParseLine ( FileInfo[NumFiles].szProgManName, &LineIndex );
  249.   ParseLine ( FileInfo[NumFiles].szDescription, &LineIndex );
  250.  
  251.   if ((!FileInfo[NumFiles].szDescription[0]) && (NumFiles))
  252.     sprintf (FileInfo[NumFiles].szDescription,FileInfo[NumFiles-1].szDescription);
  253.  
  254.   ParseLine ( FileInfo[NumFiles].szComment, &LineIndex );
  255.  
  256.   ParseLine ( Item, &LineIndex );  // Get the Flags
  257.   FileInfo[NumFiles].BytesRequired = (LONG)atoi(Item)*1024L;
  258.  
  259.   NumFiles++;
  260. }  
  261. /********************************************************************/
  262. /*                                                                  */
  263. /*   FillFileInfoStructures (void)                                  */
  264. /*                                                                  */
  265. /*   This routine reads the [apps] section and fills the FILEINFO   */
  266. /*   structures appropriately.                                      */
  267. /*                                                                  */
  268. /********************************************************************/
  269. void FillFileInfoStructures ( void )
  270. {
  271.   int  ListBoxIndex;
  272.  
  273.   NumFiles     = 0;
  274.   ListBoxIndex = -1;
  275.  
  276.   hBuffer = GlobalAlloc ( GMEM_MOVEABLE | GMEM_ZEROINIT, SECTIONSIZE+1 );
  277.  
  278.   PositionInfPointer ( (LPSTR)"apps" );
  279.  
  280.   szCurrentBuffer = GlobalLock ( hBuffer );
  281.  
  282.   while ( LoadLine()) AddFileInfo ( &ListBoxIndex );       // Fill the structures
  283.  
  284.   GlobalUnlock ( hBuffer );
  285.   GlobalFree ( hBuffer );
  286. }
  287. /********************************************************************/
  288. void AddDirInfo ( void )
  289. {
  290.   // This will parse out whatever is in Line, and add it to
  291.   // the DIRINFO structure...
  292.  
  293.   // MEGA ASSUMTION!: We assume that the .INF file is set
  294.   //                  up right, i.e. no gaps in the sequence
  295.  
  296.   int   LineIndex;
  297.   char  Item[80];
  298.   int   DirNum;
  299.  
  300.   LineIndex = 0;
  301.  
  302.   ParseLine ( Item, &LineIndex );
  303.  
  304.   if ('0' == *Item) 
  305.     DirNum = 0;
  306.   else
  307.     DirNum = toupper(*Item) - 'A' + 1;
  308.  
  309.   NumDirs++;
  310.  
  311.   ParseLine ( DirInfo[DirNum].szDirectory,   &LineIndex );
  312.   ParseLine ( DirInfo[DirNum].szDescription, &LineIndex );
  313.  
  314. }  
  315. /********************************************************************/
  316. /*                                                                  */
  317. /*   FillDIrInfoStructures (void)                                   */
  318. /*                                                                  */
  319. /*   This routine reads the [directories] section and fills the     */
  320. /*   DIRINFO structures appropriately.                              */
  321. /*                                                                  */
  322. /********************************************************************/
  323. void FillDirInfoStructures ( void )
  324. {
  325.   NumDirs     = 0;
  326.  
  327.   hBuffer = GlobalAlloc ( GMEM_MOVEABLE | GMEM_ZEROINIT, SECTIONSIZE+1 );
  328.  
  329.   PositionInfPointer ( (LPSTR)"directories" );
  330.  
  331.   szCurrentBuffer = GlobalLock ( hBuffer );
  332.  
  333.   while ( LoadLine()) AddDirInfo ( );       // Fill the structures
  334.  
  335.   GlobalUnlock ( hBuffer );
  336.   GlobalFree ( hBuffer );
  337. }
  338. /********************************************************************/
  339. void AddProgmanInfo ( void )
  340. {
  341.   // This will parse out whatever is in Line, and add it to
  342.   // the PMANINFO structure...
  343.  
  344.   // MEGA ASSUMTION!: We assume that the .INF file is set
  345.   //                  up right, i.e. no gaps in the sequence
  346.  
  347.   int   LineIndex;
  348.   char  Item[80];
  349.   int   GroupNum;
  350.  
  351.   LineIndex = 0;
  352.  
  353.   ParseLine ( Item, &LineIndex );
  354.   GroupNum = toupper(*Item) - 'A';
  355.  
  356.   NumPManGroups++;
  357.  
  358.   ParseLine ( PManInfo[GroupNum].szCaption,       &LineIndex );
  359.   ParseLine ( PManInfo[GroupNum].szGroupFilename, &LineIndex );
  360. }  
  361. /********************************************************************/
  362. /*                                                                  */
  363. /*   FillFileInfoStructures (void)                                  */
  364. /*                                                                  */
  365. /*   This routine reads the [apps] section and fills the FILEINFO   */
  366. /*   structures appropriately.                                      */
  367. /*                                                                  */
  368. /********************************************************************/
  369. void FillProgmanInfoStructures ( void )
  370. {
  371.   NumPManGroups     = 0;
  372.  
  373.   hBuffer = GlobalAlloc ( GMEM_MOVEABLE | GMEM_ZEROINIT, SECTIONSIZE+1 );
  374.  
  375.   PositionInfPointer ( (LPSTR)"progman" );
  376.  
  377.   szCurrentBuffer = GlobalLock ( hBuffer );
  378.  
  379.   while ( LoadLine()) AddProgmanInfo ( );       // Fill the structures
  380.  
  381.   GlobalUnlock ( hBuffer );
  382.   GlobalFree ( hBuffer );
  383. }
  384. /********************************************************************/
  385. int TokenValue ( char *Item )
  386. {
  387.   if (!strcmp ( Item, "PACKAGENAME" )) return ID_PACKAGENAME;
  388.   if (!strcmp ( Item, "CAPTIONNAME" )) return ID_CAPTIONNAME;
  389.  
  390.   return 0;
  391. }
  392. /********************************************************************/
  393. /*                                                                  */
  394. /*   FillGlobalInfoStructures (void)                                */
  395. /*                                                                  */
  396. /*   This routine reads the [setup] section and fills the global    */
  397. /*   structures appropriately.                                      */
  398. /*                                                                  */
  399. /********************************************************************/
  400. void FillGlobalInfoStructures ( void )
  401. {
  402.   char Item[80];
  403.   int  LineIndex;
  404.  
  405.   NumPManGroups     = 0;
  406.  
  407.   hBuffer = GlobalAlloc ( GMEM_MOVEABLE | GMEM_ZEROINIT, SECTIONSIZE+1 );
  408.  
  409.   PositionInfPointer ( (LPSTR)"setup" );
  410.  
  411.   szCurrentBuffer = GlobalLock ( hBuffer );
  412.  
  413.   while ( LoadLine())
  414.     {
  415.     LineIndex = 0;  
  416.  
  417.     ParseLine ( Item, &LineIndex );
  418.  
  419.     switch ( TokenValue ( Item ))
  420.       {
  421.       case ID_PACKAGENAME : ParseLine (szPackageName, &LineIndex); break;
  422.       case ID_CAPTIONNAME : ParseLine (szCaptionName, &LineIndex); break;
  423.       default          : break;
  424.       }
  425.     }
  426.  
  427.   GlobalUnlock ( hBuffer );
  428.   GlobalFree ( hBuffer );
  429. }
  430.  
  431.  
  432.  
  433.  
  434.