Changeset 218


Ignore:
Timestamp:
Apr 2, 2017, 11:34:55 AM (8 years ago)
Author:
Valery V. Sedletski
Message:

FS utilities: move unicode translate table loading to UFAT32.DLL and export it.

Location:
trunk/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/src/ufat32/ufat32.c

    r211 r218  
    1010int recover(int argc, char *argv[], char *envp[]);
    1111int sys(int argc, char *argv[], char *envp[]);
     12
     13BOOL LoadTranslateTable(BOOL fSilent, UCHAR ucSource);
    1214
    1315void cleanup(void);
    … …  
    128130}
    129131
     132BOOL _Far16 _Pascal _loadds LOADTRANSTBL(BOOL fSilent, UCHAR ucSource)
     133{
     134   return LoadTranslateTable(fSilent, ucSource);
     135}
     136
    130137#define SIG_CTRLC        1
    131138#define SIG_BROKENPIPE   2

  • TabularUnified trunk/src/ufat32/unicode.c

    r193 r218  
    2626
    2727extern F32PARMS f32Parms;
     28
     29USHORT _Far16 _Pascal _loadds GETSHRSEG(PVOID16 *p);
    2830
    2931int (* CALLCONV pUniCreateUconvObject)(UniChar * code_set, UconvObject * uobj);
    … …  
    176178*
    177179******************************************************************/
    178 BOOL LoadTranslateTable(BOOL fSilent)
     180BOOL LoadTranslateTable(BOOL fSilent, UCHAR ucSource)
    179181{
    180182    APIRET rc;
    … …  
    434436   }
    435437
    436    ulParmSize = sizeof rgTransTable;
    437    if( !TranslateInit((PVOID)rgTransTable, ulParmSize))
    438       rc = ERROR_INVALID_PARAMETER;
    439    else
    440       rc = 0;
     438   switch (ucSource)
     439   {
     440   case 0:
     441      {
     442         // called from CHKDSK or IFS init routine
     443         ulParmSize = sizeof rgTransTable;
     444         if( !TranslateInit((PVOID)rgTransTable, ulParmSize) )
     445            rc = ERROR_INVALID_PARAMETER;
     446         else
     447            rc = 0;
     448      }
     449      break;
     450
     451   case 1:
     452      {
     453         // called from cachef32.exe
     454         ulParmSize = sizeof rgTransTable;
     455         rc = DosFSCtl(NULL, 0, NULL,
     456                     ( PVOID )rgTransTable, ulParmSize, &ulParmSize,
     457                     FAT32_SETTRANSTABLE, "FAT32", -1, FSCTL_FSDNAME);
     458      }
     459      break;
     460#ifdef __DLL__
     461   case 2:
     462      {
     463         // called from IFS init
     464         PVOID16 p;
     465         ulParmSize = sizeof rgTransTable;
     466         if( !GETSHRSEG(&p) )
     467            rc = ERROR_INVALID_PARAMETER;
     468         else
     469         {
     470            rc = 0;
     471            memcpy((PVOID)p, (PVOID)rgTransTable, ulParmSize);
     472         }
     473      }
     474#endif
     475   }
    441476   
    442477   if (rc)
    … …  
    494529void CodepageConvInit(BOOL fSilent)
    495530{
    496    LoadTranslateTable(fSilent);
     531   LoadTranslateTable(fSilent, FALSE);
    497532   TranslateInitDBCSEnv();
    498533   CaseConversionInit();

  • TabularUnified trunk/src/util/cachef32.c

    r136 r218  
    66#include <stdarg.h>
    77#include <ctype.h>
    8 #include <uconv.h>
    98#include <process.h>
    109
    … …  
    2423#define SHAREMEM         "\\SHAREMEM\\CACHEF32"
    2524
    26 int (* CALLCONV pUniCreateUconvObject)(UniChar * code_set, UconvObject * uobj);
    27 int (* CALLCONV pUniUconvToUcs)(
    28                          UconvObject uobj,                 /* I  - Uconv object handle             */
    29                          void    * * inbuf,        /* IO - Input buffer                            */
    30                          size_t    * inbytes,      /* IO - Input buffer size (bytes)   */
    31                          UniChar * * outbuf,       /* IO - Output buffer size              */
    32                          size_t    * outchars,     /* IO - Output size (chars)             */
    33                          size_t    * subst      );         /* IO - Substitution count              */
    34 int (* CALLCONV pUniUconvFromUcs)(
    35                          UconvObject uobj,
    36                          UniChar * * inbuf,
    37                          size_t    * inchars,
    38                          void    * * outbuf,
    39                          size_t    * outbytes,
    40                          size_t    * subst      );
    41 int (* CALLCONV pUniMapCpToUcsCp)( ULONG ulCp, UniChar *ucsCp, size_t n );
    42 UniChar (* CALLCONV pUniTolower )( UniChar uin );
    43 int (* CALLCONV pUniQueryUconvObject )
    44         (UconvObject uobj, uconv_attribute_t *attr, size_t size, char first[256], char other[256], udcrange_t udcrange[32]);
    45 
    46 HMODULE hModConv = 0;
    47 HMODULE hModUni  = 0;
    48 
    4925PRIVATE VOID Handler(INT iSignal);
    5026PRIVATE VOID InitProg(INT iArgc, PSZ rgArgv[]);
    … …  
    6642PRIVATE VOID ShowRASectors(VOID);
    6743PRIVATE BOOL SetRASectors(PSZ pszArg);
    68 PRIVATE BOOL LoadTranslateTable(VOID);
    6944PRIVATE void WriteLogMessage(PSZ pszMessage);
     45
     46BOOL (*pLoadTranslateTable)(BOOL fSilent, UCHAR ucSource);
     47
     48HMODULE   hMod = 0;
    7049
    7150static PSZ rgPriority[]=
    … …  
    247226ULONG     ulParmSize;
    248227BOOL      fSetParms = FALSE;
     228BYTE      rgData[ 256 ];
    249229ULONG     ulParm;
    250230
    … …  
    259239          }
    260240   }
     241
     242   rc = DosLoadModule(rgData, sizeof(rgData), "UFAT32.DLL", &hMod);
     243   if (rc)
     244      {
     245      printf("FAT32: Utility DLL not found (%s does not load).\n", rgData);
     246      printf("FAT32: No UNICODE translate table loaded!\n");
     247      return;
     248      }
     249   rc = DosQueryProcAddr(hMod, 0L,
     250      "LoadTranslateTable", (PFN *)&pLoadTranslateTable);
     251   if (rc)
     252      {
     253      printf("FAT32: ERROR: Could not find address of LoadTranslateTable.\n");
     254      return;
     255      }
    261256
    262257   /*
    … …  
    501496          }
    502497
    503    if ( fForeGround && LoadTranslateTable())
    504           fSetParms = TRUE;
     498   if ( fForeGround && (*pLoadTranslateTable)(FALSE, TRUE))
     499          fSetParms = TRUE;
     500
     501   if( hMod )
     502        DosFreeModule(hMod);
    505503
    506504   if (fSetParms)
    … …  
    931929}
    932930
    933 #define MAX_TRANS_TABLE         0x100
    934 #define ARRAY_TRANS_TABLE       ( 0x10000 / MAX_TRANS_TABLE )
    935 
    936 #define INDEX_OF_START          MAX_TRANS_TABLE
    937 #define INDEX_OF_FIRSTINFO      MAX_TRANS_TABLE
    938 #define INDEX_OF_LCASECONV      ( MAX_TRANS_TABLE + 1 )
    939 #define INDEX_OF_END            INDEX_OF_LCASECONV
    940 #define EXTRA_ELEMENT           ( INDEX_OF_END - INDEX_OF_START + 1 )
    941 
    942 BOOL LoadTranslateTable(VOID)
    943 {
    944 APIRET rc;
    945 ULONG ulParmSize;
    946 BYTE   rgData[ 256 ];
    947 // Extra space for DBCS lead info and case conversion
    948 UniChar *rgTranslate[ MAX_TRANS_TABLE + EXTRA_ELEMENT ] = { NULL, };
    949 PBYTE  pChar;
    950 UniChar *pUni;
    951 UconvObject  uconv_object = NULL;
    952 INT iIndex;
    953 size_t bytes_left;
    954 size_t uni_chars_left;
    955 size_t num_subs;
    956 ULONG rgCP[3];
    957 ULONG cbCP;
    958 // Extra space for DBCS lead info and case conversion
    959 PVOID16 rgTransTable[ MAX_TRANS_TABLE + EXTRA_ELEMENT ] = { NULL, };
    960 char rgFirst[ 256 ];
    961 USHORT first, second;
    962 USHORT usCode;
    963 UniChar ucsCp[ 12 ];
    964 UniChar rgUniBuffer[ ARRAY_TRANS_TABLE ];
    965 
    966    rc = DosLoadModule(rgData, sizeof rgData, "UCONV.DLL", &hModConv);
    967    if (rc)
    968           {
    969           printf("No NLS support found (%s does not load).\n", rgData);
    970           printf("No UNICODE translate table loaded!\n");
    971           rc = TRUE;
    972           goto free_exit;
    973           }
    974    rc = DosQueryProcAddr(hModConv, 0L,
    975           "UniCreateUconvObject", (PFN *)&pUniCreateUconvObject);
    976    if (rc)
    977           {
    978           printf("ERROR: Could not find address of UniCreateUconvObject.\n");
    979           rc = FALSE;
    980           goto free_exit;
    981           }
    982    rc = DosQueryProcAddr(hModConv, 0L,
    983           "UniUconvToUcs", (PFN *)&pUniUconvToUcs);
    984    if (rc)
    985           {
    986           printf("ERROR: Could not find address of UniUconvToUcs.\n");
    987           rc = FALSE;
    988           goto free_exit;
    989           }
    990 
    991    rc = DosQueryProcAddr(hModConv, 0L,
    992           "UniUconvFromUcs", (PFN *)&pUniUconvFromUcs);
    993    if (rc)
    994           {
    995           printf("ERROR: Could not find address of UniUconvFromUcs.\n");
    996           rc = FALSE;
    997           goto free_exit;
    998           }
    999 
    1000    rc = DosQueryProcAddr(hModConv, 0L,
    1001           "UniMapCpToUcsCp", (PFN *)&pUniMapCpToUcsCp);
    1002    if (rc)
    1003           {
    1004           printf("ERROR: Could not find address of UniMapCpToUcsCp.\n");
    1005           rc = FALSE;
    1006           goto free_exit;
    1007           }
    1008 
    1009    rc = DosQueryProcAddr(hModConv, 0L,
    1010           "UniQueryUconvObject", (PFN *)&pUniQueryUconvObject);
    1011    if (rc)
    1012           {
    1013           printf("ERROR: Could not find address of UniQueryUconvObject.\n");
    1014           rc = FALSE;
    1015           goto free_exit;
    1016           }
    1017 
    1018    rc = DosLoadModule(rgData, sizeof rgData, "LIBUNI.DLL", &hModUni);
    1019    if (rc)
    1020           {
    1021           printf("No NLS support found (%s does not load).\n", rgData);
    1022           printf("No UNICODE translate table loaded!\n");
    1023           rc = TRUE;
    1024           goto free_exit;
    1025           }
    1026 
    1027    rc = DosQueryProcAddr(hModUni, 0L,
    1028           "UniTolower", (PFN *)&pUniTolower);
    1029    if (rc)
    1030           {
    1031           printf("ERROR: Could not find address of UniTolower.\n");
    1032           rc = FALSE;
    1033           goto free_exit;
    1034           }
    1035 
    1036    if( ulNewCP )
    1037                 rgCP[ 0 ] = ulNewCP;
    1038    else
    1039                 DosQueryCp(sizeof rgCP, rgCP, &cbCP);
    1040 
    1041    if (f32Parms.ulCurCP == rgCP[0])
    1042    {
    1043           rc = FALSE;
    1044           goto free_exit;
    1045    }
    1046 
    1047    if (f32Parms.ulCurCP && !fSayYes)
    1048           {
    1049           BYTE chChar;
    1050           printf("Loaded unicode translate table is for CP %lu\n", f32Parms.ulCurCP);
    1051           printf("Current CP is %lu\n", rgCP[0]);
    1052           printf("Would you like to reload the translate table for this CP [Y/N]? ");
    1053           fflush(stdout);
    1054 
    1055           for (;;)
    1056                  {
    1057                  chChar = getch();
    1058                  switch (chChar)
    1059                         {
    1060                         case 'y':
    1061                         case 'Y':
    1062                            chChar = 'Y';
    1063                            break;
    1064                         case 'n':
    1065                         case 'N':
    1066                            chChar = 'N';
    1067                            break;
    1068                         default :
    1069                            DosBeep(660, 10);
    1070                            continue;
    1071                         }
    1072                  printf("%c\n", chChar);
    1073                  break;
    1074                  }
    1075           if (chChar == 'N')
    1076                  {
    1077                  rc = FALSE;
    1078                  goto free_exit;
    1079                  }
    1080           }
    1081 
    1082    rc = pUniMapCpToUcsCp( rgCP[ 0 ], ucsCp, sizeof( ucsCp ) / sizeof( UniChar ));
    1083    if( rc != ULS_SUCCESS )
    1084    {
    1085                 printf("UniMapCpToUcsCp error: return code = %u\n", rc );
    1086                 rc = FALSE;
    1087                 goto free_exit;
    1088    }
    1089 
    1090    rc = pUniCreateUconvObject( ucsCp, &uconv_object);
    1091    if (rc != ULS_SUCCESS)
    1092           {
    1093           printf("UniCreateUconvObject error: return code = %u\n", rc);
    1094           rc = FALSE;
    1095           goto free_exit;
    1096           }
    1097 
    1098    rc = pUniQueryUconvObject( uconv_object, NULL, 0, rgFirst, NULL, NULL );
    1099    if (rc != ULS_SUCCESS)
    1100           {
    1101           printf("UniQueryUConvObject error: return code = %u\n", rc);
    1102           rc = FALSE;
    1103           goto free_exit;
    1104           }
    1105 
    1106    // Allocation for conversion, DBCS lead info and case conversion
    1107    for( iIndex = 0; iIndex <= INDEX_OF_END ; iIndex ++ )
    1108    {
    1109                 rgTransTable[ iIndex ] = rgTranslate[ iIndex ] = malloc( sizeof(USHORT ) * ARRAY_TRANS_TABLE );
    1110                 memset( rgTranslate[ iIndex ], 0, sizeof( USHORT ) * ARRAY_TRANS_TABLE );
    1111    }
    1112 
    1113    // Initialize SBCS only for conversion and set DBCS lead info
    1114    for( iIndex = 0; iIndex < ARRAY_TRANS_TABLE; iIndex++ )
    1115    {
    1116                 rgData[ iIndex ] = ( rgFirst[ iIndex ] == 1 ) ? iIndex : 0;
    1117                 rgTranslate[ INDEX_OF_FIRSTINFO ][ iIndex ] = rgFirst[ iIndex ];
    1118    }
    1119 
    1120    pChar = rgData;
    1121    bytes_left = sizeof rgData;
    1122    pUni = ( PVOID )rgTranslate[ 0 ];
    1123    uni_chars_left = ARRAY_TRANS_TABLE;
    1124 
    1125    rc = pUniUconvToUcs(uconv_object,
    1126           (PVOID *)&pChar,
    1127           &bytes_left,
    1128           &pUni,
    1129           &uni_chars_left,
    1130           &num_subs);
    1131 
    1132    if (rc != ULS_SUCCESS)
    1133           {
    1134           printf("UniUconvToUcs failed, rc = %u\n", rc);
    1135           rc = FALSE;
    1136           goto free_exit;
    1137           }
    1138 
    1139    // Translate upper case to lower case
    1140    for( iIndex = 0; iIndex < ARRAY_TRANS_TABLE; iIndex++ )
    1141                 rgUniBuffer[ iIndex ] = pUniTolower( rgTranslate[ 0 ][ iIndex ] );
    1142 
    1143    // Convert lower case in Unicode to codepage code
    1144    pUni = ( PVOID )rgUniBuffer;
    1145    uni_chars_left = ARRAY_TRANS_TABLE;
    1146    pChar  = rgData;
    1147    bytes_left = sizeof rgData;
    1148 
    1149    rc = pUniUconvFromUcs( uconv_object,
    1150                 &pUni,
    1151                 &uni_chars_left,
    1152                 ( PVOID * )&pChar,
    1153                 &bytes_left,
    1154                 &num_subs );
    1155 
    1156    if (rc != ULS_SUCCESS)
    1157           {
    1158           printf("UniUconvFromUcs failed, rc = %u\n", rc);
    1159           rc = FALSE;
    1160           goto free_exit;
    1161           }
    1162 
    1163    // Store codepage code to transtable
    1164    for( iIndex = 0; iIndex < ARRAY_TRANS_TABLE; iIndex++ )
    1165                 rgTranslate[ INDEX_OF_LCASECONV ][ iIndex ] = rgData[ iIndex ] ? rgData[ iIndex ] : iIndex;
    1166 
    1167    // Translate DBCS code to unicode
    1168    for( first = 0; first < ARRAY_TRANS_TABLE; first++ )
    1169    {
    1170                 if( rgFirst[ first ] == 2 )
    1171                 {
    1172                         for( second = 0; second < 0x100; second++ )
    1173                         {
    1174                                   usCode = first | (( second << 8 ) & 0xFF00 );
    1175 
    1176                                   pChar  = ( PVOID )&usCode;
    1177                                   bytes_left = sizeof usCode;
    1178                                   pUni = ( PVOID )&rgTranslate[ second ][ first ];
    1179                                   uni_chars_left = 1;
    1180 
    1181                                   rc = pUniUconvToUcs(uconv_object,
    1182                                          (PVOID *)&pChar,
    1183                                          &bytes_left,
    1184                                          &pUni,
    1185                                          &uni_chars_left,
    1186                                          &num_subs);
    1187 
    1188                                   if (rc != ULS_SUCCESS)
    1189                                   {
    1190                                          printf("UniUconvToUcs failed, rc = %u\n", rc);
    1191                                          rc = FALSE;
    1192                                          goto free_exit;
    1193                                   }
    1194                         }
    1195                 }
    1196    }
    1197 
    1198    ulParmSize = sizeof rgTransTable;
    1199    rc = DosFSCtl(NULL, 0, NULL,
    1200                            ( PVOID )rgTransTable, ulParmSize, &ulParmSize,
    1201                            FAT32_SETTRANSTABLE, "FAT32", -1, FSCTL_FSDNAME);
    1202    if (rc)
    1203           {
    1204           printf("Unable to set translate table for current Codepage.\n");
    1205           rc = FALSE;
    1206           goto free_exit;
    1207           }
    1208 
    1209    f32Parms.ulCurCP = rgCP[0];
    1210    if( !fSilent )
    1211           printf("Unicode translate table for CP %lu loaded.\n", rgCP[0]);
    1212    rc = TRUE;
    1213 free_exit:
    1214 
    1215    for( iIndex = 0; iIndex <= INDEX_OF_END; iIndex++ )
    1216           if( rgTranslate[ iIndex ])
    1217                 free( rgTranslate[ iIndex ]);
    1218 
    1219    if( hModConv )
    1220                 DosFreeModule( hModConv);
    1221 
    1222    if( hModUni )
    1223                 DosFreeModule( hModUni );
    1224 
    1225    return rc;
    1226 }
    1227 
    1228931void WriteLogMessage(PSZ pszMessage)
    1229932{
Note: See TracChangeset for help on using the changeset viewer.