home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / MAXMA003.ZIP / MAX-MAG.C < prev    next >
C/C++ Source or Header  |  1998-04-13  |  10KB  |  325 lines
  1. //<c>   Copyright 1997-1998 by Gerry J. Danen; all rights reserved.
  2.  
  3. //<t>   Generate Maximus Message Areas
  4.  
  5. //      Compiled with Microsoft C 8.00. Requires DANEN library to recompile.
  6. //      Source released into the Public Domain.
  7.  
  8. #define DEBUG 0
  9.  
  10. //      %0 file-in file-out
  11.  
  12. //      file-in format:
  13. //      name dlarea desc
  14. //      NEW o:\fil\new\ New Files
  15. //      =FileDivisionBegin <name> <rest of info>
  16. //      =FileDivisionEnd
  17. //      =Type
  18.  
  19. //FileArea NEW
  20. //      ACS             Demoted *
  21. //      Desc            New Files
  22. //      Download        O:\FIL\NEW\                                         ;
  23. //      Upload          O:\FIL\UNCHECK\ *                                   ;
  24. //End FileArea
  25.  
  26. //      file-out format:
  27. //      see MSGAREA.CTL
  28.  
  29.  
  30. #include"gd_tools.h"
  31. #include"gd_extrn.h"
  32. #include"gd_kb.h"
  33.  
  34.  
  35. #define pgVERS_ "V2.00"
  36. #define pgTITL_ "Generate Message Area data to update MSGAREA.CTL in Maximus BBS"
  37. #define pgCOPR_ "1997"
  38.  
  39.  
  40. #define BUFSIZE 4096
  41. #define MAXDIVS 36                              // we can process this many divisions, 0-9, A-Z
  42.  
  43.  
  44. FILE    *iFh, *oFh ;
  45. UCHAR   iFile[FS_LEN], oFile[FS_LEN], work[BUFSIZE+2], *w,
  46.         sACSdef[81], sDivACS[81], sACS[81],
  47.         sUpload[FS_LEN*2], sDnload[FS_LEN*2], sDesc[256],
  48.         sAreaName[81], sDivision[81], sType[256]="" ;
  49. UCHAR   *id[MAXDIVS+1], *divName[MAXDIVS+1], *divACS[MAXDIVS+1],
  50.         *nod[MAXDIVS+1], *ori[MAXDIVS+1], *sty[MAXDIVS+1] ;
  51. UCHAR   divkeys[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
  52. UCHAR   fDiv[256], fNam[256], fTag[256], fPat[256], fDes[256] ;
  53. int     sDiv, lDiv=1, sNam, lNam, sTag, lTag, sPat, lPat, sDes, lDes=80,
  54.         iThisDiv=-1, iPrevDiv=-2 ;
  55. BOOL    inMsgDivision = FALSE, ynDiv[MAXDIVS+1] ;
  56.  
  57.  
  58. void    ShowHelp( void )
  59. {
  60.     logon(1);
  61.     printf( "\n\nUsage:  %s file_in file_out\n\n",
  62.             get_global_program_name() );
  63.     exit( GD_ERROR_HELP );
  64. }
  65.  
  66.  
  67. void    do_MsgDivision( STRING action )         //~~~
  68. {
  69.     if ( st_eq(action, "End") )
  70.     {
  71.         if ( inMsgDivision )
  72.         {
  73.             inMsgDivision = FALSE ;
  74.             fprintf( oFh, "\nMsgDivisionEnd\n" );
  75.         }
  76.         return ;
  77.     }
  78.  
  79.     if ( ! st_eq(action, "Start") )
  80.         return ;
  81.  
  82.     if ( inMsgDivision )                        // terminate division first
  83.         fprintf( oFh, "\nMsgDivisionEnd\n" );
  84.  
  85.     strcpy( sDivision, divName[iThisDiv] );
  86.     strupr( sDivision );
  87.     strcpy( sDivACS  , divACS [iThisDiv] );
  88.  
  89.     if ( strlen(sDivision) )
  90.     {
  91.         inMsgDivision = TRUE ;
  92.         fprintf( oFh, "\nMsgDivisionBegin %s %s %s\n", sDivision, sDivACS, id[iThisDiv] );
  93.         strcpy( work, id[iThisDiv] );
  94.         strupr( work );
  95.         printf( "\n\nDivision %-13s %s", sDivision, work );
  96.         iPrevDiv = iThisDiv ;
  97.     }
  98. }
  99.  
  100.  
  101. int     div_number( UCHAR d )
  102. {
  103.     int         i ;
  104.     UCHAR       key[2] ;
  105.  
  106.     key[0] = d ;
  107.     key[1] = EOS ;
  108.     strupr( key );
  109.  
  110.     LOOP( i, 0, ((int)strlen(divkeys)-1), 1 )   // divkeys[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  111.     {
  112.         if ( key[0] == divkeys[i] )
  113.             return( i );
  114.     }
  115.     return( -1 );
  116. }
  117.  
  118.  
  119. void    init( int argc, char *argv[] )          //~~~
  120. {
  121.     int         i, xcnt ;
  122.     char        buffer[5120], work[256], b[21], iniFile[FS_LEN], *pIni ;
  123.  
  124.     strcpy( iniFile, argv[0] );                 // create .ini file name
  125.     pIni = strchr( iniFile, '.' );
  126.     if ( pIni != NULL )
  127.         *pIni = EOS ;
  128.     strcat( iniFile, ".INI" );
  129.  
  130.     LOOP( i, 0, MAXDIVS, 1 )
  131.     {
  132.         ynDiv[i] = FALSE ;
  133.         id[i] = nod[i] = ori[i] = sty[i] = NULPTR ;
  134.     }
  135.     LOOP( i, 0, ((int)strlen(divkeys)-1), 1 )   // divkeys[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  136.     {
  137.         sprintf( b, "%c", divkeys[i] );
  138.         fl_parse_ini( iniFile, "divisions", b, buffer, &xcnt );
  139.         if ( strlen(buffer) )
  140.         {
  141.             ynDiv[i] = TRUE ;
  142.             st_get_word( work, buffer );        // get division name
  143.             st_remove_word( buffer );           // remove word
  144.             divName[i] = strdup( work );
  145.             if ( strlen(buffer) )
  146.             {
  147.                 st_get_word( work, buffer );    // get ACS
  148.                 st_remove_word( buffer );       // remove word
  149.                 divACS[i] = strdup( work );
  150.             }
  151.             else
  152.                 divACS[i] = strdup( "" );
  153.             if ( strlen(buffer) )
  154.                 id[i] = strdup( buffer );       // whatever is left
  155.             else
  156.                 id[i] = strdup( "" );           // empty
  157.  
  158.             fl_parse_ini( iniFile, "styles", b, buffer, &xcnt );
  159.             sty[i] = strdup( buffer );
  160.             fl_parse_ini( iniFile, "nodes", b, buffer, &xcnt );
  161.             if ( strlen(buffer) )
  162.             {
  163.                 st_get_word( work, buffer );    // get node address
  164.                 st_remove_word( buffer );       // remove word
  165.                 nod[i] = strdup( work );
  166.                 ori[i] = strdup( buffer );
  167.             }
  168.             else
  169.             {
  170.                 nod[i] = strdup( "" );
  171.                 ori[i] = strdup( "" );
  172.             }
  173.         }
  174.     }
  175.  
  176. #if DEBUG
  177.     LOOP( i, 0, ((int)strlen(divkeys)-1), 1 )   // divkeys[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  178.     {
  179.         if ( ynDiv[i] )
  180.         {
  181.             printf( "%s %s %s\n\tN/O=%s %s\n\tSTY=%s\n\n",
  182.                     divName[i], divACS[i], id[i], nod[i], ori[i], sty[i] );
  183.         }
  184.     }
  185. #endif
  186.  
  187.     fl_parse_ini( iniFile, "fields", "div", buffer, &xcnt );
  188.     st_get_word( work, buffer );
  189.     sDiv = atoi( work );
  190.     fl_parse_ini( iniFile, "fields", "name", buffer, &xcnt );
  191.     st_get_word( work, buffer );
  192.     st_remove_word( buffer );
  193.     sNam = atoi( work );
  194.     st_get_word( work, buffer );
  195.     lNam = atoi( work );
  196.     fl_parse_ini( iniFile, "fields", "tag", buffer, &xcnt );
  197.     st_get_word( work, buffer );
  198.     st_remove_word( buffer );
  199.     sTag = atoi( work );
  200.     st_get_word( work, buffer );
  201.     lTag = atoi( work );
  202.     fl_parse_ini( iniFile, "fields", "path", buffer, &xcnt );
  203.     st_get_word( work, buffer );
  204.     st_remove_word( buffer );
  205.     sPat = atoi( work );
  206.     st_get_word( work, buffer );
  207.     lPat = atoi( work );
  208.     fl_parse_ini( iniFile, "fields", "desc", buffer, &xcnt );
  209.     st_get_word( work, buffer );
  210.     sDes = atoi( work );
  211.  
  212. #if DEBUG
  213.     printf( "Div  start at %d, length %d\n"
  214.             "Name start at %d, length %d\n"
  215.             "Tag  start at %d, length %d\n"
  216.             "Path start at %d, length %d\n"
  217.             "Desc start at %d, length %d\n",
  218.             sDiv, lDiv, sNam, lNam, sTag, lTag, sPat, lPat, sDes, lDes );
  219. #endif
  220.  
  221.     sDiv -- ;                                   // make 0-offset
  222.     lDiv ++ ;                                   // include space for \0
  223.     sNam -- ;
  224.     lNam ++ ;
  225.     sTag -- ;
  226.     lTag ++ ;
  227.     sPat -- ;
  228.     lPat ++ ;
  229.     sDes -- ;
  230.     lDes ++ ;
  231. }
  232.  
  233.  
  234. void    main( int argc, char *argv[] )
  235. {
  236.     tt_init( SHAREWARE_VERSION, 0, pgVERS_, pgTITL_, pgCOPR_ );
  237.     logon(0);
  238.  
  239.     if ( argc != 3 )
  240.         ShowHelp();
  241.  
  242.     st_cpy( iFile, (UCHAR *) argv[1], FS_LEN );
  243.     st_cpy( oFile, (UCHAR *) argv[2], FS_LEN );
  244.     strupr( (char *) iFile );
  245.     strupr( (char *) oFile );
  246.  
  247.     if ( ( iFh = fopen( iFile, "r" ) ) == NULL )
  248.     {
  249.         printf( "\n\nFile %s not found\a\n", iFile );
  250.         ShowHelp();
  251.     }
  252.  
  253.     oFh = fl_create_or_replace_tty( oFh, oFile, "w", YES, YES );
  254.  
  255.     init( argc, argv );
  256.  
  257.     fprintf( oFh,
  258.                 ";\tGenerated by %s %s on %s %s %s\n"
  259.                 ";\t%s\n\n",
  260.              get_global_program_name(), pgm_vers, TodaysDay(), TodaysDate(), TodaysTime(), pgm_copyrite );
  261.  
  262.     fprintf( stderr, "%s: reading %s ...", get_global_program_name(), iFile );
  263.  
  264.     while ( (w = fgets( work, BUFSIZE, iFh )) )
  265.     {
  266.         st_trim( work );
  267.         if ( strlen(work) && (work[0] != ';') )
  268.         {
  269.             iThisDiv = div_number( work[0] );
  270.             st_cpy( fDiv, &work[sDiv], lDiv );  // division
  271.             st_cpy( fNam, &work[sNam], lNam );  // name
  272.             st_cpy( fTag, &work[sTag], lTag );  // net tag
  273.             st_cpy( fPat, &work[sPat], lPat );  // file path
  274.             st_cpy( fDes, &work[sDes], lDes );  // description
  275.             st_trim( fDiv );
  276.             st_trim( fNam );
  277.             st_trim( fTag );
  278.             st_trim( fPat );
  279.             st_trim( fDes );
  280.             strupr ( fDiv );
  281.             strupr ( fTag );
  282.             strupr ( fPat );
  283.  
  284.             if ( iThisDiv != iPrevDiv )
  285.                 do_MsgDivision( "start" );
  286.  
  287.             strcpy( sACS, "**" );
  288.             if ( inMsgDivision )
  289.                 strcpy( sACS, sDivACS );
  290.  
  291.             fprintf( oFh, "\nMsgArea %s\n"
  292.                           "\t%-8s%s\n"
  293.                           "\t%-8s%s: %s\n"
  294.                           "\t%-8s%s\n"
  295.                           "\t%-8s%s\n",
  296.                           fNam, "ACS", sACS, "Desc", fTag, fDes,
  297.                           "Tag", fTag, "Path", fPat );
  298.             if ( inMsgDivision )
  299.             {
  300.                 if ( sty[iThisDiv] && strlen(sty[iThisDiv]) )
  301.                     fprintf( oFh, "\t%-8s%s\n", "Style", sty[iThisDiv] );
  302.                 if ( ori[iThisDiv] && strlen(ori[iThisDiv]) )
  303.                     fprintf( oFh, "\t%-8s%s %s %s\n", "Origin",
  304.                                   nod[iThisDiv], nod[iThisDiv], ori[iThisDiv] );
  305.             }
  306.             fprintf( oFh, "End MsgArea\n" );
  307.  
  308.             if ( inMsgDivision )
  309.             {
  310.                 sprintf( work, "%s.%s", sDivision, fNam );
  311.                 printf( "\n         %-15s %s", work, fDes );
  312.             }
  313.             else
  314.                 printf( "\nArea     %-15s %s", fNam, fDes );
  315.         }
  316.     }
  317.     do_MsgDivision( "end" );                    // just in case we're in a msg division
  318.  
  319.     _fcloseall();
  320.     printf( "\n" );
  321.     fprintf( stderr, "\n%s created\n", oFile );
  322.  
  323.     exit( GD_ERROR_NONE );
  324. }
  325.