ShuriZma
/
desmume
mirror of https://github.com/TASEmulators/desmume.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

replace worthless ansi C time functions with DateTime borrowed from mono. fixes year > 2038 bug. source files changed, please rerun autogen.sh. interested users please test well.

This commit is contained in:
zeromus 2010-10-04 08:01:16 +00:00
parent 60badc15d7
commit 964bc43c29
15 changed files with 970 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
desmume/src/GPU_osd.cpp
View File

@ -1,21 +1,18 @@
/* Copyright (C) 2006 yopyop /* Copyright (C) 2006 yopyop
Copyright (C) 2006-2010 DeSmuME team Copyright (C) 2006-2010 DeSmuME team
This file is part of DeSmuME This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
DeSmuME is free software; you can redistribute it and/or modify This file is distributed in the hope that it will be useful,
it under the terms of the GNU General Public License as published by but WITHOUT ANY WARRANTY; without even the implied warranty of
the Free Software Foundation; either version 2 of the License, or MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
(at your option) any later version. GNU General Public License for more details.
DeSmuME is distributed in the hope that it will be useful, You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of along with the this software. If not, see <http://www.gnu.org/licenses/>.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include "GPU_osd.h" #include "GPU_osd.h"
@ -562,9 +559,9 @@ void DrawHUD()
if (CommonSettings.hud.ShowRTC) if (CommonSettings.hud.ShowRTC)
{ {
struct tm tm = rtcGetTime(); DateTime tm = rtcGetTime();
const char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
osd->addFixed(Hud.RTCDisplay.x, Hud.RTCDisplay.y, "%04d-%02d-%02d %s %02d:%02d:%02d", 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday, wday[tm.tm_wday%7], tm.tm_hour, tm.tm_min, tm.tm_sec); osd->addFixed(Hud.RTCDisplay.x, Hud.RTCDisplay.y, "%04d-%03s-%02d %s %02d:%02d:%02d", tm.get_Year(), DateTime::GetNameOfMonth(tm.get_Month()), tm.get_Day(), wday[tm.get_DayOfWeek()%7], tm.get_Hour(), tm.get_Minute(), tm.get_Second());
} }
DrawStateSlots(); DrawStateSlots();

2
desmume/src/Makefile.am
View File

@ -42,7 +42,7 @@ libdesmume_a_SOURCES = \
shaders.h \ shaders.h \
movie.cpp movie.h \ movie.cpp movie.h \
PACKED.h PACKED_END.h \ PACKED.h PACKED_END.h \
utils/mkgmtime.cpp utils/mkgmtime.h \ utils/datetime.cpp utils/datetime.h \
utils/ConvertUTF.c utils/ConvertUTF.h utils/guid.cpp utils/guid.h \ utils/ConvertUTF.c utils/ConvertUTF.h utils/guid.cpp utils/guid.h \
utils/md5.cpp utils/md5.h utils/valuearray.h utils/xstring.cpp utils/xstring.h \ utils/md5.cpp utils/md5.h utils/valuearray.h utils/xstring.cpp utils/xstring.h \
utils/decrypt/crc.cpp utils/decrypt/crc.h utils/decrypt/decrypt.cpp \ utils/decrypt/crc.cpp utils/decrypt/crc.h utils/decrypt/decrypt.cpp \

70
desmume/src/movie.cpp
View File

@ -1,20 +1,17 @@
/* Copyright 2008-2010 DeSmuME team /* Copyright 2008-2010 DeSmuME team
This file is part of DeSmuME This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
DeSmuME is free software; you can redistribute it and/or modify This file is distributed in the hope that it will be useful,
it under the terms of the GNU General Public License as published by but WITHOUT ANY WARRANTY; without even the implied warranty of
the Free Software Foundation; either version 2 of the License, or MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
(at your option) any later version. GNU General Public License for more details.
DeSmuME is distributed in the hope that it will be useful, You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of along with the this software. If not, see <http://www.gnu.org/licenses/>.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
@ -24,7 +21,7 @@
#include <time.h> #include <time.h>
#include "utils/guid.h" #include "utils/guid.h"
#include "utils/xstring.h" #include "utils/xstring.h"
#include "utils/mkgmtime.h" #include "utils/datetime.h"
#include "movie.h" #include "movie.h"
#include "NDSSystem.h" #include "NDSSystem.h"
#include "readwrite.h" #include "readwrite.h"
@ -167,27 +164,10 @@ void MovieRecord::dump(MovieData* md, EMUFILE* fp, int index)
fp->fputc('\n'); fp->fputc('\n');
} }
time_t FCEUI_MovieGetRTCDefault() DateTime FCEUI_MovieGetRTCDefault()
{ {
time_t timer;
// compatible with old desmume // compatible with old desmume
struct tm t; return DateTime(2009,1,1,0,0,0);
t.tm_year = 109; // 2009
t.tm_mon = 0; // 1 (Jan)
t.tm_mday = 1;
t.tm_wday = 4;
t.tm_hour = 0; //12 AM
t.tm_min = 0;
t.tm_sec = 0;
timer = mkgmtime(&t);
// current time
//timer = time(NULL);
//struct tm *tp = localtime(&timer);
//timer = mkgmtime(tp);
return timer;
} }
MovieData::MovieData() MovieData::MovieData()
@ -238,15 +218,18 @@ void MovieData::installValue(std::string& key, std::string& val)
if (validFormat) { if (validFormat) {
struct tm t; struct tm t;
const char *s = val.data(); const char *s = val.data();
t.tm_year = atoi(&s[0]) - 1900; int year = atoi(&s[0]);
t.tm_mon = atoi(&s[5]) - 1; int mon = atoi(&s[5]);
t.tm_mday = atoi(&s[8]); int day = atoi(&s[8]);
t.tm_hour = atoi(&s[11]); int hour = atoi(&s[11]);
t.tm_min = atoi(&s[14]); int min = atoi(&s[14]);
t.tm_sec = atoi(&s[17]); int sec = atoi(&s[17]);
rtcStart = mkgmtime(&t); rtcStart = DateTime(year,mon,day,hour,min,sec);
} }
} }
else if(key == "rtcStartNew") {
DateTime::TryParse(val.c_str(),rtcStart);
}
else if(key == "comment") else if(key == "comment")
comments.push_back(mbstowcs(val)); comments.push_back(mbstowcs(val));
else if(key == "binary") else if(key == "binary")
@ -320,10 +303,7 @@ int MovieData::dump(EMUFILE* fp, bool binary)
fp->fprintf("firmLanguage %d\n", CommonSettings.InternalFirmConf.language); fp->fprintf("firmLanguage %d\n", CommonSettings.InternalFirmConf.language);
} }
char timestr[32]; fp->fprintf("rtcStartNew %s\n", rtcStart.ToString().c_str());
struct tm *tm = gmtime(&rtcStart);
strftime(timestr, 32, "%Y-%m-%dT%H:%M:%SZ", tm);
fp->fprintf("rtcStart %s\n", timestr);
for(uint32 i=0;i<comments.size();i++) for(uint32 i=0;i<comments.size();i++)
fp->fprintf("comment %s\n", wcstombs(comments[i]).c_str()); fp->fprintf("comment %s\n", wcstombs(comments[i]).c_str());
@ -646,7 +626,7 @@ bool MovieData::loadSramFrom(std::vector<u8>* buf)
//begin recording a new movie //begin recording a new movie
//TODO - BUG - the record-from-another-savestate doesnt work. //TODO - BUG - the record-from-another-savestate doesnt work.
void _CDECL_ FCEUI_SaveMovie(const char *fname, std::wstring author, int flag, std::string sramfname, time_t rtcstart) void FCEUI_SaveMovie(const char *fname, std::wstring author, int flag, std::string sramfname, const DateTime &rtcstart)
{ {
//if(!FCEU_IsValidUI(FCEUI_RECORDMOVIE)) //if(!FCEU_IsValidUI(FCEUI_RECORDMOVIE))
// return; // return;

23
desmume/src/movie.h
View File

@ -1,3 +1,19 @@
/* Copyright 2008-2010 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MOVIE_H_ #ifndef __MOVIE_H_
#define __MOVIE_H_ #define __MOVIE_H_
@ -8,6 +24,7 @@
#include <time.h> #include <time.h>
#include "emufile.h" #include "emufile.h"
#include "utils/datetime.h"
#include "utils/guid.h" #include "utils/guid.h"
#include "utils/md5.h" #include "utils/md5.h"
@ -129,7 +146,7 @@ public:
int rerecordCount; int rerecordCount;
Desmume_Guid guid; Desmume_Guid guid;
time_t rtcStart; // (time_t) it always means gmtime, not localtime. DateTime rtcStart;
//was the frame data stored in binary? //was the frame data stored in binary?
bool binaryFlag; bool binaryFlag;
@ -195,7 +212,7 @@ extern MovieData currMovieData; //adelikat: main needs this for frame counter d
extern bool movie_reset_command; extern bool movie_reset_command;
bool FCEUI_MovieGetInfo(EMUFILE* fp, MOVIE_INFO& info, bool skipFrameCount); bool FCEUI_MovieGetInfo(EMUFILE* fp, MOVIE_INFO& info, bool skipFrameCount);
void _CDECL_ FCEUI_SaveMovie(const char *fname, std::wstring author, int flag, std::string sramfname, time_t rtcstart); void FCEUI_SaveMovie(const char *fname, std::wstring author, int flag, std::string sramfname, const DateTime &rtcstart);
const char* _CDECL_ FCEUI_LoadMovie(const char *fname, bool _read_only, bool tasedit, int _pauseframe); // returns NULL on success, errmsg on failure const char* _CDECL_ FCEUI_LoadMovie(const char *fname, bool _read_only, bool tasedit, int _pauseframe); // returns NULL on success, errmsg on failure
void FCEUI_StopMovie(); void FCEUI_StopMovie();
void FCEUMOV_AddInputState(); void FCEUMOV_AddInputState();
@ -208,5 +225,5 @@ bool LoadFM2(MovieData& movieData, EMUFILE* fp, int size, bool stopAfterHeader);
extern bool movie_readonly; extern bool movie_readonly;
extern bool ShowInputDisplay; extern bool ShowInputDisplay;
void FCEUI_MakeBackupMovie(bool dispMessage); void FCEUI_MakeBackupMovie(bool dispMessage);
time_t FCEUI_MovieGetRTCDefault(); DateTime FCEUI_MovieGetRTCDefault();
#endif #endif

80
desmume/src/rtc.cpp
View File

@ -1,22 +1,19 @@
/* Copyright (C) 2006 yopyop /* Copyright 2006 yopyop
Copyright 2008 CrazyMax Copyright 2008 CrazyMax
Copyright 2008-2010 DeSmuME team Copyright 2008-2010 DeSmuME team
This file is part of DeSmuME This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
DeSmuME is free software; you can redistribute it and/or modify This file is distributed in the hope that it will be useful,
it under the terms of the GNU General Public License as published by but WITHOUT ANY WARRANTY; without even the implied warranty of
the Free Software Foundation; either version 2 of the License, or MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
(at your option) any later version. GNU General Public License for more details.
DeSmuME is distributed in the hope that it will be useful, You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of along with the this software. If not, see <http://www.gnu.org/licenses/>.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
// TODO: interrupt handler // TODO: interrupt handler
@ -32,8 +29,6 @@
#endif #endif
#include "movie.h" #include "movie.h"
#include "utils/mkgmtime.h"
typedef struct typedef struct
{ {
@ -98,13 +93,11 @@ static inline u8 toBCD(u8 x)
bool moviemode=false; bool moviemode=false;
struct tm rtcGetTime(void) DateTime rtcGetTime(void)
{ {
struct tm *tm = NULL; DateTime tm;
if(movieMode == MOVIEMODE_INACTIVE) { if(movieMode == MOVIEMODE_INACTIVE) {
time_t timer; return DateTime::get_Now();
time(&timer);
tm = localtime(&timer);
} }
else { else {
//now, you might think it is silly to go through all these conniptions //now, you might think it is silly to go through all these conniptions
@ -117,20 +110,9 @@ struct tm rtcGetTime(void)
u64 totalcycles = (u64)arm9rate_unitsperframe * currFrameCounter; u64 totalcycles = (u64)arm9rate_unitsperframe * currFrameCounter;
u64 totalseconds=totalcycles/arm9rate_unitspersecond; u64 totalseconds=totalcycles/arm9rate_unitspersecond;
time_t timer; DateTime timer = currMovieData.rtcStart;
struct tm t; return timer.AddSeconds(totalseconds);
// store start time into structure tm
timer = (time_t) currMovieData.rtcStart;
memcpy(&t, gmtime(&timer), sizeof(struct tm));
// advance it according to the frame counter
t.tm_sec += totalseconds;
// then, normalize it
timer = mkgmtime(&t);
tm = gmtime(&timer);
} }
tm->tm_year = 100 + (tm->tm_year % 100); // 20XX
return *tm;
} }
static void rtcRecv() static void rtcRecv()
@ -153,10 +135,10 @@ static void rtcRecv()
case 2: // date & time case 2: // date & time
{ {
//INFO("RTC: read date & time\n"); //INFO("RTC: read date & time\n");
struct tm tm = rtcGetTime(); DateTime tm = rtcGetTime();
rtc.data[0] = toBCD(tm.tm_year % 100); rtc.data[0] = toBCD(tm.get_Year() % 100);
rtc.data[1] = toBCD(tm.tm_mon + 1); rtc.data[1] = toBCD(tm.get_Month());
rtc.data[2] = toBCD(tm.tm_mday); rtc.data[2] = toBCD(tm.get_Day());
//zero 24-apr-2010 - this is nonsense. //zero 24-apr-2010 - this is nonsense.
//but it is so wrong, someone mustve thought they knew what they were doing, so i am leaving it... //but it is so wrong, someone mustve thought they knew what they were doing, so i am leaving it...
@ -166,22 +148,24 @@ static void rtcRecv()
//do this instead (gbatek seems to say monday=0 but i don't think that is right) //do this instead (gbatek seems to say monday=0 but i don't think that is right)
//0=sunday is necessary to make animal crossing behave //0=sunday is necessary to make animal crossing behave
//maybe it means "custom assignment" can be specified by the game //maybe it means "custom assignment" can be specified by the game
rtc.data[3] = tm.tm_wday; rtc.data[3] = tm.get_DayOfWeek();
if (!(rtc.regStatus1 & 0x02)) tm.tm_hour %= 12; int hour = tm.get_Hour();
rtc.data[4] = ((tm.tm_hour < 12) ? 0x00 : 0x40) | toBCD(tm.tm_hour); if (!(rtc.regStatus1 & 0x02)) hour %= 12;
rtc.data[5] = toBCD(tm.tm_min); rtc.data[4] = ((hour < 12) ? 0x00 : 0x40) | toBCD(hour);
rtc.data[6] = toBCD(tm.tm_sec); rtc.data[5] = toBCD(tm.get_Minute());
rtc.data[6] = toBCD(tm.get_Second());
break; break;
} }
case 3: // time case 3: // time
{ {
//INFO("RTC: read time\n"); //INFO("RTC: read time\n");
struct tm tm = rtcGetTime(); DateTime tm = rtcGetTime();
if (!(rtc.regStatus1 & 0x02)) tm.tm_hour %= 12; int hour = tm.get_Hour();
rtc.data[0] = ((tm.tm_hour < 12) ? 0x00 : 0x40) | toBCD(tm.tm_hour); if (!(rtc.regStatus1 & 0x02)) hour %= 12;
rtc.data[1] = toBCD(tm.tm_min); rtc.data[0] = ((hour < 12) ? 0x00 : 0x40) | toBCD(hour);
rtc.data[2] = toBCD(tm.tm_sec); rtc.data[1] = toBCD(tm.get_Minute());
rtc.data[2] = toBCD(tm.get_Second());
break; break;
} }
case 4: // freq/alarm 1 case 4: // freq/alarm 1

28
desmume/src/rtc.h
View File

@ -1,22 +1,19 @@
/* Copyright (C) 2006 yopyop /* Copyright 2006 yopyop
Copyright 2008 CrazyMax Copyright 2008 CrazyMax
Copyright 2008-2010 DeSmuME team Copyright 2008-2010 DeSmuME team
This file is part of DeSmuME This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
DeSmuME is free software; you can redistribute it and/or modify This file is distributed in the hope that it will be useful,
it under the terms of the GNU General Public License as published by but WITHOUT ANY WARRANTY; without even the implied warranty of
the Free Software Foundation; either version 2 of the License, or MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
(at your option) any later version. GNU General Public License for more details.
DeSmuME is distributed in the hope that it will be useful, You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of along with the this software. If not, see <http://www.gnu.org/licenses/>.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#ifndef _RTC_H_ #ifndef _RTC_H_
@ -24,8 +21,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include "types.h" #include "types.h"
#include "utils/datetime.h"
struct tm rtcGetTime(void); DateTime rtcGetTime(void);
extern void rtcInit(); extern void rtcInit();
extern u16 rtcRead(); extern u16 rtcRead();

5
desmume/src/utils/datetime.cpp Normal file
View File

@ -0,0 +1,5 @@
#include "datetime.h"
const char* DateTime::monthnames[] = { NULL, "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC" };
const int DateTime::daysmonth[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
const int DateTime::daysmonthleap[] = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

814
desmume/src/utils/datetime.h Normal file
View File

@ -0,0 +1,814 @@
/* Copyright (C) 2010 DeSmuME team
This file is based on System.DateTime.cs and System.TimeSpan.cs from mono-2.6.7
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see <http://www.gnu.org/licenses/>.
*/
//
// System.DateTime.cs
//
// author:
// Marcel Narings (marcel@narings.nl)
// Martin Baulig (martin@gnome.org)
// Atsushi Enomoto (atsushi@ximian.com)
//
// (C) 2001 Marcel Narings
// Copyright (C) 2004-2006 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// System.TimeSpan.cs
//
// Authors:
// Duco Fijma (duco@lorentz.xs4all.nl)
// Andreas Nahr (ClassDevelopment@A-SoftTech.com)
// Sebastien Pouliot <sebastien@ximian.com>
//
// (C) 2001 Duco Fijma
// (C) 2004 Andreas Nahr
// Copyright (C) 2004 Novell (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#ifndef _DATETIME_H_
#define _DATETIME_H_
#include <math.h>
#include <time.h>
#include <string>
#include <string.h>
#include "types.h"
enum DayOfWeek {
DayOfWeek_Sunday=0,
DayOfWeek_Monday=1,
DayOfWeek_Tuesday=2,
DayOfWeek_Wednesday=3,
DayOfWeek_Thursday=4,
DayOfWeek_Friday=5,
DayOfWeek_Saturday=6
};
class TimeSpan
{
friend class DateTime;
public:
static const TimeSpan& get_MaxValue()
{
static TimeSpan val(0x7FFFFFFFFFFFFFFFLL);
return val;
}
static const TimeSpan& get_MinValue()
{
static TimeSpan val(0x8000000000000000LL);
return val;
}
static const TimeSpan& get_Zero()
{
static TimeSpan val(0);
return val;
}
static const s64 TicksPerDay = 864000000000LL;
static const s64 TicksPerHour = 36000000000LL;
static const s64 TicksPerMillisecond = 10000LL;
static const s64 TicksPerMinute = 600000000LL;
static const s64 TicksPerSecond = 10000000LL;
TimeSpan ()
{
}
TimeSpan (s64 ticks)
: _ticks(ticks)
{
}
TimeSpan (int hours, int minutes, int seconds)
{
_ticks = CalculateTicks (0, hours, minutes, seconds, 0);
}
TimeSpan (int days, int hours, int minutes, int seconds)
{
_ticks = CalculateTicks (days, hours, minutes, seconds, 0);
}
TimeSpan (int days, int hours, int minutes, int seconds, int milliseconds)
{
_ticks = CalculateTicks (days, hours, minutes, seconds, milliseconds);
}
int get_Days() const { return (int) (_ticks / TicksPerDay); }
int get_Hours() const { return (int) (_ticks % TicksPerDay / TicksPerHour); }
int get_Milliseconds() const { return (int) (_ticks % TicksPerSecond / TicksPerMillisecond); }
int get_Minutes() const { return (int) (_ticks % TicksPerHour / TicksPerMinute); }
int get_Seconds() const { return (int) (_ticks % TicksPerMinute / TicksPerSecond); }
s64 get_Ticks() const { return _ticks; }
double get_TotalDays() const { return (double) _ticks / TicksPerDay; }
double get_TotalHours() const { return (double) _ticks / TicksPerHour; }
double get_TotalMilliseconds() const { return (double) _ticks / TicksPerMillisecond; }
double get_TotalMinutes() const { return (double) _ticks / TicksPerMinute; }
double get_TotalSeconds() const { return (double) _ticks / TicksPerSecond; }
TimeSpan Add (const TimeSpan &ts)
{
return TimeSpan (_ticks + ts._ticks);
//removed:
//catch (OverflowException) throw new OverflowException (Locale.GetText ("Resulting timespan is too big."));
}
static int Compare (const TimeSpan& t1, const TimeSpan& t2)
{
if (t1._ticks < t2._ticks)
return -1;
if (t1._ticks > t2._ticks)
return 1;
return 0;
}
int CompareTo (const TimeSpan& value)
{
return Compare (*this, value);
}
TimeSpan Duration ()
{
return TimeSpan(_ticks<0?-_ticks:_ticks);
//removed:
//catch (OverflowException) throw new OverflowException (Locale.GetText ("This TimeSpan value is MinValue so you cannot get the duration."));
}
static TimeSpan FromDays (double value)
{
return From (value, TicksPerDay);
}
static TimeSpan FromHours (double value)
{
return From (value, TicksPerHour);
}
static TimeSpan FromMinutes (double value)
{
return From (value, TicksPerMinute);
}
static TimeSpan FromSeconds (double value)
{
return From (value, TicksPerSecond);
}
static TimeSpan FromMilliseconds (double value)
{
return From (value, TicksPerMillisecond);
}
static TimeSpan FromTicks (s64 value)
{
return TimeSpan (value);
}
TimeSpan Negate ()
{
//removed error handling
//if (_ticks == MinValue()._ticks) throw new OverflowException (Locale.GetText ( "This TimeSpan value is MinValue and cannot be negated."));
return TimeSpan (-_ticks);
}
TimeSpan Subtract (const TimeSpan& ts)
{
//removed error handling
//try { checked {
return TimeSpan (_ticks - ts._ticks);
// }
//}
//catch (OverflowException) {
// throw new OverflowException (Locale.GetText ("Resulting timespan is too big."));
//}
}
TimeSpan operator + (const TimeSpan& t2) const
{
TimeSpan temp = *this;
temp.Add (t2);
return temp;
}
bool operator == (const TimeSpan& t2) const
{
return _ticks == t2._ticks;
}
bool operator > (const TimeSpan& t2) const
{
return _ticks > t2._ticks;
}
bool operator >= (const TimeSpan& t2) const
{
return _ticks >= t2._ticks;
}
bool operator != (const TimeSpan& t2) const
{
return _ticks != t2._ticks;
}
bool operator < (const TimeSpan& t2) const
{
return _ticks < t2._ticks;
}
bool operator <= (const TimeSpan& t2) const
{
return _ticks <= t2._ticks;
}
TimeSpan operator - (const TimeSpan& t2) const
{
TimeSpan temp = *this;
return temp.Subtract (t2);
}
TimeSpan operator - ()
{
return Negate ();
}
private:
s64 _ticks;
static s64 CalculateTicks (int days, int hours, int minutes, int seconds, int milliseconds)
{
// there's no overflow checks for hours, minutes, ...
// so big hours/minutes values can overflow at some point and change expected values
int hrssec = (hours * 3600); // break point at (Int32.MaxValue - 596523)
int minsec = (minutes * 60);
s64 t = ((s64)(hrssec + minsec + seconds) * 1000L + (s64)milliseconds);
t *= 10000;
bool overflow = false;
// days is problematic because it can overflow but that overflow can be
// "legal" (i.e. temporary) (e.g. if other parameters are negative) or
// illegal (e.g. sign change).
if (days > 0) {
s64 td = TicksPerDay * days;
if (t < 0) {
s64 ticks = t;
t += td;
// positive days -> total ticks should be lower
overflow = (ticks > t);
}
else {
t += td;
// positive + positive != negative result
overflow = (t < 0);
}
}
else if (days < 0) {
s64 td = TicksPerDay * days;
if (t <= 0) {
t += td;
// negative + negative != positive result
overflow = (t > 0);
}
else {
s64 ticks = t;
t += td;
// negative days -> total ticks should be lower
overflow = (t > ticks);
}
}
//removed:
//if (overflow) throw ArgumentOutOfRangeException ("The timespan is too big or too small.");
return t;
}
static TimeSpan From (double value, s64 tickMultiplicator)
{
//a bunch of error handling removed
//if (Double.IsNaN (value)) throw new ArgumentException (Locale.GetText ("Value cannot be NaN."), "value");
//if (Double.IsNegativeInfinity (value) || Double.IsPositiveInfinity (value) ||
// (value < MinValue.Ticks) || (value > MaxValue.Ticks))
// throw new OverflowException (Locale.GetText ("Outside range [MinValue,MaxValue]"));
//try {
value = (value * (tickMultiplicator / TicksPerMillisecond));
// checked {
// long val = (long) Math.Round(value);
// return new TimeSpan (val * TicksPerMillisecond);
// }
//}
//catch (OverflowException) {
// throw new OverflowException (Locale.GetText ("Resulting timespan is too big."));
//}
//}
}
};
class DateTime
{
private:
TimeSpan ticks;
static inline double round(const double x) { return floor(x + 0.5); }
static const int dp400 = 146097;
static const int dp100 = 36524;
static const int dp4 = 1461;
// w32 file time starts counting from 1/1/1601 00:00 GMT
// which is the constant ticks from the .NET epoch
static const s64 w32file_epoch = 504911232000000000LL;
//private const long MAX_VALUE_TICKS = 3155378975400000000L;
// -- Microsoft .NET has this value.
static const s64 MAX_VALUE_TICKS = 3155378975999999999LL;
//
// The UnixEpoch, it begins on Jan 1, 1970 at 0:0:0, expressed
// in Ticks
//
static const s64 UnixEpoch = 621355968000000000LL;
static const int daysmonth[13];
static const int daysmonthleap[13];
static const char* monthnames[13];
void init (int year, int month, int day, int hour, int minute, int second, int millisecond)
{
//removed error handling
/* if ( year < 1 || year > 9999 ||
month < 1 || month >12 ||
day < 1 || day > DaysInMonth(year, month) ||
hour < 0 || hour > 23 ||
minute < 0 || minute > 59 ||
second < 0 || second > 59 ||
millisecond < 0 || millisecond > 999)
throw new ArgumentOutOfRangeException ("Parameters describe an " +
"unrepresentable DateTime.");*/
ticks = TimeSpan (AbsoluteDays(year,month,day), hour, minute, second, millisecond);
}
static int AbsoluteDays (int year, int month, int day)
{
const int* days;
int temp = 0, m=1 ;
days = (IsLeapYear(year) ? daysmonthleap : daysmonth);
while (m < month)
temp += days[m++];
return ((day-1) + temp + (365* (year-1)) + ((year-1)/4) - ((year-1)/100) + ((year-1)/400));
}
enum Which
{
Which_Day,
Which_DayYear,
Which_Month,
Which_Year
};
int FromTicks(Which what) const
{
int num400, num100, num4, numyears;
int M =1;
const int* days = daysmonth;
int totaldays = ticks.get_Days();
num400 = (totaldays / dp400);
totaldays -= num400 * dp400;
num100 = (totaldays / dp100);
if (num100 == 4) // leap
num100 = 3;
totaldays -= (num100 * dp100);
num4 = totaldays / dp4;
totaldays -= (num4 * dp4);
numyears = totaldays / 365 ;
if (numyears == 4) //leap
numyears =3 ;
if (what == Which_Year )
return num400*400 + num100*100 + num4*4 + numyears + 1;
totaldays -= (numyears * 365) ;
if (what == Which_DayYear )
return totaldays + 1;
if ((numyears==3) && ((num100 == 3) || !(num4 == 24)) ) //31 dec leapyear
days = daysmonthleap;
while (totaldays >= days[M])
totaldays -= days[M++];
if (what == Which_Month )
return M;
return totaldays +1;
}
public:
DateTime()
: ticks(0)
{
}
static const char* GetNameOfMonth(int month) { return monthnames[month]; }
DateTime (s64 ticks)
{
this->ticks = TimeSpan (ticks);
//removed error handling
//if (ticks < get_MinValue().get_Ticks() || ticks > get_MaxValue().get_Ticks()) {
// string msg = Locale.GetText ("Value {0} is outside the valid range [{1},{2}].",
// ticks, MinValue.Ticks, MaxValue.Ticks);
// throw new ArgumentOutOfRangeException ("ticks", msg);
//}
}
static const DateTime& get_MaxValue() {
static DateTime val(false, TimeSpan (MAX_VALUE_TICKS));
return val;
}
static const DateTime& get_MinValue() {
static DateTime val(false, TimeSpan (0));
return val;
}
DateTime (int year, int month, int day)
{
init(year,month,day,0,0,0,0);
}
DateTime (int year, int month, int day, int hour, int minute, int second)
{
init(year, month, day, hour, minute, second, 0);
}
DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond)
{
init(year,month,day,hour,minute,second,millisecond);
}
DateTime (bool check, const TimeSpan& value)
{
//removed error handling
//if (check && (value.Ticks < MinValue.Ticks || value.Ticks > MaxValue.Ticks))
// throw new ArgumentOutOfRangeException ();
ticks = value;
}
DateTime get_Date () const
{
return DateTime (get_Year(), get_Month(), get_Day());
}
int get_Month () const {
return FromTicks(Which_Month);
}
int get_Day() const
{
return FromTicks(Which_Day);
}
DayOfWeek get_DayOfWeek () const
{
return ( (DayOfWeek) ((ticks.get_Days()+1) % 7) );
}
int get_DayOfYear () const
{
return FromTicks(Which_DayYear);
}
TimeSpan get_TimeOfDay () const
{
return TimeSpan(ticks.get_Ticks() % TimeSpan::TicksPerDay );
}
int get_Hour () const
{
return ticks.get_Hours();
}
int get_Minute () const
{
return ticks.get_Minutes();
}
int get_Second () const
{
return ticks.get_Seconds();
}
int get_Millisecond () const
{
return ticks.get_Milliseconds();
}
//internal static extern s64 GetTimeMonotonic ();
//internal static extern s64 GetNow ();
static DateTime get_Now ()
{
time_t timer;
time(&timer);
struct tm *tm = localtime(&timer);
return DateTime(tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec);
}
s64 get_Ticks()const
{
return ticks.get_Ticks();
}
static DateTime get_Today ()
{
DateTime now = get_Now();
DateTime today = DateTime (now.get_Year(), now.get_Month(), now.get_Day());
return today;
}
int get_Year () const
{
return FromTicks(Which_Year);
}
DateTime Add (const TimeSpan& value) const
{
DateTime ret = AddTicks (value.get_Ticks());
return ret;
}
DateTime AddDays (double value) const
{
return AddMilliseconds (round(value * 86400000));
}
DateTime AddTicks (const s64 value) const
{
//removed error handling
//if ((value + ticks.Ticks) > MAX_VALUE_TICKS || (value + ticks.Ticks) < 0) {
// throw new ArgumentOutOfRangeException();
//}
return DateTime (value + ticks.get_Ticks());
}
DateTime AddHours (double value) const
{
return AddMilliseconds (value * 3600000);
}
DateTime AddMilliseconds (double value) const
{
//removed error handling
/* if ((value * TimeSpan.TicksPerMillisecond) > long.MaxValue ||
(value * TimeSpan.TicksPerMillisecond) < long.MinValue) {
throw new ArgumentOutOfRangeException();
}
*/
s64 msticks = (s64) round(value * TimeSpan::TicksPerMillisecond);
return AddTicks (msticks);
}
DateTime AddMinutes (double value) const
{
return AddMilliseconds (value * 60000);
}
DateTime AddMonths (int months) const
{
int day, month, year, maxday ;
DateTime temp;
day = get_Day();
month = get_Month() + (months % 12);
year = get_Year() + months/12 ;
if (month < 1)
{
month = 12 + month ;
year -- ;
}
else if (month>12)
{
month = month -12;
year ++;
}
maxday = DaysInMonth(year, month);
if (day > maxday)
day = maxday;
temp = (year, month, day);
return temp.Add (get_TimeOfDay());
}
DateTime AddSeconds (double value) const
{
return AddMilliseconds (value * 1000);
}
DateTime AddYears (int value) const
{
return AddMonths (value * 12);
}
static int Compare (const DateTime& t1, const DateTime& t2)
{
if (t1.ticks < t2.ticks)
return -1;
else if (t1.ticks > t2.ticks)
return 1;
else
return 0;
}
static int DaysInMonth (int year, int month)
{
const int* days ;
//removed error handling
//if (month < 1 || month >12)throw new ArgumentOutOfRangeException ();
//if (year < 1 || year > 9999)throw new ArgumentOutOfRangeException ();
days = (IsLeapYear(year) ? daysmonthleap : daysmonth);
return days[month];
}
static bool IsLeapYear (int year)
{
//removed error handling
/* if (year < 1 || year > 9999)
throw new ArgumentOutOfRangeException ();*/
return ( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ;
}
TimeSpan Subtract (const DateTime& value) const
{
return TimeSpan (ticks.get_Ticks()) - value.ticks;
}
DateTime Subtract(const TimeSpan& value) const
{
TimeSpan newticks;
newticks = (TimeSpan (ticks.get_Ticks())) - value;
DateTime ret = DateTime (true,newticks);
return ret;
}
DateTime operator +(const TimeSpan& t) const
{
return DateTime (true, ticks + t);
}
bool operator ==(const DateTime& d2) const
{
return (ticks == d2.ticks);
}
bool operator >(const DateTime& t2) const
{
return (ticks > t2.ticks);
}
bool operator >=(const DateTime &t2) const
{
return (ticks >= t2.ticks);
}
bool operator !=(const DateTime& d2) const
{
return (ticks != d2.ticks);
}
bool operator <(const DateTime& t2) const
{
return (ticks < t2.ticks );
}
bool operator <=(const DateTime& t2) const
{
return (ticks <= t2.ticks);
}
TimeSpan operator -(const DateTime& d2) const
{
return TimeSpan((ticks - d2.ticks).get_Ticks());
}
DateTime operator -(const TimeSpan& t) const
{
return DateTime (true, ticks - t);
}
//try to have a canonical format here. this was comment was typed at 2010-oct-04 02:16:44:000
std::string ToString() const
{
char tmp[32];
sprintf(tmp,"%04d-%s-%02d %02d:%02d:%02d:%03d",get_Year(),monthnames[get_Month()],get_Day(),get_Hour(),get_Minute(),get_Second(),get_Millisecond());
return tmp;
}
static bool TryParse(const char* str, DateTime& out)
{
int year,mon=-1,day,hour,min,sec,ms;
char strmon[4];
int done = sscanf(str,"%04d-%3s-%02d %02d:%02d:%02d:%03d",&year,strmon,&day,&hour,&min,&sec,&ms);
if(done != 7) return false;
for(int i=1;i<12;i++)
if(!strncasecmp(monthnames[i],strmon,3))
{
mon=i;
break;
}
if(mon==-1) return false;
out = DateTime(year,mon,day,hour,min,sec);
return true;
}
static DateTime Parse(const char* str)
{
DateTime ret;
TryParse(str,ret);
return ret;
}
};
#endif //_DATETIME_H_

252
desmume/src/utils/mkgmtime.cpp
View File

@ -1,252 +0,0 @@
/* utils/mkgmtime.cpp
Copyright (C) 2010 DeSmuME team
This file is part of DeSmuME
DeSmuME is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
DeSmuME is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
//Taken from newlib 1.18.0 which is licensed under GPL 2 and modified for desmume
/*
* mktime.c
* Original Author: G. Haley
*
* Converts the broken-down time, expressed as local time, in the structure
* pointed to by tim_p into a calendar time value. The original values of the
* tm_wday and tm_yday fields of the structure are ignored, and the original
* values of the other fields have no restrictions. On successful completion
* the fields of the structure are set to represent the specified calendar
* time. Returns the specified calendar time. If the calendar time can not be
* represented, returns the value (time_t) -1.
*
* Modifications: Fixed tm_isdst usage - 27 August 2008 Craig Howland.
*/
#include <stdlib.h>
#include <time.h>
#include "mkgmtime.h"
#define _SEC_IN_MINUTE 60L
#define _SEC_IN_HOUR 3600L
#define _SEC_IN_DAY 86400L
static const int DAYS_IN_MONTH[12] =
{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
#define _DAYS_IN_MONTH(x) ((x == 1) ? days_in_feb : DAYS_IN_MONTH[x])
static const int _DAYS_BEFORE_MONTH[12] =
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
#define _ISLEAP(y) (((y) % 4) == 0 && (((y) % 100) != 0 || (((y)+1900) % 400) == 0))
#define _DAYS_IN_YEAR(year) (_ISLEAP(year) ? 366 : 365)
static void validate_structure(tm *tim_p)
{
div_t res;
int days_in_feb = 28;
/* calculate time & date to account for out of range values */
if (tim_p->tm_sec < 0 || tim_p->tm_sec > 59)
{
res = div (tim_p->tm_sec, 60);
tim_p->tm_min += res.quot;
if ((tim_p->tm_sec = res.rem) < 0)
{
tim_p->tm_sec += 60;
--tim_p->tm_min;
}
}
if (tim_p->tm_min < 0 || tim_p->tm_min > 59)
{
res = div (tim_p->tm_min, 60);
tim_p->tm_hour += res.quot;
if ((tim_p->tm_min = res.rem) < 0)
{
tim_p->tm_min += 60;
--tim_p->tm_hour;
}
}
if (tim_p->tm_hour < 0 || tim_p->tm_hour > 23)
{
res = div (tim_p->tm_hour, 24);
tim_p->tm_mday += res.quot;
if ((tim_p->tm_hour = res.rem) < 0)
{
tim_p->tm_hour += 24;
--tim_p->tm_mday;
}
}
if (tim_p->tm_mon > 11)
{
res = div (tim_p->tm_mon, 12);
tim_p->tm_year += res.quot;
if ((tim_p->tm_mon = res.rem) < 0)
{
tim_p->tm_mon += 12;
--tim_p->tm_year;
}
}
if (_DAYS_IN_YEAR (tim_p->tm_year) == 366)
days_in_feb = 29;
if (tim_p->tm_mday <= 0)
{
while (tim_p->tm_mday <= 0)
{
if (--tim_p->tm_mon == -1)
{
tim_p->tm_year--;
tim_p->tm_mon = 11;
days_in_feb =
((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
29 : 28);
}
tim_p->tm_mday += _DAYS_IN_MONTH (tim_p->tm_mon);
}
}
else
{
while (tim_p->tm_mday > _DAYS_IN_MONTH (tim_p->tm_mon))
{
tim_p->tm_mday -= _DAYS_IN_MONTH (tim_p->tm_mon);
if (++tim_p->tm_mon == 12)
{
tim_p->tm_year++;
tim_p->tm_mon = 0;
days_in_feb =
((_DAYS_IN_YEAR (tim_p->tm_year) == 366) ?
29 : 28);
}
}
}
}
time_t mkgmtime(tm *tim_p)
{
time_t tim = 0;
long days = 0;
int year, isdst, tm_isdst;
/* validate structure */
validate_structure (tim_p);
/* compute hours, minutes, seconds */
tim += tim_p->tm_sec + (tim_p->tm_min * _SEC_IN_MINUTE) +
(tim_p->tm_hour * _SEC_IN_HOUR);
/* compute days in year */
days += tim_p->tm_mday - 1;
days += _DAYS_BEFORE_MONTH[tim_p->tm_mon];
if (tim_p->tm_mon > 1 && _DAYS_IN_YEAR (tim_p->tm_year) == 366)
days++;
/* compute day of the year */
tim_p->tm_yday = days;
if (tim_p->tm_year > 10000
|| tim_p->tm_year < -10000)
{
return (time_t) -1;
}
/* compute days in other years */
if (tim_p->tm_year > 70)
{
for (year = 70; year < tim_p->tm_year; year++)
days += _DAYS_IN_YEAR (year);
}
else if (tim_p->tm_year < 70)
{
for (year = 69; year > tim_p->tm_year; year--)
days -= _DAYS_IN_YEAR (year);
days -= _DAYS_IN_YEAR (year);
}
/* compute day of the week */
if ((tim_p->tm_wday = (days + 4) % 7) < 0)
tim_p->tm_wday += 7;
/* compute total seconds */
tim += (days * _SEC_IN_DAY);
/* Convert user positive into 1 */
tm_isdst = tim_p->tm_isdst > 0 ? 1 : tim_p->tm_isdst;
isdst = tm_isdst;
//screw this!
// if (_daylight)
// {
// int y = tim_p->tm_year + YEAR_BASE;
// if (y == tz->__tzyear || __tzcalc_limits (y))
//{
// /* calculate start of dst in dst local time and
// start of std in both std local time and dst local time */
// time_t startdst_dst = tz->__tzrule[0].change
// - (time_t) tz->__tzrule[1].offset;
// time_t startstd_dst = tz->__tzrule[1].change
// - (time_t) tz->__tzrule[1].offset;
// time_t startstd_std = tz->__tzrule[1].change
// - (time_t) tz->__tzrule[0].offset;
// /* if the time is in the overlap between dst and std local times */
// if (tim >= startstd_std && tim < startstd_dst)
// ; /* we let user decide or leave as -1 */
// else
// {
// isdst = (tz->__tznorth
// ? (tim >= startdst_dst && tim < startstd_std)
// : (tim >= startdst_dst || tim < startstd_std));
// /* if user committed and was wrong, perform correction, but not
// * if the user has given a negative value (which
// * asks mktime() to determine if DST is in effect or not) */
// if (tm_isdst >= 0 && (isdst ^ tm_isdst) == 1)
// {
// /* we either subtract or add the difference between
// time zone offsets, depending on which way the user got it
// wrong. The diff is typically one hour, or 3600 seconds,
// and should fit in a 16-bit int, even though offset
// is a long to accomodate 12 hours. */
// int diff = (int) (tz->__tzrule[0].offset
// - tz->__tzrule[1].offset);
// if (!isdst)
// diff = -diff;
// tim_p->tm_sec += diff;
// validate_structure (tim_p);
// tim += diff; /* we also need to correct our current time calculation */
// }
// }
//}
// }
//screw this also
/* add appropriate offset to put time in gmt format */
//if (isdst == 1)
// tim += (time_t) tz->__tzrule[1].offset;
//else /* otherwise assume std time */
// tim += (time_t) tz->__tzrule[0].offset;
//and screw this too
/* reset isdst flag to what we have calculated */
tim_p->tm_isdst = isdst;
return tim;
}

28
desmume/src/utils/mkgmtime.h
View File

@ -1,28 +0,0 @@
/* utils/mkgmtime.h
Copyright (C) 2010 DeSmuME team
This file is part of DeSmuME
DeSmuME is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
DeSmuME is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _MKGMTIME_H_
#define _MKGMTIME_H_
#include <time.h>
time_t mkgmtime(tm *tim_p);
#endif //_MKGMTIME_H_

8
desmume/src/windows/DeSmuME_2005.vcproj
View File

@ -1359,6 +1359,14 @@
RelativePath="..\utils\ConvertUTF.h" RelativePath="..\utils\ConvertUTF.h"
> >
</File> </File>
<File
RelativePath="..\utils\datetime.cpp"
>
</File>
<File
RelativePath="..\utils\datetime.h"
>
</File>
<File <File
RelativePath="..\utils\dlditool.cpp" RelativePath="..\utils\dlditool.cpp"
> >

16
desmume/src/windows/DeSmuME_2008.vcproj
View File

@ -1058,6 +1058,14 @@
RelativePath="..\utils\ConvertUTF.h" RelativePath="..\utils\ConvertUTF.h"
> >
</File> </File>
<File
RelativePath="..\utils\datetime.cpp"
>
</File>
<File
RelativePath="..\utils\datetime.h"
>
</File>
<File <File
RelativePath="..\utils\dlditool.cpp" RelativePath="..\utils\dlditool.cpp"
> >
@ -1078,14 +1086,6 @@
RelativePath="..\utils\md5.h" RelativePath="..\utils\md5.h"
> >
</File> </File>
<File
RelativePath="..\utils\mkgmtime.cpp"
>
</File>
<File
RelativePath="..\utils\mkgmtime.h"
>
</File>
<File <File
RelativePath="..\utils\task.cpp" RelativePath="..\utils\task.cpp"
> >

4
desmume/src/windows/DeSmuME_2010.vcxproj
View File

@ -470,8 +470,8 @@
<ClCompile Include="..\SPU.cpp" /> <ClCompile Include="..\SPU.cpp" />
<ClCompile Include="..\texcache.cpp" /> <ClCompile Include="..\texcache.cpp" />
<ClCompile Include="..\thumb_instructions.cpp" /> <ClCompile Include="..\thumb_instructions.cpp" />
<ClCompile Include="..\utils\datetime.cpp" />
<ClCompile Include="..\utils\dlditool.cpp" /> <ClCompile Include="..\utils\dlditool.cpp" />
<ClCompile Include="..\utils\mkgmtime.cpp" />
<ClCompile Include="..\version.cpp" /> <ClCompile Include="..\version.cpp" />
<ClCompile Include="..\wifi.cpp" /> <ClCompile Include="..\wifi.cpp" />
<ClCompile Include="..\addons\compactFlash.cpp" /> <ClCompile Include="..\addons\compactFlash.cpp" />
@ -594,7 +594,7 @@
<ClInclude Include="..\texcache.h" /> <ClInclude Include="..\texcache.h" />
<ClInclude Include="..\thumb_instructions.h" /> <ClInclude Include="..\thumb_instructions.h" />
<ClInclude Include="..\types.h" /> <ClInclude Include="..\types.h" />
<ClInclude Include="..\utils\mkgmtime.h" /> <ClInclude Include="..\utils\datetime.h" />
<ClInclude Include="..\version.h" /> <ClInclude Include="..\version.h" />
<ClInclude Include="..\wifi.h" /> <ClInclude Include="..\wifi.h" />
<ClInclude Include="..\utils\xstring.h" /> <ClInclude Include="..\utils\xstring.h" />

12
desmume/src/windows/DeSmuME_2010.vcxproj.filters
View File

@ -378,9 +378,6 @@
<ClCompile Include="tileView.cpp"> <ClCompile Include="tileView.cpp">
<Filter>Windows\tools</Filter> <Filter>Windows\tools</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\utils\mkgmtime.cpp">
<Filter>Core\utils</Filter>
</ClCompile>
<ClCompile Include="..\addons\piano.cpp"> <ClCompile Include="..\addons\piano.cpp">
<Filter>Core\addons</Filter> <Filter>Core\addons</Filter>
</ClCompile> </ClCompile>
@ -399,6 +396,9 @@
<ClCompile Include="..\emufat.cpp"> <ClCompile Include="..\emufat.cpp">
<Filter>Core</Filter> <Filter>Core</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\utils\datetime.cpp">
<Filter>Core\utils</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="..\addons.h"> <ClInclude Include="..\addons.h">
@ -725,9 +725,6 @@
<ClInclude Include="tileView.h"> <ClInclude Include="tileView.h">
<Filter>Windows\tools</Filter> <Filter>Windows\tools</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\utils\mkgmtime.h">
<Filter>Core\utils</Filter>
</ClInclude>
<ClInclude Include="filter\hq2x.h" /> <ClInclude Include="filter\hq2x.h" />
<ClInclude Include="filter\interp.h" /> <ClInclude Include="filter\interp.h" />
<ClInclude Include="filter\lq2x.h" /> <ClInclude Include="filter\lq2x.h" />
@ -735,6 +732,9 @@
<Filter>Core</Filter> <Filter>Core</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\emufat_types.h" /> <ClInclude Include="..\emufat_types.h" />
<ClInclude Include="..\utils\datetime.h">
<Filter>Core\utils</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="..\instruction_tabdef.inc"> <None Include="..\instruction_tabdef.inc">

54
desmume/src/windows/replay.cpp
View File

@ -1,21 +1,17 @@
/* windows/replay.cpp /* Copyright (C) 2008-2010 DeSmuME team
Copyright (C) 2008-2010 DeSmuME team
This file is part of DeSmuME This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
DeSmuME is free software; you can redistribute it and/or modify This file is distributed in the hope that it will be useful,
it under the terms of the GNU General Public License as published by but WITHOUT ANY WARRANTY; without even the implied warranty of
the Free Software Foundation; either version 2 of the License, or MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
(at your option) any later version. GNU General Public License for more details.
DeSmuME is distributed in the hope that it will be useful, You should have received a copy of the GNU General Public License
but WITHOUT ANY WARRANTY; without even the implied warranty of along with the this software. If not, see <http://www.gnu.org/licenses/>.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "types.h" #include "types.h"
@ -32,7 +28,6 @@
#include "movie.h" #include "movie.h"
#include "rtc.h" #include "rtc.h"
#include "utils/xstring.h" #include "utils/xstring.h"
#include "utils/mkgmtime.h"
bool replayreadonly=1; bool replayreadonly=1;
@ -262,17 +257,16 @@ static INT_PTR CALLBACK RecordDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
CheckDlgButton(hwndDlg, IDC_START_FROM_SRAM, ((flag == 1) ? BST_CHECKED : BST_UNCHECKED)); CheckDlgButton(hwndDlg, IDC_START_FROM_SRAM, ((flag == 1) ? BST_CHECKED : BST_UNCHECKED));
SetFocus(GetDlgItem(hwndDlg, IDC_EDIT_FILENAME)); SetFocus(GetDlgItem(hwndDlg, IDC_EDIT_FILENAME));
time_t timer = FCEUI_MovieGetRTCDefault(); DateTime t = FCEUI_MovieGetRTCDefault();
struct tm *t = gmtime(&timer);
ZeroMemory(&systime, sizeof(SYSTEMTIME)); ZeroMemory(&systime, sizeof(SYSTEMTIME));
systime.wYear = t->tm_year + 1900; systime.wYear = t.get_Year();
systime.wMonth = t->tm_mon + 1; systime.wMonth = t.get_Month();
systime.wDay = t->tm_mday; systime.wDay = t.get_Day();
systime.wDayOfWeek = t->tm_wday; systime.wDayOfWeek = t.get_DayOfWeek();
systime.wHour = t->tm_hour; systime.wHour = t.get_Hour();
systime.wMinute = t->tm_min; systime.wMinute = t.get_Minute();
systime.wSecond = t->tm_sec; systime.wSecond = t.get_Second();
systime.wMilliseconds = 0; systime.wMilliseconds = t.get_Millisecond();
DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_DATE), GDT_VALID, &systime); DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_DATE), GDT_VALID, &systime);
DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_TIME), GDT_VALID, &systime); DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_TIME), GDT_VALID, &systime);
@ -304,20 +298,18 @@ static INT_PTR CALLBACK RecordDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
std::string sramfname = GetDlgItemText<MAX_PATH>(hwndDlg,IDC_EDIT_SRAMFILENAME); std::string sramfname = GetDlgItemText<MAX_PATH>(hwndDlg,IDC_EDIT_SRAMFILENAME);
if (fname.length()) if (fname.length())
{ {
time_t rtcstart;
struct tm t; struct tm t;
DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_DATE), &systime); DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_DATE), &systime);
t.tm_year = systime.wYear - 1900; t.tm_year = systime.wYear;
t.tm_mon = systime.wMonth - 1; t.tm_mon = systime.wMonth;
t.tm_mday = systime.wDay; t.tm_mday = systime.wDay;
t.tm_wday = systime.wDayOfWeek; t.tm_wday = systime.wDayOfWeek;
DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_TIME), &systime); DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DTP_TIME), &systime);
t.tm_hour = systime.wHour; t.tm_hour = systime.wHour;
t.tm_min = systime.wMinute; t.tm_min = systime.wMinute;
t.tm_sec = systime.wSecond; t.tm_sec = systime.wSecond;
t.tm_isdst= -1; DateTime rtcstart(t.tm_year,t.tm_mon,t.tm_mday,t.tm_hour,t.tm_min,t.tm_sec);
rtcstart = mkgmtime(&t);
FCEUI_SaveMovie(fname.c_str(), author, flag, sramfname, rtcstart); FCEUI_SaveMovie(fname.c_str(), author, flag, sramfname, rtcstart);
EndDialog(hwndDlg, 0); EndDialog(hwndDlg, 0);