int main(void)
{
uint8_t lcd_show = 1, was_in_menu=0;
InitAll();
FirstRun();
while(1)
{
switch(state)
{
case 0: //simple kb checking
my_btn = get_btn();
ProcessMenu(my_btn->button, my_btn->duration);
if(is_in_menu()) was_in_menu=1;
if(!is_in_menu() && was_in_menu){
state=1;
was_in_menu=0;
}
search_for_cmd();
break;
case 1:
check_state();
state=0;
break;
case 2:
break;
}
}
}
int main(void)
{
// int i;
/* GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(LED_GPIO, &GPIO_InitStructure);
GPIO_SetBits(GPIOD,GPIO_Pin_5);
GPIO_ResetBits(GPIOD,GPIO_Pin_5);
*/InitAll();
socket(0, Sn_MR_TCP, Config_Msg.port_science, 0);
while(1)
{
motor_tcps(0, Config_Msg.port_science);
}
}
int main(int argc, char *argv[])
{
bool running = 1;
if(InitAll())
{
return -1;
}
Graphics::AddObject(new GraphicsObject("pacman.jpg", 0, 0));
while(running)
{
if(KeyboardHandler::isPressed(SDLK_ESCAPE))
{
running = 0;
}
Graphics::Update();
}
DeinitAll();
return 0;
}
wxArchive::wxArchive(wxOutputStream &stream, size_t version, const wxString &header, bool partialMode)
: m_writeMode(true)
, m_odstr(stream)
, m_partialMode(partialMode)
, m_itmp(m_tmpistr)
, m_idstr(m_itmp)
, m_otmp(&m_tmpostr)
, m_version(version)
, m_headerStr(header)
{
InitAll();
// all ok, use this stream
if(stream.IsOk())
{
m_opened = true;
m_errorCode = wxARCHIVE_ERR_OK;
// write information
SaveString(header);
SaveUint32(version);
m_status = wxArchiveStatus(version, header);
// when we are ok, start saving
if(!IsOk())
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_NOVERHDR);
}
else
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_BADOSTREAM);
}
void Init(void)
{
// GL Inits
glClearColor(backgroundColor.x, backgroundColor.y, backgroundColor.z, backgroundColor.w);
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
printError("GL Inits");
InitAll();
}
int main( void )
{
InitAll();
curGS = CreateGameState();
BuildResources (curGS->res);
LoadUnlockProfile(curGS);
BuildMainMenu(curGS);
RunGameState(curGS);
FreeGameState(curGS);
return 0;
}
int main(void)
{
InitAll();
while(1)
{
GPIOA->BSRR =GPIO_BSRR_BS3;
GPIOA->BSRR =GPIO_BSRR_BR3;
}
}
/**
*@brief Initialize all the Lists,Screens, etc
*/
void Init()
{
game = (Game*)malloc(sizeof(Game));
memset(game,0,sizeof(Game));
mainEvent = new SDL_Event();
InitAll();
SetUpTitle();
game->camera = (SDL_Rect*)malloc(sizeof(SDL_Rect));
memset(game->camera,0,sizeof(SDL_Rect));
game->camera->x = 0;
game->camera->y = 0;
game->gameState = StateTitle;
game->font = TTF_OpenFont("Tahoma.ttf",20);
}
//------------------------------------------------------------ WacomInit()
//
pthread_t WacomInit(void (*WacomCallback)(int)) {
if ( !InitAll() ) {
perror("Init Wacom Engine");
WacomCloseTablet(ghTablet);
WacomTermEngine(ghEngine);
exit(0);
}
if (WacomCallback)
gCallback = WacomCallback;
if ( pthread_create(&g_thread_id,NULL,WacomThread,NULL) ) {
perror("Setting wacom scanning mode failed");
WacomCloseTablet(ghTablet);
WacomTermEngine(ghEngine);
exit(0);
}
return g_thread_id;
}
void analyze( Char_t *szFin,
Int_t first=2,
Int_t lastt=0)
{
ReadFile(szFin);
InitAll();
SetThreshold( 3000, 3000 ); // set the thresholds
event_first = first;
event_lastt=h2D[0]->GetNbinsY()-1;
if( lastt>1 && lastt<event_lastt )
event_lastt = lastt;
event = event_first;
ftimer.Start();
return;
}
//==============================================================================
int main(void)
{
pinMode(led, OUTPUT);
InitAll(); // Инициализируем периферию
InitRTOS(); // Инициализируем ядро
RunRTOS(); // Старт ядра.
// Запуск фоновых задач.
SetTask(Task1);
while(1) // Главный цикл диспетчера
{
wdt_reset(); // Сброс собачьего таймера
TaskManager(); // Вызов диспетчера
}
return 0;
}
int main(int argc, char *argv[])
{
#if HAVE_SETBUF
setbuf(stdin, NULL);
#endif
OpenLogFile("Amy.log");
InitMoves();
InitAll();
HashInit();
/*
* Process rc file first, then command line options. This way command
* line options can override rc file settings.
*/
ProcessRCFile();
ProcessOptions(argc, argv);
ShowVersion();
AllocateHT();
InitEGTB(EGTBPath);
RecogInit();
DoBookLearning();
Print(0, "\n");
strcpy(AutoSaveFileName, GetTmpFileName());
/* Ensure true random behavior. */
InitRandom(GetTime());
StateMachine();
return 0;
}
//==============================================================================
int main(void)
{
InitAll(); // Инициализируем периферию
/*for (short i = 0 ; i < 10 ; i++)
{
PM_OnPin(LED_RED);//зажигаем светодиод //LED_PORT ^=1<<LED1;
_delay_ms(100);
PM_OffPin(LED_RED);//зажигаем светодиод //LED_PORT ^=1<<LED1;
_delay_ms(400);
}*/
pressedTime = 0;
InitRTOS(); // Инициализируем ядро
RunRTOS(); // Старт ядра.
SetTask(TaskScanButtons);
wdt_enable(WDTO_1S);
while(1) // Главный цикл диспетчера
{
wdt_reset(); // Сброс собачьего таймера
TaskManager(); // Вызов диспетчера
}
return 0;
}
int main(void)
{
InitAll();
InitRelayPins();
BSP_LED_On(LED_GREEN);
BSP_LED_On(LED_BLUE);
BSP_LCD_GLASS_DisplayString((uint8_t*)"READY");
// RIGHT: 00 - 27 min: blue led on, relay 1 on
// RIGHT_OVERLAP: 28 - 29 min: same + green flashing
// LEFT: 30 - 57 min: green led on, relay 2 on
// LEFT_OVERLAP: 58 - 59 min: same + blue flashing
// BOTH_OFF: both relays off, both LEDs off, counters not active
// BOTH_ON: both relays on, both LEDs on, counters not active
// USER press: BOTH_OFF
// left button: jump to state LEFT
// right button: jump to state RIGHT
// left + right button: jump to state BOTH_ON
const int TIME_OVERLAP = 2 * 60;
const int TIME_RIGHT = 30 * 60 - TIME_OVERLAP;
const int TIME_LEFT = 15 * 60 - TIME_OVERLAP;
while (1)
{
switch(state) {
case RESET_STATE:
green_off();
blue_off();
relay_1_off();
relay_2_off();
relay_3_off();
relay_4_off();
set_sec(0);
state = RIGHT;
break;
case RIGHT:
if (prev_state != RIGHT) {
prev_state = RIGHT;
blue_on();
green_off();
relay_1_off();
relay_2_on();
set_sec(TIME_RIGHT);
}
if (!sec) {
state = RIGHT_OVERLAP;
}
break;
case RIGHT_OVERLAP:
if (prev_state != RIGHT_OVERLAP) {
prev_state = RIGHT_OVERLAP;
blue_on();
relay_1_on();
relay_2_on();
set_sec(TIME_OVERLAP);
}
if (sec & 1) {
green_on();
}
else {
green_off();
}
if (!sec) {
state = LEFT;
}
break;
case LEFT:
if (prev_state != LEFT) {
prev_state = LEFT;
green_on();
blue_off();
relay_1_on();
relay_2_off();
set_sec(TIME_LEFT);
}
if (!sec) {
state = LEFT_OVERLAP;
}
break;
case LEFT_OVERLAP:
if (prev_state != LEFT_OVERLAP) {
prev_state = LEFT_OVERLAP;
green_on();
relay_1_on();
relay_2_on();
set_sec(TIME_OVERLAP);
}
if (sec & 1) {
blue_on();
}
else {
blue_off();
}
if (!sec) {
state = RIGHT;
}
break;
case BOTH_OFF:
if (prev_state != BOTH_OFF) {
green_off();
blue_off();
relay_1_off();
relay_2_off();
set_sec(0);
}
break;
case BOTH_ON:
if (prev_state != BOTH_ON) {
green_on();
blue_on();
relay_1_on();
relay_2_on();
set_sec(0);
}
break;
}
// Read touch buttons
int buttonId = getTouchButtons();
// LEFT button
if (buttonId == 0) {
prev_state = RESET_STATE;
state = LEFT;
}
// RIGHT button
if (buttonId == 3) {
prev_state = RESET_STATE;
state = RIGHT;
}
}
// Will never get here.
return 0;
}
void CGraphics::CreateControl(DWORD style, int x, int y, int width, int height) {
CStaticCtrl::CreateControl(style, x, y, width, height);
InitAll();
}
void main(void)
{
#else
int g_start_gl = 1;
int main(int argc, const char** argv)
{
if ((argc > 1) && (argv[1][0] == 'h'))
g_start_gl = 0;
#endif
/* softReset() on x86 will jump here! */
softResetJumpDestination();
InitAll();
while(1)
{
Timer_StartStopwatch(eMAIN);
#ifndef __CC8E__
// give opengl thread a chance to run
usleep(10);
#endif /* #ifndef __CC8E__ */
do_and_measure(Platform_CheckInputs);
do_and_measure(Error_Throw);
do_and_measure(CommandIO_GetCommands);
if(g_UpdateLedStrip > 0) {
do_and_measure(Ledstrip_UpdateLed);
Timer1Enable();
g_UpdateLedStrip = 0;
}
Timer_StopStopwatch(eMAIN);
do_and_measure(ScriptCtrl_Run);
if(g_UpdateLed > 0) {
do_and_measure(Ledstrip_DoFade);
Timer5InterruptLock();
g_UpdateLed = 0;
Timer5InterruptUnlock();
}
}
}
//*********************** UNTERPROGRAMME **********************************************
void InitAll()
{
clearRAM();
Trace_Init();
Platform_OsciInit();
Platform_IOInit();
RingBuf_Init(&g_RingBuf);
UART_Init();
Timer_Init();
Ledstrip_Init();
CommandIO_Init();
Rtc_Init();
ScriptCtrl_Init();
ExtEeprom_Init();
#ifndef __CC8E__
init_x86(g_start_gl);
#endif /* #ifndef CC8E */
Platform_AllowInterrupts();
/* Startup Wait-Time 2s
* to protect Wifly-Modul from errors*/
gScriptBuf.waitValue = 20;
CommandIO_CreateResponse(&g_ResponseBuf, FW_STARTED, OK);
CommandIO_SendResponse(&g_ResponseBuf);
Trace_String(" Init Done ");
Platform_DisableBootloaderAutostart();
}
VOID CSmartReader::CloseAll()
{
InitAll();
}
CSmartReader::CSmartReader()
{
InitAll();
FillAttribGenericDetails();
}
wxArchive::wxArchive(wxInputStream &stream, size_t version, const wxString &header, bool partialMode)
: m_writeMode(false)
, m_idstr(stream)
, m_partialMode(partialMode)
, m_otmp(&m_tmpostr)
, m_odstr(m_otmp)
, m_itmp(m_tmpistr)
{
InitAll();
// all ok, use this stream
if(stream.IsOk())
{
// now we need to reset the code for
// reading to work
m_errorCode = wxARCHIVE_ERR_OK;
m_opened = true;
// load header
wxString hdr = LoadString();
if(IsOk())
{
// when we have a header to check else ignore and store
// for future reference (and writing back maybe?)
if(header.IsEmpty() || header.IsSameAs(hdr))
{
// store header for consulting later
m_headerStr = header;
// check the version number
size_t ver = LoadUint32();
if(IsOk())
{
// if version is 0, we accept any version if higher, we
// need to see if this stream does not exceed the expected version
if(!version || ver <=version)
{
// this is the point where all is
// approved. We can start reading
m_version = ver;
m_status = wxArchiveStatus(m_version, m_headerStr);
}
else
{
wxString v1, v2;
v1 << version;
v2 << ver;
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_WRONGVERSION_s1_s2, v1, v2);
}
}
else
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_NOVERSION);
}
else
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_HEADER_s1_s2, header, hdr);
}
else
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_NOHEADER_s1, header);
}
else
LogError(wxARCHIVE_ERR_ILL, wxARCHIVE_ERR_STR_BADISTREAM);
}
/*------------------------------------------------------------------------------*/
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPreInst, LPSTR lpszCmdLine, int nCmdShow )
{
HWND hWnd;
WCHAR ClsName[] = L"RemoteJoyLiteWindow";
if ( hPreInst == NULL ){
WNDCLASS WndCls;
WndCls.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
WndCls.lpfnWndProc = WndProc;
WndCls.cbClsExtra = 0;
WndCls.cbWndExtra = 0;
WndCls.hInstance = hInstance;
WndCls.hIcon = LoadIcon( hInstance, L"REMOTEJOYLITE_ICON" );
WndCls.hCursor = LoadCursor( NULL, IDC_ARROW );
WndCls.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
WndCls.lpszMenuName = NULL;
WndCls.lpszClassName = ClsName;
if ( RegisterClass(&WndCls) == FALSE ){ return( FALSE ); }
}
SettingLoad();
MacroLoad();
if ( SettingData.DispRot & 1 ){
SCREEN_W = 272;
SCREEN_H = 480;
} else {
SCREEN_W = 480;
SCREEN_H = 272;
}
RECT rect = { 0, 0, SCREEN_W, SCREEN_H };
AdjustWindowRect( &rect, WS_OVERLAPPEDWINDOW, FALSE );
hWnd = CreateWindow( ClsName,
L"RemoteJoyLite Ver0.19",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
rect.right - rect.left,
rect.bottom - rect.top,
NULL,
NULL,
hInstance,
NULL );
hWndMain = hWnd;
pAkindDI = std::unique_ptr<AkindDI>(new AkindDI());
pAkindD3D = std::unique_ptr<AkindD3D>(new AkindD3D(hWnd));
pAkindD3D->addCreateEventHandler(RemoteJoyLiteInit);
pAkindD3D->addReleaseEventHandler(RemoteJoyLiteExit);
pAkindD3D->addCreateEventHandler(DebugFontInit);
pAkindD3D->addReleaseEventHandler(DebugFontExit);
pAkindD3D->addReleaseEventHandler(ImageFilterLanczos4::release);
pAkindD3D->addReleaseEventHandler(ImageFilterSpline36::release);
if ( InitAll( hWnd, hInstance ) == FALSE ){
ExitAll();
return( FALSE );
}
CreateDirectory( L".\\Capture", NULL );
CreateDirectory( L".\\Macro", NULL );
UpdateWindow( hWnd );
InitWindowSize( hWnd );
MSG msg;
while ( LoopFlag != FALSE ){
MainSync( hWnd );
while ( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) ){
GetMessage( &msg, NULL, 0, 0 );
if ( SettingMessage( &msg, FullScreen, *pAkindD3D ) != FALSE ){ continue; }
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
ExitAll();
return( msg.wParam );
}
//------------------------------------------------------------ WacomInit()
//
void WacomInit(int samplerate) {
if ( !InitAll() )
exit(0);
if ( pthread_create(&g_thread_id,NULL,WacomThread,samplerate) )
exit(0);
}
int main(int argc, char **argv)
{
char str[256];
int16 i16;
HANDLE rom_fh;
const char *rom_path;
uint32 rom_size;
DWORD actual;
uint8 *rom_tmp;
// Initialize variables
RAMBase = 0;
// Print some info
printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR);
printf(" %s\n", GetString(STR_ABOUT_TEXT2));
// Read preferences
PrefsInit(NULL, argc, argv);
// Parse command line arguments
for (int i=1; i<argc; i++) {
if (strcmp(argv[i], "--help") == 0) {
usage(argv[0]);
} else if (argv[i][0] == '-') {
fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
usage(argv[0]);
}
}
// Check we are using a Windows NT kernel >= 4.0
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&osvi)) {
ErrorAlert("Could not determine OS type");
QuitEmulator();
}
win_os = osvi.dwPlatformId;
win_os_major = osvi.dwMajorVersion;
if (win_os != VER_PLATFORM_WIN32_NT || win_os_major < 4) {
ErrorAlert(GetString(STR_NO_WIN32_NT_4));
QuitEmulator();
}
// Check that drivers are installed
if (!check_drivers())
QuitEmulator();
// Load win32 libraries
KernelInit();
// FIXME: default to DIB driver
if (getenv("SDL_VIDEODRIVER") == NULL)
putenv("SDL_VIDEODRIVER=windib");
// Initialize SDL system
int sdl_flags = 0;
#ifdef USE_SDL_VIDEO
sdl_flags |= SDL_INIT_VIDEO;
#endif
#ifdef USE_SDL_AUDIO
sdl_flags |= SDL_INIT_AUDIO;
#endif
assert(sdl_flags != 0);
if (SDL_Init(sdl_flags) == -1) {
char str[256];
sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError());
ErrorAlert(str);
goto quit;
}
atexit(SDL_Quit);
#ifdef ENABLE_MON
// Initialize mon
mon_init();
#endif
// Install SIGSEGV handler for CPU emulator
if (!sigsegv_install_handler(sigsegv_handler)) {
sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
// Initialize VM system
vm_init();
// Get system info
PVR = 0x00040000; // Default: 604
CPUClockSpeed = 100000000; // Default: 100MHz
BusClockSpeed = 100000000; // Default: 100MHz
TimebaseSpeed = 25000000; // Default: 25MHz
PVR = 0x000c0000; // Default: 7400 (with AltiVec)
D(bug("PVR: %08x (assumed)\n", PVR));
// Init system routines
SysInit();
// Show preferences editor
if (!PrefsFindBool("nogui"))
if (!PrefsEditor())
goto quit;
// Create areas for Kernel Data
if (!kernel_data_init())
goto quit;
kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE);
emulator_data = &kernel_data->ed;
KernelDataAddr = KERNEL_DATA_BASE;
D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE));
D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed)));
// Create area for DR Cache
if (vm_mac_acquire(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) {
sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
dr_emulator_area_mapped = true;
if (vm_mac_acquire(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) {
sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
dr_cache_area_mapped = true;
DRCacheAddr = (uint32)Mac2HostAddr(DR_CACHE_BASE);
D(bug("DR Cache at %p (%08x)\n", DRCacheAddr, DR_CACHE_BASE));
// Create area for SheepShaver data
if (!SheepMem::Init()) {
sprintf(str, GetString(STR_SHEEP_MEM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
// Create area for Mac ROM
if (vm_mac_acquire(ROM_BASE, ROM_AREA_SIZE) < 0) {
sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
ROMBase = ROM_BASE;
ROMBaseHost = Mac2HostAddr(ROMBase);
rom_area_mapped = true;
D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase));
// Create area for Mac RAM
RAMSize = PrefsFindInt32("ramsize");
if (RAMSize < 8*1024*1024) {
WarningAlert(GetString(STR_SMALL_RAM_WARN));
RAMSize = 8*1024*1024;
}
RAMBase = 0;
if (vm_mac_acquire(RAMBase, RAMSize) < 0) {
sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno));
ErrorAlert(str);
goto quit;
}
RAMBaseHost = Mac2HostAddr(RAMBase);
ram_area_mapped = true;
D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase));
if (RAMBase > ROMBase) {
ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR));
goto quit;
}
// Load Mac ROM
rom_path = PrefsFindString("rom");
rom_fh = CreateFile(rom_path && *rom_path ? rom_path : ROM_FILE_NAME,
GENERIC_READ, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (rom_fh == INVALID_HANDLE_VALUE) {
rom_fh = CreateFile(ROM_FILE_NAME2,
GENERIC_READ, 0, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (rom_fh == INVALID_HANDLE_VALUE) {
ErrorAlert(GetString(STR_NO_ROM_FILE_ERR));
goto quit;
}
}
printf(GetString(STR_READING_ROM_FILE));
rom_size = GetFileSize(rom_fh, NULL);
rom_tmp = new uint8[ROM_SIZE];
ReadFile(rom_fh, (void *)rom_tmp, ROM_SIZE, &actual, NULL);
CloseHandle(rom_fh);
// Decode Mac ROM
if (!DecodeROM(rom_tmp, actual)) {
if (rom_size != 4*1024*1024) {
ErrorAlert(GetString(STR_ROM_SIZE_ERR));
goto quit;
} else {
ErrorAlert(GetString(STR_ROM_FILE_READ_ERR));
goto quit;
}
}
delete[] rom_tmp;
// Initialize native timers
timer_init();
// Initialize everything
if (!InitAll(NULL))
goto quit;
D(bug("Initialization complete\n"));
// Write protect ROM
vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ);
// Start 60Hz thread
tick_thread_cancel = false;
tick_thread_active = ((tick_thread = create_thread(tick_func)) != NULL);
SetThreadPriority(tick_thread, THREAD_PRIORITY_ABOVE_NORMAL);
D(bug("Tick thread installed (%ld)\n", tick_thread));
// Start NVRAM watchdog thread
memcpy(last_xpram, XPRAM, XPRAM_SIZE);
nvram_thread_cancel = false;
nvram_thread_active = ((nvram_thread = create_thread(nvram_func, NULL)) != NULL);
SetThreadPriority(nvram_thread, THREAD_PRIORITY_BELOW_NORMAL);
D(bug("NVRAM thread installed (%ld)\n", nvram_thread));
// Get my thread ID and jump to ROM boot routine
emul_thread = GetCurrentThread();
D(bug("Jumping to ROM\n"));
#ifdef _MSC_VER
__try {
#endif
jump_to_rom(ROMBase + 0x310000);
#ifdef _MSC_VER
} __except (main_exception_filter(GetExceptionInformation())) {}
#endif
D(bug("Returned from ROM\n"));
quit:
Quit();
return 0;
}
bool Profile::LoadAllFromDir( CString sDir, bool bRequireSignature )
{
CHECKPOINT;
LOG->Trace( "Profile::LoadAllFromDir( %s )", sDir.c_str() );
InitAll();
LoadEditableDataFromDir( sDir );
// Read stats.xml
FOR_ONCE
{
CString fn = sDir + STATS_XML;
if( !IsAFile(fn) )
break;
//
// Don't unreasonably large stats.xml files.
//
if( !IsMachine() ) // only check stats coming from the player
{
int iBytes = FILEMAN->GetFileSizeInBytes( fn );
if( iBytes > MAX_PLAYER_STATS_XML_SIZE_BYTES )
{
LOG->Warn( "The file '%s' is unreasonably large. It won't be loaded.", fn.c_str() );
break;
}
}
if( bRequireSignature )
{
CString sStatsXmlSigFile = fn+SIGNATURE_APPEND;
CString sDontShareFile = sDir + DONT_SHARE_SIG;
LOG->Trace( "Verifying don't share signature" );
// verify the stats.xml signature with the "don't share" file
if( !CryptManager::VerifyFileWithFile(sStatsXmlSigFile, sDontShareFile) )
{
LOG->Warn( "The don't share check for '%s' failed. Data will be ignored.", sStatsXmlSigFile.c_str() );
break;
}
LOG->Trace( "Done." );
// verify stats.xml
LOG->Trace( "Verifying stats.xml signature" );
if( !CryptManager::VerifyFileWithFile(fn, sStatsXmlSigFile) )
{
LOG->Warn( "The signature check for '%s' failed. Data will be ignored.", fn.c_str() );
break;
}
LOG->Trace( "Done." );
}
LOG->Trace( "Loading %s", fn.c_str() );
XNode xml;
if( !xml.LoadFromFile( fn ) )
{
LOG->Warn( "Couldn't open file '%s' for reading.", fn.c_str() );
break;
}
LOG->Trace( "Done." );
/* The placeholder stats.xml file has an <html> tag. Don't load it, but don't
* warn about it. */
if( xml.name == "html" )
break;
if( xml.name != "Stats" )
WARN_AND_BREAK_M( xml.name );
LOAD_NODE( GeneralData );
LOAD_NODE( SongScores );
LOAD_NODE( CourseScores );
LOAD_NODE( CategoryScores );
LOAD_NODE( ScreenshotData );
LOAD_NODE( CalorieData );
LOAD_NODE( RecentSongScores );
LOAD_NODE( RecentCourseScores );
}
return true; // FIXME? Investigate what happens if we always return true.
}
int billstat:: run()
{
int i=0;
TStatClass * pStat;
int iStatClassID=-1;
int iRunMode=0;
int iPageInOutMode=1;
int cGet=0;
int process_id,flow_id;
while((cGet=getopt(g_argc,g_argv,"c:rp"))!=EOF)
{
switch(cGet)
{
case 'c':
iStatClassID = atoi(optarg);
break;
case 'r':
iRunMode=1;
break;
case 'p':
iPageInOutMode=0;
break;
default:
printf("billstat:参数错误\n");
printf("Usg billstat -c ? [-r] [-p]\n");
return -1;
}
}
if (iStatClassID==-1){
printf("billstat:参数错误\n");
printf("Usg billstat -c ? [-r] [-p]\n");
return -1;
}
gpDBLink.connect("stat","group_by","tibs_stat");
gpDBLink_Temp.connect("stat","group_by","tibs_stat");
set_new_handler(my_new_error);
InitAll();
switch ( iStatClassID){
case OID_CALL_EVENT:
pStat = new StatCallEvent();
break;
case OID_SERV:
pStat = new StatServ();
break;
case OID_ACCT_ITEM:
pStat = new StatAcctItem();
break;
case OID_ACCT_BALANCE:
pStat = new StatAcctBalance();
break;
case OID_BALANCE_SOURCE:
pStat = new StatBalanceSource();
break;
case OID_BALANCE_PAYOUT:
pStat = new StatBalancePayout();
break;
case OID_PAYMENT:
pStat = new StatPayment();
break;
case OID_BILL:
pStat = new StatBill();
break;
case OID_OTHER_EVENT:
pStat = new StatOtherEvent();
break;
case OID_DATA_EVENT:
pStat = new StatDataEvent();
break;
case OID_CYCLE_FEE_EVENT:
pStat = new StatCycleFeeEvent();
break;
case OID_VALUE_ADDED_EVENT:
pStat = new StatValueAddedEvent();
break;
case OID_ACCT_ITEM_AGGR:
pStat = new StatAcctItemAggr();
break;
case OID_ERROR:
pStat = new StatError();
break;
case OID_REDO_EVENT:
pStat = new StatRedoEvent();
break;
case OID_AREFUNDLOG:
pStat = new StatARefundLog();
break;
default:
printf("统计类:[%d]不存在!\n",iStatClassID);
return -1;
}
if (iRunMode)
pStat->SetRunMode(iRunMode);
pStat->SetPageInOutMode(iPageInOutMode);
try{
for (;;){
if (pStat->GetRecord()){
pStat->ProcessStat();
i++;
if (i%500==0)
usleep(1000);
if (i%10000==0){
pStat->OutputResult();
pStat->Commit();
}
if (i%50000==0){
pStat->FreeResult();
pStat->Commit();
}
}
else
break;
}
pStat->FreeResult();
pStat->Commit();
delete pStat;
printf("统计程序正常结束!\n");
return 1;
}
catch (TOCIException &oe) {
cout<<"Error occured ... in "<< __FILE__ <<endl;
cout<<oe.GetErrMsg()<<endl;
cout<<oe.getErrSrc()<<endl;
throw oe;
}
catch (TException &e) {
cout<<"Error occured ... in "<< __FILE__ <<endl;
cout<<e.GetErrMsg()<<endl;
throw e;
}
catch (...) {
cout<<"Error occured ... in "<< __FILE__ <<endl;
throw TException("Error occured ... ");
}
}
int main(int argc, char **argv)
{
// Print banner
printf(
"SIDPlayer Version 4.4\n\n"
"Copyright (C) 1996-2004 Christian Bauer\n"
"E-mail: [email protected]\n"
"http://www.uni-mainz.de/~bauec002/\n\n"
"This is free software with ABSOLUTELY NO WARRANTY.\n"
"You are welcome to redistribute it under certain conditions.\n"
"For details, see the file COPYING.\n\n"
);
// Initialize everything
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
fprintf(stderr, "Couldn't initialize SDL (%s)\n", SDL_GetError());
exit(1);
}
atexit(quit);
InitAll(argc, argv);
int32 speed = PrefsFindInt32("speed");
// Parse non-option arguments
const char *file_name = NULL;
int song = 0;
int i;
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "--help") == 0)
usage(argv[0]);
else if (argv[i][0] == '-') {
fprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
usage(argv[0]);
} else {
if (file_name == NULL)
file_name = argv[i]; // First non-option argument is file name
else
song = atoi(argv[i]); // Second non-option argument is song number
}
}
if (file_name == NULL)
usage(argv[0]);
// Load given PSID file
if (!LoadPSIDFile(file_name)) {
fprintf(stderr, "Couldn't load '%s' (not a PSID file?)\n", file_name);
exit(1);
}
// Select song
if (song > 0) {
if (song > number_of_songs)
song = number_of_songs;
SelectSong(song - 1);
}
SIDAdjustSpeed(speed); // SelectSong and LoadPSIDFile() reset this to 100%
// Print file information
printf("Module Name: %s\n", module_name);
printf("Author : %s\n", author_name);
printf("Copyright : %s\n\n", copyright_info);
printf("Playing song %d/%d\n", current_song + 1, number_of_songs);
// Start replay and enter main loop
SDL_PauseAudio(false);
while (true) {
SDL_Event e;
if (SDL_WaitEvent(&e)) {
if (e.type == SDL_QUIT)
break;
}
}
ExitAll();
return 0;
}
