Ignore:
Timestamp:
Jan 9, 2017, 11:09:38 AM (2 years ago)
Author:
jrpelegrina
Message:

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/engine/directorylistingparser.cpp

    r130 r3185  
    66#include <vector>
    77
    8 std::map<wxString, int> CDirectoryListingParser::m_MonthNamesMap;
     8std::map<std::wstring, int> CDirectoryListingParser::m_MonthNamesMap;
    99
    1010//#define LISTDEBUG_MVS
     
    2020struct ObjectCache
    2121{
    22         CRefcountObject<fzstring> const& get(fzstring const& v)
     22        CRefcountObject<std::wstring> const& get(std::wstring const& v)
    2323        {
    2424                auto it = std::lower_bound(cache.begin(), cache.end(), v);
     
    3333        // alternative as we expect a relatively low amount of inserts.
    3434        // Note that we cannot use set, as it it cannot search based on a different type.
    35         std::vector<CRefcountObject<fzstring>> cache;
     35        std::vector<CRefcountObject<std::wstring>> cache;
    3636};
    3737
     
    5959        };
    6060
    61         CToken(wxChar const* p, unsigned int len)
     61        CToken(wchar_t const* p, unsigned int len)
    6262                : m_pToken(p)
    6363                , m_len(len)
    6464        {}
    6565
    66         wxChar const* GetToken() const
     66        wchar_t const* GetToken() const
    6767        {
    6868                return m_pToken;
     
    7474        }
    7575
    76         fzstring GetString() const
     76        std::wstring GetString() const
    7777        {
    7878                if (!m_pToken || !m_len) {
    79                         return fzstring();
     79                        return std::wstring();
    8080                }
    8181                else {
    82                         return fzstring(m_pToken, m_len);
     82                        return std::wstring(m_pToken, m_len);
    8383                }
    8484        }
     
    114114        bool IsNumeric(unsigned int start, unsigned int len)
    115115        {
    116                 for (unsigned int i = start; i < wxMin(start + len, m_len); ++i)
     116                for (unsigned int i = start; i < std::min(start + len, m_len); ++i)
    117117                        if (m_pToken[i] < '0' || m_pToken[i] > '9')
    118118                                return false;
     
    146146        }
    147147
    148         int Find(const wxChar* chr, int start = 0) const
     148        int Find(const wchar_t* chr, int start = 0) const
    149149        {
    150150                if (!chr)
     
    160160        }
    161161
    162         int Find(wxChar chr, int start = 0) const
     162        int Find(wchar_t chr, int start = 0) const
    163163        {
    164164                if (!m_pToken)
     
    228228                                int64_t number = 0;
    229229                                for (unsigned int i = 0; i < m_len; ++i) {
    230                                         const wxChar& c = m_pToken[i];
     230                                        const wchar_t& c = m_pToken[i];
    231231                                        if (c >= '0' && c <= '9') {
    232232                                                number *= 16;
     
    249249        }
    250250
    251         wxChar operator[](unsigned int n) const
     251        wchar_t operator[](unsigned int n) const
    252252        {
    253253                if (n >= m_len)
     
    258258
    259259protected:
    260         wxChar const* m_pToken{};
     260        wchar_t const* m_pToken{};
    261261        unsigned int m_len{};
    262262
     
    270270{
    271271public:
    272         CLine(wxChar* p, int len = -1, int trailing_whitespace = 0)
     272        CLine(wchar_t* p, int len = -1, int trailing_whitespace = 0)
    273273        {
    274274                m_pLine = p;
     
    276276                        m_len = len;
    277277                else
    278                         m_len = wxStrlen(p);
     278                        m_len = fz::strlen(p);
    279279
    280280                m_parsePos = 0;
     
    344344                                if (!GetToken(prev, ref))
    345345                                        return false;
    346                                 wxChar const* p = ref.GetToken() + ref.GetLength() + 1;
     346                                wchar_t const* p = ref.GetToken() + ref.GetLength() + 1;
    347347
    348348                                auto const newLen = m_len - (p - m_pLine);
     
    365365                        for (unsigned int i = static_cast<unsigned int>(m_LineEndTokens.size()); i <= n; ++i) {
    366366                                const CToken *refToken = m_Tokens[i];
    367                                 const wxChar* p = refToken->GetToken();
     367                                const wchar_t* p = refToken->GetToken();
    368368                                auto const newLen = m_len - (p - m_pLine) - m_trailing_whitespace;
    369369                                if (newLen <= 0) {
     
    381381        {
    382382                int newLen = m_len + pLine->m_len + 1;
    383                 wxChar* p = new wxChar[newLen];
    384                 memcpy(p, m_pLine, m_len * sizeof(wxChar));
     383                wchar_t* p = new wchar_t[newLen];
     384                memcpy(p, m_pLine, m_len * sizeof(wchar_t));
    385385                p[m_len] = ' ';
    386                 memcpy(p + m_len + 1, pLine->m_pLine, pLine->m_len * sizeof(wxChar));
     386                memcpy(p + m_len + 1, pLine->m_pLine, pLine->m_len * sizeof(wchar_t));
    387387
    388388                return new CLine(p, m_len + pLine->m_len + 1, pLine->m_trailing_whitespace);
     
    400400        int m_len;
    401401        int m_trailing_whitespace;
    402         wxChar* m_pLine;
     402        wchar_t* m_pLine;
    403403        unsigned int offset_{};
    404404};
     
    600600                // Some servers send a combination of month name and number,
    601601                // Add corresponding numbers to the month names.
    602                 std::map<wxString, int> combo;
    603                 for (auto iter = m_MonthNamesMap.begin(); iter != m_MonthNamesMap.end(); ++iter)
    604                 {
     602                std::map<std::wstring, int> combo;
     603                for (auto iter = m_MonthNamesMap.begin(); iter != m_MonthNamesMap.end(); ++iter) {
    605604                        // January could be 1 or 0, depends how the server counts
    606                         combo[wxString::Format(_T("%s%02d"), iter->first, iter->second)] = iter->second;
    607                         combo[wxString::Format(_T("%s%02d"), iter->first, iter->second - 1)] = iter->second;
     605                        combo[wxString::Format(_T("%s%02d"), iter->first, iter->second).ToStdWstring()] = iter->second;
     606                        combo[wxString::Format(_T("%s%02d"), iter->first, iter->second - 1).ToStdWstring()] = iter->second;
    608607                        if (iter->second < 10)
    609                                 combo[wxString::Format(_T("%s%d"), iter->first, iter->second)] = iter->second;
     608                                combo[wxString::Format(_T("%s%d"), iter->first, iter->second).ToStdWstring()] = iter->second;
    610609                        else
    611                                 combo[wxString::Format(_T("%s%d"), iter->first, iter->second % 10)] = iter->second;
     610                                combo[wxString::Format(_T("%s%d"), iter->first, iter->second % 10).ToStdWstring()] = iter->second;
    612611                        if (iter->second <= 10)
    613                                 combo[wxString::Format(_T("%s%d"), iter->first, iter->second - 1)] = iter->second;
     612                                combo[wxString::Format(_T("%s%d"), iter->first, iter->second - 1).ToStdWstring()] = iter->second;
    614613                        else
    615                                 combo[wxString::Format(_T("%s%d"), iter->first, (iter->second - 1) % 10)] = iter->second;
     614                                combo[wxString::Format(_T("%s%d"), iter->first, (iter->second - 1) % 10).ToStdWstring()] = iter->second;
    616615                }
    617616                m_MonthNamesMap.insert(combo.begin(), combo.end());
     
    695694        CDirectoryListing listing;
    696695        listing.path = path;
    697         listing.m_firstListTime = CMonotonicClock::now();
     696        listing.m_firstListTime = fz::monotonic_clock::now();
    698697
    699698        if (!ParseData(false)){
     
    834833                // Trim version information from directories
    835834                auto pos = entry.name.rfind(';');
    836                 if (pos != fzstring::npos && pos > 0)
     835                if (pos != std::wstring::npos && pos > 0)
    837836                        entry.name = entry.name.substr(0, pos);
    838837        }
     
    845844                        int64_t seconds = t.GetNumber();
    846845                        if (seconds > 0 && seconds <= 0xffffffffll) {
    847                                 CDateTime time(static_cast<time_t>(seconds), CDateTime::seconds);
    848                                 if (time.IsValid()) {
     846                                fz::datetime time(static_cast<time_t>(seconds), fz::datetime::seconds);
     847                                if (time.empty()) {
    849848                                        entry.time = time;
    850849                                }
     
    856855                auto const timezoneOffset = m_server.GetTimezoneOffset();
    857856                if (timezoneOffset) {
    858                         entry.time += duration::from_minutes(timezoneOffset);
     857                        entry.time += fz::duration::from_minutes(timezoneOffset);
    859858                }
    860859        }
     
    877876                return false;
    878877
    879         wxChar chr = token[0];
     878        wchar_t chr = token[0];
    880879        if (chr != 'b' &&
    881880                chr != 'c' &&
     
    887886                return false;
    888887
    889         fzstring permissions = token.GetString();
     888        std::wstring permissions = token.GetString();
    890889
    891890        entry.flags = 0;
     
    922921                index = startindex;
    923922
    924                 fzstring ownerGroup;
     923                std::wstring ownerGroup;
    925924                for (int i = 0; i < numOwnerGroup; ++i) {
    926925                        if (!line.GetToken(++index, token))
     
    946945                                ownerGroup += _T(" ");
    947946
    948                         wxString const group = token.GetString();
     947                        std::wstring const group = token.GetString();
    949948                        int i;
    950                         for( i = group.size() - 1;
     949                        for (i = group.size() - 1;
    951950                                 i >= 0 && group[i] >= '0' && group[i] <= '9';
    952                                  --i ) {}
    953 
    954                         ownerGroup += group.Left(i + 1);
     951                                 --i) {}
     952
     953                        ownerGroup += group.substr(0, i + 1);
    955954                }
    956955
    957956                if (expect_date) {
    958                         entry.time = CDateTime();
     957                        entry.time = fz::datetime();
    959958                        if (!ParseUnixDateTime(line, index, entry))
    960959                                continue;
     
    976975                if (entry.is_link()) {
    977976                        size_t pos;
    978                         if ((pos = entry.name.find(_T(" -> "))) != fzstring::npos) {
    979                                 entry.target = CSparseOptional<fzstring>(entry.name.substr(pos + 4));
     977                        if ((pos = entry.name.find(_T(" -> "))) != std::wstring::npos) {
     978                                entry.target = CSparseOptional<std::wstring>(entry.name.substr(pos + 4));
    980979                                entry.name = entry.name.substr(0, pos);
    981980                        }
     
    10371036                                return true;
    10381037
    1039                         tm t = entry.time.GetTm(CDateTime::utc);
     1038                        tm t = entry.time.get_tm(fz::datetime::utc);
    10401039                        year = t.tm_year + 1900;
    10411040                        month = t.tm_mon + 1;
     
    11071106
    11081107        if (month < 1) {
    1109                 wxString strMonth = dateMonth.GetString();
    1110                 if (dateMonth.IsLeftNumeric() && (unsigned int)strMonth[strMonth.Length() - 1] > 127) {
     1108                std::wstring strMonth = dateMonth.GetString();
     1109                if (dateMonth.IsLeftNumeric() && (unsigned int)strMonth[strMonth.size() - 1] > 127) {
    11111110                        // Most likely an Asian server sending some unknown language specific
    11121111                        // suffix at the end of the monthname. Filter it out.
    11131112                        int i;
    1114                         for (i = strMonth.Length() - 1; i > 0; --i) {
     1113                        for (i = strMonth.size() - 1; i > 0; --i) {
    11151114                                if (strMonth[i] >= '0' && strMonth[i] <= '9')
    11161115                                        break;
    11171116                        }
    1118                         strMonth = strMonth.Left(i + 1);
     1117                        strMonth = strMonth.substr(0, i + 1);
    11191118                }
    11201119                // Check month name
    1121                 while (strMonth.Right(1) == _T(",") || strMonth.Right(1) == _T("."))
    1122                         strMonth.RemoveLast();
     1120                while (!strMonth.empty() && (strMonth.back() == ',' || strMonth.back() == '.'))
     1121                        strMonth.pop_back();
    11231122                if (!GetMonthFromName(strMonth, month))
    11241123                        return false;
     
    11491148                if( year <= 0 ) {
    11501149                        wxASSERT( month != -1 && day != -1 );
    1151                         tm const t = CDateTime::Now().GetTm(CDateTime::utc);
     1150                        tm const t = fz::datetime::now().get_tm(fz::datetime::utc);
    11521151                        year = t.tm_year + 1900;
    11531152                        int const currentDayOfYear = t.tm_mday + 31 * t.tm_mon;
     
    12051204                --index;
    12061205
    1207         if (!entry.time.Set(CDateTime::utc, year, month, day, hour, minute)) {
     1206        if (!entry.time.set(fz::datetime::utc, year, month, day, hour, minute)) {
    12081207                return false;
    12091208        }
     
    12341233
    12351234                // Check month name
    1236                 wxString dateMonth = token.GetString().substr(0, pos);
     1235                std::wstring const dateMonth = token.GetString().substr(0, pos);
    12371236                if (!GetMonthFromName(dateMonth, month))
    12381237                        return false;
     
    13101309                // Month field in yyyy-mm-dd or dd-mm-yyyy
    13111310                // Check month name
    1312                 wxString dateMonth = token.GetString().substr(pos + 1, pos2 - pos - 1);
     1311                std::wstring dateMonth = token.GetString().substr(pos + 1, pos2 - pos - 1);
    13131312                if (!GetMonthFromName(dateMonth, month))
    13141313                        return false;
     
    13491348        wxASSERT(gotDay);
    13501349
    1351         if (!entry.time.Set(CDateTime::utc, year, month, day)) {
     1350        if (!entry.time.set(fz::datetime::utc, year, month, day)) {
    13521351                return false;
    13531352        }
     
    14111410
    14121411        entry.target.clear();
    1413         entry.ownerGroup = objcache.get(fzstring());
     1412        entry.ownerGroup = objcache.get(std::wstring());
    14141413        entry.permissions = entry.ownerGroup;
    14151414        entry.time += m_timezoneOffset;
     
    14651464        }
    14661465
    1467         return entry.time.ImbueTime(hour, minute, seconds);
     1466        return entry.time.imbue_time(hour, minute, seconds);
    14681467}
    14691468
     
    14861485        entry.size = -1;
    14871486
    1488         fzstring permissions;
     1487        std::wstring permissions;
    14891488
    14901489        int fact = 1;
     
    15121511                        if (number < 0)
    15131512                                return false;
    1514                         entry.time = CDateTime(static_cast<time_t>(number), CDateTime::seconds);
     1513                        entry.time = fz::datetime(static_cast<time_t>(number), fz::datetime::seconds);
    15151514                }
    15161515                else if (type == 'u' && len > 2 && token[fact + 1] == 'p')
     
    15211520
    15221521        entry.permissions = objcache.get(permissions);
    1523         entry.ownerGroup = objcache.get(fzstring());
     1522        entry.ownerGroup = objcache.get(std::wstring());
    15241523        return true;
    15251524}
    15261525
    15271526namespace {
    1528 wxString Unescape(const wxString& str, wxChar escape)
    1529 {
    1530         wxString res;
     1527std::wstring Unescape(const std::wstring& str, wchar_t escape)
     1528{
     1529        std::wstring res;
    15311530        for (unsigned int i = 0; i < str.size(); ++i) {
    1532                 wxChar c = str[i];
     1531                wchar_t c = str[i];
    15331532                if (c == escape) {
    15341533                        ++i;
     
    15751574                return false;
    15761575
    1577         fzstring ownerGroup;
    1578         fzstring permissions;
     1576        std::wstring ownerGroup;
     1577        std::wstring permissions;
    15791578
    15801579        // This field can either be the filesize, a username (at least that's what I think) enclosed in [] or a date.
     
    17381737
    17391738        entry.ownerGroup = objcache.get(ownerGroupToken.GetString());
    1740         entry.permissions = objcache.get(fzstring());
     1739        entry.permissions = objcache.get(std::wstring());
    17411740
    17421741        entry.time += m_timezoneOffset;
     
    17701769                        entry.flags |= CDirentry::flag_dir;
    17711770
    1772                 fzstring ownerGroup = token.GetString();
     1771                std::wstring ownerGroup = token.GetString();
    17731772
    17741773                if (!line.GetToken(++index, token))
     
    17931792                if (number < 0)
    17941793                        return false;
    1795                 entry.time = CDateTime(static_cast<time_t>(number), CDateTime::seconds);
     1794                entry.time = fz::datetime(static_cast<time_t>(number), fz::datetime::seconds);
    17961795
    17971796                // Get filename
     
    18141813
    18151814                // Get date
    1816                 wxString dateMonth = token.GetString();
     1815                std::wstring dateMonth = token.GetString();
    18171816                int month = 0;
    18181817                if (!GetMonthFromName(dateMonth, month)) {
     
    18471846                        entry.name = token.GetString();
    18481847                        if (entry.name.size() >= 5) {
    1849                                 wxString type = entry.name.substr(entry.name.size() - 5);
    1850                                 MakeLowerAscii(type);
     1848                                std::wstring type = fz::str_tolower_ascii(entry.name.substr(entry.name.size() - 5));
    18511849                                if (!skippedCount && type == _T("<dir>")) {
    18521850                                        entry.flags |= CDirentry::flag_dir;
     
    18821880                                year += 1900;
    18831881
    1884                         if( !entry.time.Set(CDateTime::utc, year, month, day) ) {
     1882                        if (!entry.time.set(fz::datetime::utc, year, month, day)) {
    18851883                                return false;
    18861884                        }
     
    19051903                }
    19061904                entry.target.clear();
    1907                 entry.ownerGroup = objcache.get(fzstring());
     1905                entry.ownerGroup = objcache.get(std::wstring());
    19081906                entry.permissions = entry.ownerGroup;
    19091907                entry.time += m_timezoneOffset;
     
    19261924}
    19271925
    1928 bool CDirectoryListingParser::AddLine(wxChar const* pLine)
     1926bool CDirectoryListingParser::AddLine(wchar_t const* pLine)
    19291927{
    19301928        if (m_pControlSocket)
     
    19371935                return false;
    19381936
    1939         const int len = wxStrlen(pLine);
    1940 
    1941         wxChar* p = new wxChar[len + 1];
    1942 
    1943         wxStrcpy(p, pLine);
     1937        const int len = fz::strlen(pLine);
     1938
     1939        wchar_t* p = new wchar_t[len + 1];
     1940
     1941        wcscpy(p, pLine);
    19441942
    19451943        CLine line(p, len);
     
    19911989                                if (iter == m_DataList.end()) {
    19921990                                        if (reslen > 10000) {
    1993                                                 m_pControlSocket->LogMessage(MessageType::Error, _("Received a line exceeding 10000 characters, aborting."));
     1991                                                if (m_pControlSocket) {
     1992                                                        m_pControlSocket->LogMessage(MessageType::Error, _("Received a line exceeding 10000 characters, aborting."));
     1993                                                }
    19941994                                                error = true;
    19951995                                                return 0;
     
    20052005
    20062006                if (reslen > 10000) {
    2007                         m_pControlSocket->LogMessage(MessageType::Error, _("Received a line exceeding 10000 characters, aborting."));
     2007                        if (m_pControlSocket) {
     2008                                m_pControlSocket->LogMessage(MessageType::Error, _("Received a line exceeding 10000 characters, aborting."));
     2009                        }
    20082010                        error = true;
    20092011                        return 0;
     
    20502052
    20512053                size_t lineLength{};
    2052                 wxChar* buffer;
     2054                wchar_t* buffer;
    20532055                if (m_pControlSocket) {
    20542056                        buffer = m_pControlSocket->ConvToLocalBuffer(res, buflen, lineLength);
     
    20572059                else {
    20582060                        wxString str(res, wxConvUTF8);
    2059                         if (str.empty())
    2060                         {
     2061                        if (str.empty()) {
    20612062                                str = wxString(res, wxConvLocal);
    20622063                                if (str.empty())
     
    20642065                        }
    20652066                        lineLength = str.Len() + 1;
    2066                         buffer = new wxChar[str.Len() + 1];
    2067                         wxStrcpy(buffer, str.c_str());
     2067                        buffer = new wchar_t[str.Len() + 1];
     2068                        wcscpy(buffer, str.c_str());
    20682069                }
    20692070                delete [] res;
     
    21232124                return false;
    21242125
    2125         entry.ownerGroup = objcache.get(fzstring());
     2126        entry.ownerGroup = objcache.get(std::wstring());
    21262127        entry.permissions = entry.ownerGroup;
    21272128        entry.time += m_timezoneOffset;
     
    21582159
    21592160                entry.name = token.GetString();
    2160                 if (entry.name.find(' ') != fzstring::npos)
     2161                if (entry.name.find(' ') != std::wstring::npos)
    21612162                        return false;
    21622163
    21632164                entry.size = -1;
    2164                 entry.ownerGroup = objcache.get(fzstring());
     2165                entry.ownerGroup = objcache.get(std::wstring());
    21652166                entry.permissions = entry.ownerGroup;
    21662167
     
    22212222        entry.name = token.GetString();
    22222223
    2223         entry.ownerGroup = objcache.get(fzstring());
     2224        entry.ownerGroup = objcache.get(std::wstring());
    22242225        entry.permissions = entry.ownerGroup;
    22252226
     
    22842285                return false;
    22852286
    2286         entry.ownerGroup = objcache.get(fzstring());
     2287        entry.ownerGroup = objcache.get(std::wstring());
    22872288        entry.permissions = entry.ownerGroup;
    22882289        entry.time += m_timezoneOffset;
     
    23012302                return false;
    23022303
    2303         wxString s = token.GetString();
    2304         MakeLowerAscii(s);
     2304        std::wstring s = fz::str_tolower_ascii(token.GetString());
    23052305        if (s != _T("migrated"))
    23062306                return false;
     
    23162316        entry.flags = 0;
    23172317        entry.size = -1;
    2318         entry.ownerGroup = objcache.get(fzstring());
     2318        entry.ownerGroup = objcache.get(std::wstring());
    23192319        entry.permissions = entry.ownerGroup;
    23202320
     
    23322332
    23332333        entry.flags = 0;
    2334         entry.ownerGroup = objcache.get(fzstring());
     2334        entry.ownerGroup = objcache.get(std::wstring());
    23352335        entry.permissions = entry.ownerGroup;
    23362336        entry.size = -1;
     
    24012401                return false;
    24022402
    2403         wxString s = token.GetString();
    2404         MakeLowerAscii(s);
     2403        std::wstring s = fz::str_tolower_ascii(token.GetString());
    24052404        if (s != _T("tape"))
    24062405                return false;
     
    24122411        entry.name = token.GetString();
    24132412        entry.flags = 0;
    2414         entry.ownerGroup = objcache.get(fzstring());
    2415         entry.permissions = objcache.get(fzstring());
     2413        entry.ownerGroup = objcache.get(std::wstring());
     2414        entry.permissions = objcache.get(std::wstring());
    24162415        entry.size = -1;
    24172416
     
    25232522                return 0;
    25242523
    2525         fzstring const facts = token.GetString();
     2524        std::wstring const facts = token.GetString();
    25262525        if (facts.empty())
    25272526                return 0;
     
    25302529        entry.size = -1;
    25312530
    2532         fzstring owner, group, uid, gid;
    2533         fzstring ownerGroup;
    2534         fzstring permissions;
     2531        std::wstring owner, group, uid, gid;
     2532        std::wstring ownerGroup;
     2533        std::wstring permissions;
    25352534
    25362535        size_t start = 0;
    25372536        while (start < facts.size()) {
    25382537                auto delim = facts.find(';', start);
    2539                 if (delim == fzstring::npos) {
     2538                if (delim == std::wstring::npos) {
    25402539                        delim = facts.size();
    25412540                }
     
    25452544
    25462545                auto const pos = facts.find('=', start);
    2547                 if (pos == fzstring::npos || pos < start + 1 || pos > delim)
     2546                if (pos == std::wstring::npos || pos < start + 1 || pos > delim)
    25482547                        return 0;
    25492548
    2550                 fzstring factname = facts.substr(start, pos - start);
    2551                 MakeLowerAscii(factname);
    2552                 fzstring value = facts.substr(pos + 1, delim - pos - 1);
     2549                std::wstring factname = fz::str_tolower_ascii(facts.substr(start, pos - start));
     2550                std::wstring value = facts.substr(pos + 1, delim - pos - 1);
    25532551                if (factname == _T("type")) {
    25542552                        auto colonPos = value.find(':');
    2555                         fzstring valuePrefix;
    2556                         if (colonPos == fzstring::npos)
    2557                                 valuePrefix = value;
     2553                        std::wstring valuePrefix;
     2554                        if (colonPos == std::wstring::npos)
     2555                                valuePrefix = fz::str_tolower_ascii(value);
    25582556                        else
    2559                                 valuePrefix = value.substr(0, colonPos);
    2560                         MakeLowerAscii(valuePrefix);
    2561 
    2562                         if (valuePrefix == _T("dir") && colonPos == fzstring::npos)
     2557                                valuePrefix = fz::str_tolower_ascii(value.substr(0, colonPos));
     2558
     2559                        if (valuePrefix == _T("dir") && colonPos == std::wstring::npos)
    25632560                                entry.flags |= CDirentry::flag_dir;
    25642561                        else if (valuePrefix == _T("os.unix=slink") || valuePrefix == _T("os.unix=symlink")) {
    25652562                                entry.flags |= CDirentry::flag_dir | CDirentry::flag_link;
    2566                                 if (colonPos != fzstring::npos)
    2567                                         entry.target = CSparseOptional<fzstring>(value.substr(colonPos));
    2568                         }
    2569                         else if ((valuePrefix == _T("cdir") || valuePrefix == _T("pdir")) && colonPos == fzstring::npos) {
     2563                                if (colonPos != std::wstring::npos)
     2564                                        entry.target = CSparseOptional<std::wstring>(value.substr(colonPos));
     2565                        }
     2566                        else if ((valuePrefix == _T("cdir") || valuePrefix == _T("pdir")) && colonPos == std::wstring::npos) {
    25702567                                // Current and parent directory, don't parse it
    25712568                                return 2;
     
    25852582                        (!entry.has_date() && factname == _T("create")))
    25862583                {
    2587                         entry.time = CDateTime(value, CDateTime::utc);
    2588                         if (!entry.time.IsValid()) {
     2584                        entry.time = fz::datetime(value, fz::datetime::utc);
     2585                        if (!entry.time.empty()) {
    25892586                                return 0;
    25902587                        }
     
    27382735        if (!line.GetToken(++index, token))
    27392736                return false;
    2740         wxString format = token.GetString();
     2737        std::wstring format = token.GetString();
    27412738        if (format != _T("V") && format != _T("F"))
    27422739                return false;
     
    27932790
    27942791        entry.ownerGroup = objcache.get(ownerGroupToken.GetString());
    2795         entry.permissions = objcache.get(fzstring());
     2792        entry.permissions = objcache.get(std::wstring());
    27962793        entry.target.clear();
    27972794        entry.time += m_timezoneOffset;
     
    28422839        if (!line.GetToken(++index, token))
    28432840                return false;
    2844         fzstring ownerGroup = token.GetString();
     2841        std::wstring ownerGroup = token.GetString();
    28452842
    28462843        if (token[token.GetLength() - 1] == ',') {
     
    28662863}
    28672864
    2868 bool CDirectoryListingParser::GetMonthFromName(const wxString& name, int &month)
    2869 {
    2870         auto iter = m_MonthNamesMap.find(name.Lower());
     2865bool CDirectoryListingParser::GetMonthFromName(const std::wstring& name, int &month)
     2866{
     2867        std::wstring lower = fz::str_tolower_ascii(name);
     2868        auto iter = m_MonthNamesMap.find(lower);
    28712869        if (iter == m_MonthNamesMap.end())
    2872         {
    2873                 wxString lower(name);
    2874                 MakeLowerAscii(lower);
    2875                 iter = m_MonthNamesMap.find(lower);
    2876                 if (iter == m_MonthNamesMap.end())
    2877                         return false;
    2878         }
     2870                return false;
    28792871
    28802872        month = iter->second;
     
    29282920        int count_normal = 0;
    29292921        int count_ebcdic = 0;
    2930         for (int i = '0'; i <= '9'; ++i ) {
     2922        for (int i = '0'; i <= '9'; ++i) {
    29312923                count_normal += count[i];
    29322924        }
    2933         for (int i = 'a'; i <= 'z'; ++i ) {
     2925        for (int i = 'a'; i <= 'z'; ++i) {
    29342926                count_normal += count[i];
    29352927        }
    2936         for (int i = 'A'; i <= 'Z'; ++i ) {
     2928        for (int i = 'A'; i <= 'Z'; ++i) {
    29372929                count_normal += count[i];
    29382930        }
    29392931
    2940         for (int i = 0x81; i <= 0x89; ++i ) {
     2932        for (int i = 0x81; i <= 0x89; ++i) {
    29412933                count_ebcdic += count[i];
    29422934        }
    2943         for (int i = 0x91; i <= 0x99; ++i ) {
     2935        for (int i = 0x91; i <= 0x99; ++i) {
    29442936                count_ebcdic += count[i];
    29452937        }
    2946         for (int i = 0xa2; i <= 0xa9; ++i ) {
     2938        for (int i = 0xa2; i <= 0xa9; ++i) {
    29472939                count_ebcdic += count[i];
    29482940        }
    2949         for (int i = 0xc1; i <= 0xc9; ++i ) {
     2941        for (int i = 0xc1; i <= 0xc9; ++i) {
    29502942                count_ebcdic += count[i];
    29512943        }
    2952         for (int i = 0xd1; i <= 0xd9; ++i ) {
     2944        for (int i = 0xd1; i <= 0xd9; ++i) {
    29532945                count_ebcdic += count[i];
    29542946        }
    2955         for (int i = 0xe2; i <= 0xe9; ++i ) {
     2947        for (int i = 0xe2; i <= 0xe9; ++i) {
    29562948                count_ebcdic += count[i];
    29572949        }
    2958         for (int i = 0xf0; i <= 0xf9; ++i ) {
     2950        for (int i = 0xf0; i <= 0xf9; ++i) {
    29592951                count_ebcdic += count[i];
    29602952        }
    29612953
    29622954
    2963         if ((count[0x1f] || count[0x15] || count[0x25]) && !count[0x0a] && count[static_cast<unsigned char>('@')] && count[static_cast<unsigned char>('@')] > count[static_cast<unsigned char>(' ')] && count_ebcdic > count_normal)
    2964         {
    2965                 m_pControlSocket->LogMessage(MessageType::Status, _("Received a directory listing which appears to be encoded in EBCDIC."));
     2955        if ((count[0x1f] || count[0x15] || count[0x25]) && !count[0x0a] && count[static_cast<unsigned char>('@')] && count[static_cast<unsigned char>('@')] > count[static_cast<unsigned char>(' ')] && count_ebcdic > count_normal) {
     2956                if (m_pControlSocket) {
     2957                        m_pControlSocket->LogMessage(MessageType::Status, _("Received a directory listing which appears to be encoded in EBCDIC."));
     2958                }
    29662959                m_listingEncoding = listingEncoding::ebcdic;
    29672960                for (auto it = m_DataList.begin(); it != m_DataList.end(); ++it)
Note: See TracChangeset for help on using the changeset viewer.