home *** CD-ROM | disk | FTP | other *** search
/ Chip 1999 June / Chip_1999-06_cd.bin / ctenari / Kvarda / source / FILE_HTMLREMOVE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-30  |  11.5 KB  |  417 lines
  1. /************************************************************************\
  2. *
  3. * MODULE    : FILE_HTMLREMOVE.C
  4. *
  5. * PROGRAMS  : HTMLENRM
  6. *
  7. * PURPOSE   : Conversion of source file to target file replacing HTML   
  8. *             entities by target code page characters and supporting 
  9. *             variables and functions
  10. *
  11. \************************************************************************/
  12.  
  13. #include <windows.h>
  14. #include <stdio.h>
  15. #include <string.h>
  16.  
  17. #include "FILE_HTMLREMOVE.H"
  18. #include "CONV_SUB.H"
  19.  
  20. /************************************************************************\
  21. * Conversion mode setting
  22. *   normal   default
  23. *   loose    replace HTML entities corresponding to characters with
  24. *            accents that are not defined in the target code page by
  25. *            characters without accents
  26. *   all      the same as "loose" and convert also special HTML entities
  27. *            & > < and "
  28. \************************************************************************/
  29.  
  30. enum {normal, loose, all};
  31.  
  32. static int ConvMode = normal;
  33.  
  34. void SetNormalConversion (void)
  35. {
  36.    ConvMode=normal;
  37. }
  38.  
  39. void SetLooseConversion (void)
  40. {
  41.    ConvMode=loose;
  42. }
  43.  
  44. void SetAllConversion (void)
  45. {
  46.    ConvMode=all;
  47. }
  48.  
  49. /************************************************************************\
  50. * Time mode setting
  51. *   current   set date/time of the target file to the current file
  52. *   original  set date/time of the target file to be the same as
  53. *             of the source (original) file
  54. \************************************************************************/
  55.  
  56. enum {original, current};
  57.  
  58. static int TimeMode = original;
  59. FILETIME CurrentTime;
  60.  
  61. void SetOriginalFileTime (void)
  62. {
  63.    TimeMode=original;
  64. }
  65.  
  66. void SetCurrentFileTime (void)
  67. {
  68.    TimeMode=current;
  69.    CoFileTimeNow(&CurrentTime);
  70. }
  71.  
  72. /************************************************************************\
  73. * Encoding setting
  74. *   EncDir    encoding directory (directory of the code page tables)
  75. *   CodePage  target code page
  76. \************************************************************************/
  77.  
  78. static char EncDir[_MAX_PATH];
  79. static char CodePage[_MAX_FNAME]={"CP1250"};
  80.  
  81. void SetEncodingDirectory (char *directory)
  82. {
  83.    int n;
  84.    strncpy(EncDir,directory,_MAX_PATH);
  85.    EncDir[_MAX_PATH-1]='\0';
  86.    n=strlen(EncDir);
  87.    while (n>0 && EncDir[n]=='\\')
  88.      {
  89.       EncDir[n]='\0';
  90.       n--;
  91.      }
  92. }
  93.  
  94. void SetTargetCodePage (char *cp)
  95. {
  96.    strncpy (CodePage,cp,_MAX_FNAME);
  97.    CodePage[_MAX_FNAME-1]='\0';
  98. }
  99.  
  100. /************************************************************************\
  101. * Directory for temporary files
  102. \************************************************************************/
  103.  
  104. static char TempDir[_MAX_PATH]={""};
  105.  
  106. /************************************************************************\
  107. * Conversion tables
  108. *   Conv0,nConv0   structure for creation of conversion table
  109. *   Conv,nConv     conversion table
  110. \************************************************************************/
  111.  
  112. static struct {
  113.    char entity[20];
  114.    char description[30];
  115.    char loosestring[20];
  116.    char string[20];
  117.    BOOL use;
  118.   } Conv0[384];
  119.  
  120. static struct {
  121.    int ncen;
  122.    char entity[20];
  123.    int ncst;
  124.    char string[20];
  125.   } Conv[384];
  126.  
  127. static int nConv0=0;
  128. static int nConv=0;
  129.  
  130. /************************************************************************\
  131. *
  132. * FUNCTION    : InitConversionTable
  133. *
  134. * LOCAL VARS  : fname       - code page table filename
  135. *               f           - code page table file handle
  136. *               line        - buffer for code page table line
  137. *               entity      - HTML entity
  138. *               description - character description
  139. *               loosestring - string for character replace if there isn't
  140. *                             target character
  141. *               ichar       - character code
  142. *
  143. \************************************************************************/
  144.  
  145. BOOL InitConversionTable (void)
  146. {
  147.    int  i,n,ichar;
  148.    char entity[20],description[30],loosestring[20],line[100];
  149.    char fname[_MAX_FNAME];
  150.    FILE *f;
  151.  
  152.    if (GetTempPath((DWORD)sizeof(TempDir),TempDir)==0)
  153.       return (FALSE);
  154.  
  155. // HTML entities table reading
  156.  
  157.    strcat(strcpy(fname,EncDir),"\\HTML.ENC");
  158.    f=fopen(fname,"rt");
  159.    if (f==NULL)
  160.      {
  161.       printf("\n Error: Unable to find %s",fname);
  162.       return (FALSE);
  163.      }
  164.    while(!feof(f))
  165.      {
  166.       if (fgets(line,100,f)==NULL)
  167.          break;
  168.       if (line[0]==';')
  169.          continue;
  170.       line[99]='\0';
  171.       memset(entity,0,20);
  172.       memset(description,0,30);
  173.       sscanf(line,"%s %s",entity,description);
  174.       n=strlen(entity);
  175.       if (entity[0]!='&' || entity[n-1]!=';')
  176.          continue;
  177.       if (ConvMode!=all)
  178.          if (strcmp(entity,"&")==0 || strcmp(entity,"<")==0 || 
  179.              strcmp(entity,"<")==0)
  180.             continue; 
  181.       Conv0[nConv0].use=FALSE;
  182.       strcpy(Conv0[nConv0].entity,entity);
  183.       strcpy(Conv0[nConv0].description,description);
  184.       memset(Conv0[nConv0].string,0,20);
  185.       memset(Conv0[nConv0].loosestring,0,20);
  186.       nConv0++;
  187.      }
  188.    fclose(f);
  189.  
  190. // HTML coded character set creating based on ISO-8859-1 table
  191.  
  192.    strcat(strcpy(fname,EncDir),"\\ISO-8859-1.ENC");
  193.    f=fopen(fname,"rt");
  194.    if (f==NULL)
  195.      {
  196.       printf("\n Warning: Unable to find %s"
  197.              "\n          Numerical entities will not be replaced.",fname);
  198.       goto accent;
  199.      }
  200.    while(!feof(f))
  201.      {
  202.       if (fgets(line,100,f)==NULL)
  203.          break;
  204.       if (line[0]==';')
  205.          continue;
  206.       line[99]='\0';
  207.       memset(entity,0,20);
  208.       memset(description,0,30);
  209.       sscanf(line,"%d %s",&ichar,description);
  210.       if (strlen(description)<1)
  211.          continue;
  212.       sprintf(entity,"&#%d;",ichar);
  213.       Conv0[nConv0].use=FALSE;
  214.       strcpy(Conv0[nConv0].entity,entity);
  215.       strcpy(Conv0[nConv0].description,description);
  216.       memset(Conv0[nConv0].string,0,20);
  217.       memset(Conv0[nConv0].loosestring,0,20);
  218.       nConv0++;
  219.      }
  220.    fclose(f);
  221.  
  222. // not-accented strings assignment to accented characters
  223.  
  224. accent:
  225.    if (ConvMode!=normal)
  226.      {
  227.       strcat(strcpy(fname,EncDir),"\\ACCENT.CONV");
  228.       f=fopen(fname,"rt");
  229.       if (f==NULL)
  230.         {
  231.          printf("\n Warning: Unable to find %s"
  232.                 "\n          Remaining accent character entities will not be replaced",
  233.                 fname);
  234.          goto readcp;
  235.         }
  236.       while(!feof(f))
  237.         {
  238.          if (fgets(line,100,f)==NULL)
  239.             break;
  240.          if (line[0]==';')
  241.             continue;
  242.          line[99]='\0';
  243.          memset(description,0,30);
  244.          memset(loosestring,0,20);
  245.          sscanf(line,"%s %s",description,loosestring);
  246.          if (strlen(description)<1)
  247.             continue;
  248.          for (i=0; i<nConv0; i++)
  249.            { 
  250.             if (strcmp(description,Conv0[i].description)==0)
  251.                strcpy(Conv0[i].loosestring,loosestring);
  252.             break; 
  253.            }                                           
  254.         }
  255.       fclose(f);
  256.      }
  257.  
  258. // target code page table reading and assignment to the HTML entities
  259.  
  260. readcp:
  261.    strcat(strcat(strcat(strcpy(fname,EncDir),"\\"),CodePage),".ENC");
  262.    f=fopen(fname,"rt");
  263.    if (f==NULL)
  264.      {
  265.       printf("\n Error: Unable to find %s",fname);
  266.       return (FALSE);
  267.      }
  268.    while(!feof(f))
  269.      {
  270.       if (fgets(line,100,f)==NULL)
  271.          break;
  272.       if (line[0]==';')
  273.          continue;
  274.       line[99]='\0';
  275.       memset(description,0,30);
  276.       sscanf(line,"%d %s",&ichar,description);
  277.       if (strlen(description)<1)
  278.          continue;
  279.       for(i=0; i<nConv0; i++)
  280.         {
  281.          if (Conv0[i].use==TRUE)
  282.             continue;
  283.          if (strcmp(description,Conv0[i].description)==0)
  284.            { 
  285.             Conv0[i].string[0]=(char)ichar;
  286.             Conv0[i].use=TRUE;
  287.            }
  288.         }
  289.      }
  290.    fclose(f);
  291.  
  292. // decision of which loose conversion to use
  293.  
  294.    if (ConvMode!=normal)
  295.      {
  296.       for (i=0; i<nConv0; i++)
  297.         {
  298.          if (Conv0[i].use==TRUE)
  299.             continue;
  300.          if (strlen(Conv0[i].loosestring)>0)
  301.            {
  302.             strcpy(Conv0[i].string,Conv0[i].loosestring);
  303.             Conv0[i].use=TRUE;
  304.            }
  305.         }
  306.      }
  307.  
  308. // finishing file conversion table
  309.  
  310.    nConv=0;
  311.    for (i=0; i<nConv0; i++)
  312.       if (Conv0[i].use==TRUE)
  313.         {
  314.          strcpy (Conv[nConv].entity,Conv0[i].entity);
  315.          strcpy (Conv[nConv].string,Conv0[i].string);
  316.          Conv[nConv].ncen=strlen(Conv[nConv].entity);
  317.          Conv[nConv].ncst=strlen(Conv[nConv].string);
  318.          nConv++;
  319.         }
  320.  
  321.    return (TRUE);
  322. }
  323.  
  324. /************************************************************************\
  325. *
  326. * FUNCTION    : ConvertFile
  327. *
  328. * INPUTS      : SourceDir  - source file name
  329. *               TargetDir  - target file name
  330. *
  331. * RETURNS     : None
  332. *
  333. * LOCAL VARS  : hSFile     - source file handle
  334. *               hTFile     - target file handle
  335. *               hTempFile  - temporary file handle
  336. *               TempName   - temporary file name
  337. *               ssize      - source file size
  338. *               stime      - source file time
  339. *               buff       - buffer for source file content
  340. *
  341. \************************************************************************/
  342.  
  343. void ConvertFile(char *SFileName, char *TFileName)
  344. {
  345.    HANDLE hSFile, hTFile, hTempFile;
  346.    char *buff,*p0,*p1,*p2;
  347.    char TempName[_MAX_FNAME];
  348.    DWORD dwBytesRead,dwBytesWritten,dwPos;
  349.    DWORD ssize,n;
  350.    FILETIME stime;
  351.    int i;
  352.  
  353.    if (GetTempFileName(TempDir,"HTR",0,TempName)==0)
  354.       return;
  355.    hTempFile= CreateFile(TempName,GENERIC_WRITE,0,
  356.                          (LPSECURITY_ATTRIBUTES)NULL,CREATE_ALWAYS,
  357.                          FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
  358.    if (hTempFile==INVALID_HANDLE_VALUE)
  359.       return;
  360.  
  361.    hSFile= CreateFile(SFileName,GENERIC_READ,0,
  362.                       (LPSECURITY_ATTRIBUTES) NULL,OPEN_EXISTING,
  363.                       FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
  364.    if (hSFile==INVALID_HANDLE_VALUE)
  365.       return;
  366.    ssize=GetFileSize(hSFile,NULL);
  367.    GetFileTime(hSFile,NULL,NULL,&stime);
  368.  
  369.    buff=malloc(ssize);
  370.    if (buff==NULL) 
  371.       return;
  372.    ReadFile(hSFile, (LPSTR)buff, ssize, &dwBytesRead, NULL); 
  373.    p0=&buff[0];
  374.    p1=strchr(p0,'&');
  375.    p2=&buff[dwBytesRead-1];
  376.    dwPos=SetFilePointer(hTempFile,0,(LPLONG)NULL,FILE_BEGIN);
  377.    while (p1!=NULL && p1<p2)
  378.      {
  379.       n=(DWORD)(p1-p0);
  380.       WriteFile(hTempFile,(LPSTR)p0,n,&dwBytesWritten,NULL);
  381.       p0=p1;
  382.       for (i=0;i<nConv;i++)
  383.          if (strncmp(Conv[i].entity,p0,Conv[i].ncen)==0)
  384.            {
  385.             WriteFile(hTempFile,Conv[i].string,Conv[i].ncst,&dwBytesWritten,NULL);
  386.             p0+=Conv[i].ncen;
  387.             goto nextamp;
  388.            }
  389.       WriteFile(hTempFile,p0,1,&dwBytesWritten,NULL);
  390.       p0++;
  391. nextamp:   
  392.       p1=strchr(p0,'&');
  393.      }
  394.    n=(DWORD)(p2-p0)+1;
  395.    WriteFile(hTempFile,(LPSTR)p0,n,&dwBytesWritten,NULL);
  396.    free(buff);
  397.    CloseHandle(hSFile);
  398.    CloseHandle(hTempFile);
  399.  
  400.    CopyFile(TempName,TFileName,FALSE);
  401.    DeleteFile(TempName);
  402.  
  403.    hTFile= CreateFile(TFileName,GENERIC_WRITE,0,
  404.                       (LPSECURITY_ATTRIBUTES) NULL,OPEN_EXISTING,
  405.                       FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
  406.    if (hTFile==INVALID_HANDLE_VALUE)
  407.       return;
  408.    if (TimeMode==current)
  409.       SetFileTime(hTFile,NULL,NULL,&CurrentTime);
  410.    else
  411.       SetFileTime(hTFile,NULL,NULL,&stime);
  412.    CloseHandle(hTFile);
  413.    printf("\n  Converted target file: %s", TFileName);
  414.    return;
  415. }
  416.  
  417.