wince.cpp

压缩解压,是unzip540的升级,这个外国网站摘来的源码,是evb编写.

//-- Called from winmain.cpp
int __cdecl _stricmp(const char *string1, const char *string2) {
   while (*string1 && ((*string1 | 0x20) == (*string2 | 0x20))) {
      string1++;
      string2++;
   }
   return (*string1 - *string2);
}

//******************************************************************************
//-- Called from intrface.cpp and winmain.cpp
char* __cdecl _strupr(char *string) {
   while (*string) {
      if ((*string >= 'a') && (*string <= 'z')) {
         *string -= 'a' - 'A';
      }
      string++;
   }
   return string;
}

//******************************************************************************
//-- Called from fileio.c ("open_input_file()")
char* __cdecl strerror(int errnum) {
   return "[errmsg not available]";
}

#ifndef _MBCS
//******************************************************************************
//-- Called from winmain.cpp
char* __cdecl strrchr(const char *string, int c) {

   // Walk to end of string.
   for (char *p = (char*)string; *p; p++) {
   }

   // Walk backwards looking for character.
   for (p--; p >= string; p--) {
      if ((int)*p == c) {
         return p;
      }
   }

   return NULL;
}
#endif /* !_MBCS */

//******************************************************************************
//***** CTYPE.H functions
//******************************************************************************

#if _WIN32_WCE < 300
int __cdecl isupper(int c) {
   return ((c >= 'A') && (c <= 'Z'));
}
#endif

//******************************************************************************
//***** STAT.H functions
//******************************************************************************

//-- Called fileio.c, process.c, intrface.cpp
int __cdecl stat(const char *path, struct stat *buffer) {

   // stat() is called on both the ZIP files and extracted files.

   // Clear our stat buffer to be safe.
   ZeroMemory(buffer, sizeof(struct stat));

   // Find the file/direcotry and fill in a WIN32_FIND_DATA structure.
   WIN32_FIND_DATA w32fd;
   ZeroMemory(&w32fd, sizeof(w32fd));

   TCHAR szPath[_MAX_PATH];
   MBSTOTSTR(szPath, path, countof(szPath));
   HANDLE hFind = FindFirstFile(szPath, &w32fd);

   // Bail out now if we could not find the file/directory.
   if (hFind == INVALID_HANDLE_VALUE) {
      return -1;
   }

   // Close the find.
   FindClose(hFind);

   // Mode flags that are currently used: S_IWRITE, S_IFMT, S_IFDIR, S_IEXEC
   if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
      buffer->st_mode = _S_IFDIR | _S_IREAD | _S_IEXEC;
   } else {
      buffer->st_mode = _S_IFREG | _S_IREAD;
   }
   if (!(w32fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
      buffer->st_mode |= _S_IWRITE;
   }

   // Store the file size.
   buffer->st_size  = (_off_t)w32fd.nFileSizeLow;

   // Convert the modified FILETIME to a time_t and store it.
   DWORDLONG dwl = *(DWORDLONG*)&w32fd.ftLastWriteTime;
   buffer->st_mtime = (time_t)((dwl - (DWORDLONG)116444736000000000) / (DWORDLONG)10000000);

   return 0;
}

//******************************************************************************
//***** TIME.H functions
//******************************************************************************

// Evaluates to TRUE if 'y' is a leap year, otherwise FALSE
// #define IS_LEAP_YEAR(y) ((((y) % 4 == 0) && ((y) % 100 != 0)) || ((y) % 400 == 0))

// The macro below is a reduced version of the above macro.  It is valid for
// years between 1901 and 2099 which easily includes all years representable
// by the current implementation of time_t.
#define IS_LEAP_YEAR(y) (((y) & 3) == 0)

#define BASE_DOW          4                  // 1/1/1970 was a Thursday.
#define SECONDS_IN_A_DAY  (24L * 60L * 60L)  // Number of seconds in one day.

// Month to Year Day conversion array.
int M2YD[] = {
   0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
};

// Month to Leap Year Day conversion array.
int M2LYD[] = {
   0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366
};

//******************************************************************************
//-- Called from list.c
struct tm * __cdecl localtime(const time_t *timer) {

   // Return value for localtime().  Source currently never references
   // more than one "tm" at a time, so the single return structure is ok.
   static struct tm g_tm;
   ZeroMemory(&g_tm, sizeof(g_tm));

   // Get our time zone information.
   TIME_ZONE_INFORMATION tzi;
   SafeGetTimeZoneInformation(&tzi);

   // Create a time_t that has been corrected for our time zone.
   time_t localTime = *timer - (tzi.Bias * 60L);

   // Decide if value is in Daylight Savings Time.
   if (g_tm.tm_isdst = (int)IsDST(&tzi, localTime)) {
      localTime -= tzi.DaylightBias * 60L; // usually 60 minutes
   } else {
      localTime -= tzi.StandardBias * 60L; // usually  0 minutes
   }

   // time_t   is a 32-bit value for the seconds since January 1, 1970
   // FILETIME is a 64-bit value for the number of 100-nanosecond intervals
   //          since January 1, 1601

   // Compute the FILETIME for the given local time.
   DWORDLONG dwl = ((DWORDLONG)116444736000000000 +
                   ((DWORDLONG)localTime * (DWORDLONG)10000000));
   FILETIME ft = *(FILETIME*)&dwl;

   // Convert the FILETIME to a SYSTEMTIME.
   SYSTEMTIME st;
   ZeroMemory(&st, sizeof(st));
   FileTimeToSystemTime(&ft, &st);

   // Finish filling in our "tm" structure.
   g_tm.tm_sec  = (int)st.wSecond;
   g_tm.tm_min  = (int)st.wMinute;
   g_tm.tm_hour = (int)st.wHour;
   g_tm.tm_mday = (int)st.wDay;
   g_tm.tm_mon  = (int)st.wMonth - 1;
   g_tm.tm_year = (int)st.wYear - 1900;

   return &g_tm;
}

//******************************************************************************
static void SafeGetTimeZoneInformation(TIME_ZONE_INFORMATION *ptzi)
{

   ZeroMemory(ptzi, sizeof(TIME_ZONE_INFORMATION));

   // Ask the OS for the standard/daylight rules for the current time zone.
   if ((GetTimeZoneInformation(ptzi) == 0xFFFFFFFF) ||
       (ptzi->StandardDate.wMonth > 12) || (ptzi->DaylightDate.wMonth > 12))
   {
      // If the OS fails us, we default to the United States' rules.
      ZeroMemory(ptzi, sizeof(TIME_ZONE_INFORMATION));
      ptzi->StandardDate.wMonth =  10;  // October
      ptzi->StandardDate.wDay   =   5;  // Last Sunday (DOW == 0)
      ptzi->StandardDate.wHour  =   2;  // At 2:00 AM
      ptzi->DaylightBias        = -60;  // One hour difference
      ptzi->DaylightDate.wMonth =   4;  // April
      ptzi->DaylightDate.wDay   =   1;  // First Sunday (DOW == 0)
      ptzi->DaylightDate.wHour  =   2;  // At 2:00 AM
   }
}

//******************************************************************************
static time_t GetTransitionTimeT(TIME_ZONE_INFORMATION *ptzi,
                                 int year, BOOL fStartDST)
{
   // We only handle years within the range that time_t supports.  We need to
   // handle the very end of 1969 since the local time could be up to 13 hours
   // into the previous year.  In this case, our code will actually return a
   // negative value, but it will be compared to another negative value and is
   // handled correctly.  The same goes for the 13 hours past a the max time_t
   // value of 0x7FFFFFFF (in the year 2038).  Again, these values are handled
   // correctly as well.

   if ((year < 1969) || (year > 2038)) {
      return (time_t)0;
   }

   SYSTEMTIME *pst = fStartDST ? &ptzi->DaylightDate : &ptzi->StandardDate;

   // WORD wYear          Year (0000 == 0)
   // WORD wMonth         Month (January == 1)
   // WORD wDayOfWeek     Day of week (Sunday == 0)
   // WORD wDay           Month day (1 - 31)
   // WORD wHour          Hour (0 - 23)
   // WORD wMinute        Minute (0 - 59)
   // WORD wSecond        Second (0 - 59)
   // WORD wMilliseconds  Milliseconds (0 - 999)

   // Compute the number of days since 1/1/1970 to the beginning of this year.
   long daysToYear = ((year - 1970) * 365) // Tally up previous years.
                   + ((year - 1969) >> 2); // Add few extra for the leap years.

   // Compute the number of days since the beginning of this year to the
   // beginning of the month.  We will add to this value to get the actual
   // year day.
   long yearDay = IS_LEAP_YEAR(year) ? M2LYD[pst->wMonth - 1] :
                                       M2YD [pst->wMonth - 1];

   // Check for day-in-month format.
   if (pst->wYear == 0) {

      // Compute the week day for the first day of the month (Sunday == 0).
      long monthDOW = (daysToYear + yearDay + BASE_DOW) % 7;

      // Add the day offset of the transition day to the year day.
      if (monthDOW < pst->wDayOfWeek) {
         yearDay += (pst->wDayOfWeek - monthDOW) + (pst->wDay - 1) * 7;
      } else {
         yearDay += (pst->wDayOfWeek - monthDOW) + pst->wDay * 7;
      }

      // It is possible that we overshot the month, especially if pst->wDay
      // is 5 (which means the last instance of the day in the month). Check
      // if the year-day has exceeded the month and adjust accordingly.
      if ((pst->wDay == 5) &&
          (yearDay >= (IS_LEAP_YEAR(year) ? M2LYD[pst->wMonth] :
                                            M2YD [pst->wMonth])))
      {
         yearDay -= 7;
      }

   // If not day-in-month format, then we assume an absolute date.
   } else {

      // Simply add the month day to the current year day.
      yearDay += pst->wDay - 1;
   }

   // Tally up all our days, hours, minutes, and seconds since 1970.
   long seconds = ((SECONDS_IN_A_DAY * (daysToYear + yearDay)) +
                   (3600L * (long)pst->wHour) +
                   (60L * (long)pst->wMinute) +
                   (long)pst->wSecond);

   // If we are checking for the end of DST, then we need to add the DST bias
   // since we are in DST when we chack this time stamp.
   if (!fStartDST) {
      seconds += ptzi->DaylightBias * 60L;
   }

   return (time_t)seconds;
}

//******************************************************************************
static BOOL IsDST(TIME_ZONE_INFORMATION *ptzi, time_t localTime) {

   // If either of the months is 0, then this usually means that the time zone
   // does not use DST.  Unfortunately, Windows CE since it has a bug where it
   // never really fills in these fields with the correct values, so it appears
   // like we are never in DST.  This is supposed to be fixed in future releases,
   // so hopefully this code will get some use then.
   if ((ptzi->StandardDate.wMonth == 0) || (ptzi->DaylightDate.wMonth == 0)) {
      return FALSE;
   }

   // time_t   is a 32-bit value for the seconds since January 1, 1970
   // FILETIME is a 64-bit value for the number of 100-nanosecond intervals
   //          since January 1, 1601

   // Compute the FILETIME for the given local time.
   DWORDLONG dwl = ((DWORDLONG)116444736000000000 +
                   ((DWORDLONG)localTime * (DWORDLONG)10000000));
   FILETIME ft = *(FILETIME*)&dwl;

   // Convert the FILETIME to a SYSTEMTIME.
   SYSTEMTIME st;
   ZeroMemory(&st, sizeof(st));
   FileTimeToSystemTime(&ft, &st);

   // Get our start and end daylight savings times.
   time_t timeStart = GetTransitionTimeT(ptzi, (int)st.wYear, TRUE);
   time_t timeEnd   = GetTransitionTimeT(ptzi, (int)st.wYear, FALSE);

   // Check what hemisphere we are in.
   if (timeStart < timeEnd) {

      // Northern hemisphere ordering.
      return ((localTime >= timeStart) && (localTime < timeEnd));

   } else if (timeStart > timeEnd) {

      // Southern hemisphere ordering.
      return ((localTime < timeEnd) || (localTime >= timeStart));
   }

   // If timeStart equals timeEnd then this time zone does not support DST.
   return FALSE;
}

#endif // _WIN32_WCE

//******************************************************************************
//***** Functions to supply timezone information from the Windows registry to
//***** Info-ZIP's private RTL "localtime() et al." replacements in timezone.c.
//******************************************************************************

//******************************************************************************
// Copied from win32.c
#ifdef W32_USE_IZ_TIMEZONE
#include "timezone.h"
#define SECSPERMIN      60
#define MINSPERHOUR     60
#define SECSPERHOUR     (SECSPERMIN * MINSPERHOUR)
static void conv_to_rule(LPSYSTEMTIME lpw32tm, struct rule * ZCONST ptrule);

static void conv_to_rule(LPSYSTEMTIME lpw32tm, struct rule * ZCONST ptrule)
{
    if (lpw32tm->wYear != 0) {
        ptrule->r_type = JULIAN_DAY;
        ptrule->r_day = ydays[lpw32tm->wMonth - 1] + lpw32tm->wDay;
    } else {
        ptrule->r_type = MONTH_NTH_DAY_OF_WEEK;
        ptrule->r_mon = lpw32tm->wMonth;
        ptrule->r_day = lpw32tm->wDayOfWeek;
        ptrule->r_week = lpw32tm->wDay;
    }
    ptrule->r_time = (long)lpw32tm->wHour * SECSPERHOUR +
                     (long)(lpw32tm->wMinute * SECSPERMIN) +
                     (long)lpw32tm->wSecond;
}

int GetPlatformLocalTimezone(register struct state * ZCONST sp,
        void (*fill_tzstate_from_rules)(struct state * ZCONST sp_res,
                                        ZCONST struct rule * ZCONST start,
                                        ZCONST struct rule * ZCONST end))
{
    TIME_ZONE_INFORMATION tzinfo;
    DWORD res;

    /* read current timezone settings from registry if TZ envvar missing */
    res = GetTimeZoneInformation(&tzinfo);
    if (res != TIME_ZONE_ID_INVALID)
    {
        struct rule startrule, stoprule;

        conv_to_rule(&(tzinfo.StandardDate), &stoprule);
        conv_to_rule(&(tzinfo.DaylightDate), &startrule);
        sp->timecnt = 0;
        sp->ttis[0].tt_abbrind = 0;
        if ((sp->charcnt =
             WideCharToMultiByte(CP_ACP, 0, tzinfo.StandardName, -1,
                                 sp->chars, sizeof(sp->chars), NULL, NULL))
            == 0)
            sp->chars[sp->charcnt++] = '\0';
        sp->ttis[1].tt_abbrind = sp->charcnt;
        sp->charcnt +=
            WideCharToMultiByte(CP_ACP, 0, tzinfo.DaylightName, -1,
                                sp->chars + sp->charcnt,
                                sizeof(sp->chars) - sp->charcnt, NULL, NULL);
        if ((sp->charcnt - sp->ttis[1].tt_abbrind) == 0)
            sp->chars[sp->charcnt++] = '\0';
        sp->ttis[0].tt_gmtoff = - (tzinfo.Bias + tzinfo.StandardBias)
                                * MINSPERHOUR;
        sp->ttis[1].tt_gmtoff = - (tzinfo.Bias + tzinfo.DaylightBias)
                                * MINSPERHOUR;
        sp->ttis[0].tt_isdst = 0;
        sp->ttis[1].tt_isdst = 1;
        sp->typecnt = (startrule.r_mon == 0 && stoprule.r_mon == 0) ? 1 : 2;

        if (sp->typecnt > 1)
            (*fill_tzstate_from_rules)(sp, &startrule, &stoprule);
        return TRUE;
    }
    return FALSE;
}
#endif /* W32_USE_IZ_TIMEZONE */