home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / PTR-TCL v2.1 / Support / Exception Check / Munge.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-07  |  6.4 KB  |  325 lines  |  [TEXT/MMCC]
  1. /*
  2.  * munge.c
  3.  */
  4.  
  5. #include <string.h>
  6.  
  7. #define isalfa(x) ((((x)>='A')&&((x)<='Z'))||(((x)>='a')&&((x)<='z'))||((x)=='_')||(((x)>='0')&&((x)<='9')))
  8.  
  9. extern void Idle ( void ) ;
  10. extern short vRefNum ;
  11. void MungeFolder ( long parID ) ;
  12. extern void Message ( unsigned char * ) ;
  13. extern Boolean DoLine ( unsigned char * line ) ;
  14.  
  15.  
  16. CInfoPBRec rec ;
  17. short err ;
  18. Str63 name ;
  19. Str255 str ;
  20. short lineNo ;
  21.  
  22.  
  23. static void
  24. CopyP ( unsigned char * from , unsigned char * to ) {
  25.     BlockMove ( from , to , 1 + * from ) ;
  26. }
  27.  
  28.  
  29. static void
  30. ConcP ( unsigned char * to , unsigned char * tail ) {
  31.  
  32. short len = * tail ;
  33.     if ( len + * to > 255 ) {
  34.         len = 255 - * to ;
  35.     }
  36.     BlockMove ( tail + 1 , to + * to + 1 , len ) ;
  37.     * to += len ;
  38. }
  39.  
  40.  
  41. static void
  42. ErrMsg ( unsigned char * why , unsigned char * file , short code ) {
  43.  
  44. Str15 nn ;
  45. long tick ;
  46. static long lastBeep = 0 ;
  47.  
  48.     NumToString ( code , nn ) ;
  49.     CopyP ( "\p ERROR " , str ) ;
  50.     ConcP ( str , why ) ;
  51.     ConcP ( str , "\p " ) ;
  52.     ConcP ( str , nn ) ;
  53.     ConcP ( str , "\p\r" ) ;
  54.     Message ( str ) ;
  55.     tick = TickCount ( ) + 30 ;
  56.     if ( lastBeep < tick - 600 ) { /* Only beep every 10 seconds if lots of errors */
  57.         SysBeep ( 20 ) ;
  58.         lastBeep = tick ;
  59.     }
  60.     do {
  61.         Idle ( ) ;
  62.     } while ( TickCount ( ) < tick ) ;
  63. }
  64.  
  65.  
  66. static long
  67. GetLine ( Handle text , long pos , unsigned char * into ) {
  68.  
  69. long end = GetHandleSize ( text ) ;
  70.  
  71.     lineNo ++ ;
  72.     * into = 0 ;
  73.     while ( pos < end ) {
  74.         if ( * into == 255 ) {
  75.             ErrMsg ( "\pLong Line!" , "\pLine" , lineNo ) ;
  76.             return pos ;
  77.         }
  78.         ( * into ) ++ ;
  79.         into [ * into ] = ( * text ) [ pos ] ;
  80.         pos ++ ;
  81.         if ( into [ * into ] == '\r' ) {
  82.             return pos ;
  83.         }
  84.     }
  85.     return pos ;
  86. }
  87.  
  88.  
  89. static long
  90. PutLine ( Handle text , long pos , long len , unsigned char * str ) {
  91.     ConcP ( str , "\p// " ) ; /* Comment out old line */
  92.     Munger ( text , pos , NULL , 0L , str + 1 , * str ) ;
  93.     return pos + len + * str ;
  94. }
  95.  
  96. static long
  97. token ( Handle text , long pos , long end , char * tok ) {
  98.  
  99. char ch ;
  100. Boolean f = 0 ;
  101.  
  102.     while ( pos < end ) {
  103.         ch = ( * text ) [ pos ] ;
  104.         pos ++ ;
  105.         if ( isalfa ( ch ) ) {
  106.             f = 1 ;
  107.             * ( tok ++ ) = ch ;
  108.         } else {
  109.             if ( f ) {
  110.                 * tok = 0 ;
  111.                 if ( ch == '\r' ) {
  112.                     pos -- ;
  113.                 }
  114.                 return pos ;
  115.             }
  116.             if ( ch == '\r' ) {
  117.                 * tok = ch ;
  118.                 tok [ 1 ] = 0 ;
  119.                 return pos ;
  120.             }
  121.         }
  122.     }
  123.     return pos ;
  124. }
  125.  
  126.  
  127. /* This function contains the total text of a TEXT file. */
  128. /* The contents of the handle will be re-written to disk when done if true returned. */
  129. /* Call Idle ( ) now and then for lengthy tasks */
  130. static Boolean
  131. MungeHandle ( Handle text ) {
  132.  
  133. long end = GetHandleSize ( text ) ;
  134. long pos = 0 ;
  135. int level = 0 ;
  136. char tok [ 256 ] ;
  137. Boolean aGoto = 0 ;
  138. Boolean aReturn = 0 ;
  139. Boolean aGotoOK = 0 ;
  140. Boolean aReturnOK = 0 ;
  141. Boolean aNL = 0 ;
  142. long line = 0 ;
  143. Str255 ss ;
  144. Str15 num ;
  145. Boolean aDec = 0 ;
  146.  
  147.     while ( pos < end ) {
  148.         aDec = 0 ;
  149.         pos = token ( text , pos , end , tok ) ;
  150.         if ( ! strcmp ( tok , "TRY" ) || ! strcmp ( tok , "TRY_MULTIPLE" ) ) {
  151.             level ++ ;
  152.         } else
  153.         if ( ! strcmp ( tok , "ENDTRY" ) || ! strcmp ( tok , "DONE" ) ) {
  154.             aNL = 1 ;
  155.             aDec = 1 ;
  156.         } else
  157.         if ( ! strcmp ( tok , "goto" ) ) {
  158.             aGoto = 1 ;
  159.         } else
  160.         if ( ! strcmp ( tok , "return" ) ) {
  161.             aReturn = 1 ;
  162.         } else
  163.         if ( ! strcmp ( tok , "\r" ) ) {
  164.             line ++ ;
  165.             aNL = 1 ;
  166.         } else
  167.         if ( ! strcmp ( tok , "GOTO_OK" ) ) {
  168.             aGotoOK = 1 ;
  169.         } else
  170.         if ( ! strcmp ( tok , "RETURN_OK" ) ) {
  171.             aReturnOK = 1 ;
  172.         }
  173.         if ( aGotoOK ) {
  174.             aGoto = 0 ;
  175.         }
  176.         if ( aReturnOK ) {
  177.             aReturn = 0 ;
  178.         }
  179.         if ( aNL ) {
  180.             if ( level ) {
  181.                 if ( aReturn ) {
  182.                     CopyP ( "\p RETURN error line " , ss ) ;
  183.                     NumToString ( line , num ) ;
  184.                     ConcP ( ss , num ) ;
  185.                     Message ( ss );
  186.                 }
  187.                 if ( aGoto ) {
  188.                     CopyP ( "\p GOTO error line " , ss ) ;
  189.                     NumToString ( line , num ) ;
  190.                     ConcP ( ss , num ) ;
  191.                     Message ( ss );
  192.                 }
  193.             }
  194.             if ( aDec ) {
  195.                 level -- ;
  196.             }
  197.             if ( level < 0 ) {
  198.                 CopyP ( "\p level error line " , ss ) ;
  199.                 NumToString ( line , num ) ;
  200.                 ConcP ( ss , num ) ;
  201.                 Message ( ss );
  202.             }
  203.             aNL = 0 ;
  204.             aGoto = 0 ;
  205.             aReturn = 0 ;
  206.             aGotoOK = 0 ;
  207.             aReturnOK = 0 ;
  208.             if ( ! ( line % 10 ) ) {
  209.                 Idle ( ) ;
  210.             }
  211.         }
  212.     }
  213.  
  214.     if ( level ) {
  215.         Message ( "\p END level error" ) ;
  216.     }
  217.     return false ;
  218. }
  219.  
  220.  
  221. static void
  222. MungeFile ( short vRef , long parID , unsigned char * fn ) {
  223.  
  224. Handle text ;
  225. short ref = 0 ;
  226. long size ;
  227. Boolean doWrite ;
  228.  
  229.     Message ( fn ) ;
  230.  
  231.     err = HOpenDF ( vRef , parID , fn , fsRdWrPerm , & ref ) ;
  232.     if ( err ) {
  233.         ErrMsg ( "\pOpening" , fn , err ) ;
  234.         return ;
  235.     }
  236.     err = GetEOF ( ref , & size ) ;
  237.     if ( ! err ) {
  238.         err = SetFPos ( ref , fsFromStart , 0L ) ;
  239.     }
  240.     if ( err ) {
  241.         ErrMsg ( "\pStarting" , fn , err ) ;
  242.         FSClose ( ref ) ;
  243.         return ;
  244.     }
  245.     text = NewHandle ( size ) ;
  246.     if ( ! text ) {
  247.         ErrMsg ( "\pAllocating" , fn , MemError ( ) ) ;
  248.         FSClose ( ref ) ;
  249.         return ;
  250.     }
  251.     HLock ( text ) ;
  252.     err = FSRead ( ref , & size , * text ) ;
  253.     if ( err ) {
  254.         ErrMsg ( "\pReading" , fn , err ) ;
  255.         FSClose ( ref ) ;
  256.         DisposeHandle ( text ) ;
  257.     }
  258.     HUnlock ( text ) ;
  259.     doWrite = MungeHandle ( text ) ;
  260.     if ( doWrite ) {
  261.         size = GetHandleSize ( text ) ;
  262.         err = SetEOF ( ref , size ) ;
  263.         if ( ! err ) {
  264.             err = SetFPos ( ref , fsFromStart , 0L ) ;
  265.         }
  266.         if ( err ) {
  267.             ErrMsg ( "\pFinishing" , fn , err ) ;
  268.             FSClose ( ref ) ;
  269.             DisposeHandle ( text ) ;
  270.             return ;
  271.         }
  272.         HLock ( text ) ;
  273.         err = FSWrite ( ref , & size , * text ) ;
  274.         if ( err ) {
  275.             ErrMsg ( "\pWriting" , fn , err ) ;
  276.             FSClose ( ref ) ;
  277.             DisposeHandle ( text ) ;
  278.             return ;
  279.         }
  280.     }
  281.     err = FSClose ( ref ) ;
  282.     if ( doWrite && ! err ) {
  283.         err = FlushVol ( NULL , vRef ) ;
  284.     }
  285.     DisposeHandle ( text ) ;
  286.     if ( err ) {
  287.         ErrMsg ( "\pClosing" , fn , err ) ;
  288.     }
  289.     Message ( "\p DONE\r" ) ;
  290. }
  291.  
  292.  
  293. void
  294. MungeFolder ( long parID ) {
  295.  
  296. short ix ;
  297.  
  298.     for ( ix = 1 ; ix > 0 ; ix ++ ) {
  299.         rec . hFileInfo . ioCompletion = 0L ;
  300.         rec . hFileInfo . ioFVersNum = 0 ;
  301.         rec . hFileInfo . ioNamePtr = name ;
  302.         rec . hFileInfo . ioVRefNum = vRefNum ;
  303.         rec . hFileInfo . ioDirID = parID ;
  304.         rec . hFileInfo . ioFDirIndex = ix ;
  305.         err = PBGetCatInfoAsync ( & rec ) ;
  306.         do {
  307.             Idle ( ) ;
  308.         } while ( rec . hFileInfo . ioResult == 1 ) ;
  309.         err = rec . hFileInfo . ioResult ;
  310.         if ( err ) {
  311.             break ;
  312.         }
  313.         if ( rec . hFileInfo . ioFlAttrib & 0x10 ) { /* Folder */
  314.             CopyP ( "\p\r•Entering Folder " , str ) ;
  315.             ConcP ( str , name ) ;
  316.             ConcP ( str , "\p\r" ) ;
  317.             Message ( str ) ;
  318.             MungeFolder ( rec . hFileInfo . ioDirID ) ;
  319.             Message ( "\p---- Leaving folder ----\r\r" ) ;
  320.         } else if ( rec . hFileInfo . ioFlFndrInfo . fdType == 'TEXT' ) {
  321.             MungeFile ( vRefNum , parID , name ) ;
  322.         }
  323.     }
  324. }
  325.