bool Ctrl::SetWndFocus() { GuiLock __; LLOG("SetWndFocus0 " << Upp::Name(this) << ", top: " << top); if(top) { LLOG("SetWndFocus0 DO gdk: " << gdk()); SetWndForeground(); int t0 = msecs(); while(!gtk_window_is_active(gtk()) && msecs() - t0 < 500) // Wait up to 500ms for window to become active - not ideal, but only possibility FetchEvents(true); FocusSync(); } return true; }
/* * intel_wait_for_pipe_off - wait for pipe to turn off * @dev: drm device * @pipe: pipe to wait for * * After disabling a pipe, we can't wait for vblank in the usual way, * spinning on the vblank interrupt status bit, since we won't actually * see an interrupt when the pipe is disabled. * * On Gen4 and above: * wait for the pipe register state bit to turn off * * Otherwise: * wait for the display line value to settle (it usually * ends up stopping at the start of the next frame). * */ void intel_wait_for_pipe_off(struct drm_device *dev, int pipe) { struct drm_i915_private *dev_priv = dev->dev_private; if (INTEL_INFO(dev)->gen >= 4) { int reg = PIPECONF(pipe); /* Wait for the Pipe State to go off */ if (wait_for((I915_READ(reg) & I965_PIPECONF_ACTIVE) == 0, 100)) fprintf(stderr, "pipe_off wait timed out\n"); } else { u32 last_line; int reg = PIPEDSL(pipe); unsigned long timeout = msecs() + 100; /* Wait for the display line to settle */ do { last_line = I915_READ(reg) & DSL_LINEMASK; mdelay(5); } while (((I915_READ(reg) & DSL_LINEMASK) != last_line) && (timeout> msecs())); if ((msecs()> timeout)) fprintf(stderr, "pipe_off wait timed out\n"); } }
void StopService() { service_stopped = true; int start = msecs(); while(msecs(start) < 10000 && !service_exited) Sleep(100); }
void AutosaveTest::successTest() { AutosaveTestDocument doc(Autosave::Success); // Enable and trigger Autosave doc.setAutosaveNeeded(true); // Verify that Autosave does not trigger too early QThread::msleep(msecs(0.9 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 0); // Verify that Autosave does trigger exactly once before too late QThread::msleep(msecs(0.2 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); // Verify that Autosave does not trigger again too early QThread::msleep(msecs(0.9 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); // Verify that Autosave does trigger again once before too late QThread::msleep(msecs(0.2 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 2); }
void Timer::GlobalTick() { map<NetworkID, Timer*>::iterator it; for (it = timers.begin(); it != timers.end();) { Timer* timer = it->second; if (timer->markdelete) { timers.erase(it++); delete timer; continue; } if ((msecs() - timer->ms) > timer->interval) { last_timer = it->first; timer->Call(timer->args); timer->ms = msecs(); } ++it; } }
int Socket::Data::Read(void *buf, int amount) { int res = recv(socket, (char *)buf, amount, 0); #if FAKESLOWLINE if(res > 0) { int end = msecs() + iscale(res, 10000, FAKESLOWLINE) + 10; for(int delta; (delta = end - msecs()) > 0; Sleep(delta)) ; } #endif #ifndef NOFAKEERROR if(fake_error && res > 0) { if((fake_error -= res) <= 0) { fake_error = 0; if(sock) sock->SetSockError(socket, "recv", 1, "fake error"); return -1; } else LLOG("Socket::Data::Read: fake error after " << fake_error); } #endif if(res == 0) is_eof = true; else if(res < 0 && Socket::GetErrorCode() != IS_BLOCKED) SetSockError("recv"); return res; }
bool Console::Wait() { int ms0 = msecs(); for(;;) { if(ms0 != msecs()) { ProcessEvents(); ms0 = msecs(); } if(Flush() == -1) return error_keys.IsEmpty(); Sleep(0); } }
void Console::Wait(int slot) { int ms0 = msecs(); while(processes[slot].process) { if(ms0 != msecs()) { ProcessEvents(); ms0 = msecs(); } if(Flush() == -1) return; Sleep(0); } }
// read data, requested amount, blocks 'timeout' milliseconds // if reqSize == 0 just read all available data, waiting for 'timeout' if != 0 String Serial::Read(size_t reqSize, uint32_t timeout) { char buf[1001]; buf[1000] = 0; String data; size_t n; uint32_t tim = msecs() + timeout; if(reqSize) { n = min(reqSize, (size_t)1000); while(reqSize) { n = read(fd, buf, n); if(!n) { if((uint32_t)msecs() > tim) break; n = min(reqSize, (size_t)1000); continue; } tim = msecs() + timeout; if(n) { reqSize -= n; data.Cat(buf, n); } n = min(reqSize, (size_t)1000); } } else { for(;;) { n = read(fd, buf, 1000); if(!n) { if((uint32_t)msecs() > tim) break; continue; } tim = msecs() + timeout; if(n) data.Cat(buf, n); } } return data; }
// write a single byte bool Serial::Write(char c, uint32_t timeout) { if(!timeout) return write(fd, &c, 1); uint32_t tim = msecs() + timeout; for(;;) { if(write(fd, &c, 1) == 1) return true; if((uint32_t)msecs() > tim) break; } return false; }
void VfkStream::SpeedTest() { for(int i = 0; i < tables.GetCount(); i++) { int begin = msecs(); Data data = GetData(tables[i].name); int get = msecs(); if(data.GetCount() > 0) data[0]; int first = msecs(); for(int r = 1; r < data.GetCount(); r++) data[r]; int nth = msecs(); puts(NFormat("%s: get(%d), first(%d), nth(%2v)", tables[i].name, get - begin, first - get, (nth - first) / max<double>((double)data.GetCount() - 1, 1))); } }
bool UninstallService(String name, String& status) { ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if(!scm) { status = "Cannot open service manager"; return false; } ServiceHandle me = OpenService(scm, name, SC_MANAGER_ALL_ACCESS); if(!me) { status = "Cannot open service."; return false; } SERVICE_STATUS srvstat; if(ControlService(me, SERVICE_CONTROL_STOP, &srvstat)) { int start = msecs(); while(QueryServiceStatus(me, &srvstat) && srvstat.dwCurrentState != SERVICE_STOPPED && msecs(start) < 10000) Sleep(100); } if(!DeleteService(me)) { status = NFormat("Error deleting service: %s", GetLastErrorMessage()); return false; } return true; }
void Console::CheckEndGroup() { for(int g = groups.GetCount(); --g >= 0;) { String gname = groups.GetKey(g); Group& group = groups[g]; if(!IsNull(gname) && group.finished) { int p = processes.GetCount(); while(--p >= 0 && !(!!processes[p].process && processes[p].group == gname)) ; if(p < 0) { if(group.count > 0) { int duration = msecs(group.start_time); String msg = NFormat("%s: %d file(s) built in %s, %d msecs / file, duration = %d msecs", gname, group.count, PrintTime(group.msecs), group.msecs / group.count, duration); if(processes.GetCount() > 1) { int k = 100 * processes.GetCount() / (processes.GetCount() - 1); msg << NFormat(", parallelization %d%%", minmax(k - group.msecs * k / max(group.raw_msecs, 1), 0, 100)); } msg << '\n'; spooled_output.Cat(msg); if(console_lock < 0) { Append(spooled_output); spooled_output = Null; } } groups.Remove(g); } } } }
bool Console::Run(One<AProcess> pick_ process, const char *cmdline, Stream *out, bool quiet, int slot, String key, int blitz_count) { if(!process) { if(verbosebuild) spooled_output << "Error running " << cmdline << "\n"; FlushConsole(); return false; } else if(verbosebuild) spooled_output << cmdline << "\n"; Wait(slot); Slot& pslot = processes[slot]; pslot.process = pick(process); pslot.cmdline = cmdline; pslot.outfile = out; pslot.output = Null; pslot.quiet = quiet; pslot.key = key; pslot.group = current_group; pslot.last_msecs = msecs(); pslot.serial = ++serial; groups.GetAdd(pslot.group).count += blitz_count; if(processes.GetCount() == 1) Wait(slot); return true; }
int Console::AllocSlot() { int ms0 = msecs(); for(;;) { for(int i = 0; i < processes.GetCount(); i++) if(!IsRunning(i)) return i; Flush(); Sleep(0); if(ms0 != msecs()) { ProcessEvents(); ms0 = msecs(); } } }
bool Serial::Read(char &c, uint32_t timeout) { char buf[1]; uint32_t tim = msecs() + timeout; for(;;) { if(!read(fd, buf, 1)) { if((uint32_t)msecs() > tim) return false; continue; } c = buf[0]; return true; } }
String Ctrl::DragGet(const char *fmt) { LLOG("DragGet " << fmt << " " << (Ctrl::dnd_targets.Find(fmt) >= 0)); if(Ctrl::dnd_targets.Find(fmt) < 0) return Null; dnd_data.Clear(); dnd_data_wait = true; dnd_data_fmt = fmt; int t0 = msecs(); gtk_drag_get_data(dnd_widget, dnd_context, GAtom(strcmp(fmt, "image") == 0 ? ~dnd_image_target : strcmp(fmt, "text") == 0 ? ~dnd_text_target : strcmp(fmt, "files") == 0 ? ~dnd_files_target : fmt), dnd_time); while(msecs() - t0 < 1000 && dnd_data_wait) FetchEvents(true); LLOG("DragGet data length " << dnd_data.GetLength()); return dnd_data; }
String Gdb::Cmd(const char *command) { if(!dbg || !dbg->IsRunning() || IdeIsDebugLock()) return Null; #ifdef _DEBUG TimeStop ts; #endif Lock(); if(command) { LLOG("========= Cmd: " << command); dbg->Write(String(command) + "\n"); PutVerbose(command); } String result; int ms0 = msecs(); while(dbg) { String s; if(!dbg->Read(s)) { PutVerbose(result); PutVerbose("Debugger terminated"); break; } if(!s.IsEmpty() && Result(result, s)) { LLOG(result); PutVerbose(result); break; } if(ms0 != msecs()) { ProcessEvents(); ms0 = msecs(); } // if(s.GetCount() == 0) GuiSleep(0); if(TTYQuit()) Stop(); } Unlock(); #ifdef _DEBUG if(command) LLOG("Cmd Time of `" << command <<"` " << ts); #endif return result; }
void Ctrl::WndSetPos(const Rect& rect) { LLOG("WndSetPos0 " << rect); GuiLock __; if(!IsOpen()) return; Ptr<Ctrl> this_ = this; SweepConfigure(false); // Remove any previous GDK_CONFIGURE for this window if(!this_ || !IsOpen()) return; // gtk_window_move(gtk(), rect.left, rect.top); // gtk_window_resize(gtk(), rect.GetWidth(), rect.GetHeight()); gdk_window_move_resize(gdk(), rect.left, rect.top, rect.GetWidth(), rect.GetHeight()); int t0 = msecs(); do { // Wait up to 500ms for corresponding GDK_CONFIGURE to arrive if(SweepConfigure(true)) break; } while(msecs() - t0 < 500); LLOG("-- WndSetPos0 " << rect << " " << msecs() - t0); }
int Console::Flush() { bool done_output = false; int num_running = 0; for(int i = 0; i < processes.GetCount(); i++) if(!!processes[i].process) num_running++; if(num_running) { int time = msecs(); for(int i = 0; i < processes.GetCount(); i++) { Slot& slot = processes[i]; if(!!slot.process) { Group& group = groups.GetAdd(slot.group); group.msecs += (time - slot.last_msecs) / num_running; group.raw_msecs += time - slot.last_msecs; slot.last_msecs = time; } } } bool running = false; for(int i = 0; i < processes.GetCount(); i++) { Slot& slot = processes[i]; if(!slot.process) continue; String s; slot.process->Read(s); if(!IsNull(s)) { done_output = true; if(slot.outfile) slot.outfile->Put(s); if(!slot.quiet) { if(console_lock < 0 || console_lock == i) { console_lock = i; AppendOutput(s); } else slot.output.Cat(s); } } if(!slot.process->IsRunning()) { Kill(i); if(slot.exitcode != 0 && verbosebuild) spooled_output.Cat("Error executing " + slot.cmdline + "\n"); if(console_lock == i) console_lock = -1; FlushConsole(); CheckEndGroup(); continue; } running = true; } return !running ? -1 : done_output ? 1 : 0; }
// writes data bool Serial::Write(String const &data, uint32_t timeout) { int dLen = data.GetCount(); if(!timeout) return (write(fd, ~data, data.GetCount()) == dLen); uint32_t tim = msecs() + timeout; const char *dPos = ~data; for(;;) { int written = write(fd, dPos, dLen); if(written == dLen) return true; if(written >= 0) { dPos += written; dLen -= written; continue; } if((uint32_t)msecs() >= tim) break; } return false; }
bool Ctrl::IsWaitingEvent() { GuiLock __; if(quit) { WhenDisconnect(); EndSession(); Exit(0); } while(socket.Timeout(0).WaitRead()) { socket.Timeout(20000); String s = websocket.Recieve(); if(s.IsVoid()) { // No data returned -> means EOF was reached WhenDisconnect(); EndSession(); Exit(0); } LLOG("Recieved data " << s); StringStream ss(s); while(!ss.IsEof()) { String s = ss.GetLine(); CParser p(s); try { if(p.Id("S")) { uint32 l = p.ReadNumber(); uint32 h = p.ReadNumber(); recieved_update_serial = MAKEQWORD(l, h); stat_client_ms = p.ReadNumber(); } else event_queue.AddTail(s); } catch(CParser::Error) {} } if(recieved_update_serial == serial_0) { serial_0 = 0; stat_roundtrip_ms = msecs() - serial_time0; serial_time0 = Null; } } socket.Timeout(20000); if(socket.IsError()) LLOG("ERROR: " << socket.GetErrorDesc()); return event_queue.GetCount(); }
void Ide::BuildAndExecute() { if(Build()) { int time = msecs(); One<Host> h = CreateHostRunDir(); h->ChDir(Nvl(rundir, GetFileFolder(target))); String cmdline; if(!runexternal) cmdline << '\"' << h->GetHostPath(target) << "\" "; cmdline << ToSystemCharset(runarg); int exitcode; switch(runmode) { case RUN_WINDOW: HideBottom(); h->Launch(cmdline, FindIndex(SplitFlags(mainconfigparam, true), "GUI") < 0); break; case RUN_CONSOLE: ShowConsole(); PutConsole(String().Cat() << "Executing: " << cmdline); console.Sync(); exitcode = h->ExecuteWithInput(cmdline); PutConsole("Finished in " + GetPrintTime(time) + ", exit code: " + AsString(exitcode)); break; case RUN_FILE: { HideBottom(); String fn; if(IsNull(stdout_file)) fn = ForceExt(target, ".ol"); else fn = stdout_file; FileOut out(fn); if(!out) { PromptOK("Unable to open output file [* " + DeQtf(stdout_file) + "] !"); return; } if(h->Execute(cmdline, out) >= 0) { out.Close(); EditFile(fn); } } } } }
void AutosaveTest::autosaveStopTest() { { AutosaveTestDocument doc(Autosave::Success); // Enable and trigger Autosave doc.setAutosaveNeeded(true); // Sleep some time QThread::msleep(msecs(0.3 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 0); // Verify that Autosave does not trigger after setAutosaveNeeded(false) doc.setAutosaveNeeded(false); QThread::msleep(msecs(1.1 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 0); } { AutosaveTestDocument doc(Autosave::TemporaryFailure); // Test stopping autosave in temporary failure mode doc.setAutosaveNeeded(true); QThread::msleep(msecs(1.1 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); doc.setAutosaveNeeded(false); QThread::msleep(msecs(autosave_interval) + 6000); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); } { AutosaveTestDocument doc(Autosave::PermanentFailure); // Test stopping autosave in permament failure mode doc.setAutosaveNeeded(true); QThread::msleep(msecs(1.1 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); doc.setAutosaveNeeded(false); QThread::msleep(msecs(1.1 * autosave_interval)); QCoreApplication::processEvents(); QCOMPARE(doc.autosaveCount(), 1); } }
bool InstallService(String name, String display_name, String& cmdline, String& status) { ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if(!scm) { status = "Cannot open service manager"; return false; } ServiceHandle me = OpenService(scm, name, SC_MANAGER_ALL_ACCESS); if(me) { SERVICE_STATUS srvstat; if(ControlService(me, SERVICE_CONTROL_STOP, &srvstat)) { int start = msecs(); while(QueryServiceStatus(me, &srvstat) && srvstat.dwCurrentState != SERVICE_STOPPED && msecs(start) < 10000) Sleep(100); } if(!DeleteService(me)) { status = NFormat("Error deleting existing service: %s", GetLastErrorMessage()); return false; } me.Close(); } me = CreateService(scm, name, display_name, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, cmdline, 0, 0, 0, 0, 0); if(!me) { status = NFormat("Error creating service: %s", GetLastErrorMessage()); return false; } if(!StartService(me, 0, NULL)) { status = NFormat("Error starting service: %s", GetLastErrorMessage()); return false; } return true; }
LRESULT CALLBACK Ctrl::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { GuiLock __; if(sFinished) return DefWindowProc(hWnd, message, wParam, lParam); #ifdef PLATFORM_WINCE if(message == WM_CREATE) #else if(message == WM_NCCREATE) #endif { Ctrl *w = (Ctrl *)((LPCREATESTRUCT) lParam)->lpCreateParams; if(w) { w->NcCreate(hWnd); int i = Windows().Find(NULL); if(i >= 0) { Windows().SetKey(i, hWnd); Windows()[i] = w; } else Windows().Add(hWnd) = w; } } Ctrl *w = Windows().Get(hWnd, NULL); #ifdef PLATFORM_WINCE if(message == WM_DESTROY) #else if(message == WM_NCDESTROY) #endif { if(w) w->NcDestroy(); int i = Windows().Find(hWnd); if(i >= 0) Windows().SetKey(i, NULL); } #if LOGMESSAGES bool logblk = false; if(message != WM_SETCURSOR && message != WM_CTLCOLORBTN && message != WM_TIMER && #ifndef PLATFORM_WINCE message != WM_NCHITTEST && message != WM_ENTERIDLE && #endif message != WM_CTLCOLORDLG && message != WM_CTLCOLOREDIT && message != WM_CTLCOLORLISTBOX && message != WM_CTLCOLORMSGBOX && message != WM_CTLCOLORSCROLLBAR && message != WM_CTLCOLORSTATIC && message != WM_CANCELMODE && message != 0x0118) for(WinMsg *m = sWinMsg; m->ID; m++) if(m->ID == message) { RLOG(m->name << ' ' << UPP::Name(w) << Sprintf(", wParam = %d (0x%x), lParam = %d (0x%x)", wParam, wParam, lParam, lParam)); VppLog() << LOG_BEGIN; logblk = true; break; } #endif LRESULT l = 0; if(w) { #if defined(_DEBUG) && LOGTIMING int ticks = msecs(); String wname = w->Name(); #endif Ptr<Ctrl> pw = w; l = w->WindowProc(message, wParam, lParam); if(pw) pw->SyncMoves(); #if defined(_DEBUG) && LOGTIMING String msgname; for(WinMsg *m = sWinMsg; m->ID; m++) if(m->ID == message) { msgname = m->name; break; } if(IsNull(msgname)) msgname = NFormat("0x%04x", (int)message); LLOG(NFormat("T+%d %s 0x%08x 0x%08x -> %s", msecs(ticks), msgname, (int)wParam, (int)lParam, wname)); #endif } else l = DefWindowProc(hWnd, message, wParam, lParam); #if LOGMESSAGES if(logblk) VppLog() << LOG_END; #endif return l; }
bool Socket::Data::OpenClient(const char *host, int port, bool nodelay, dword *my_addr, int timeout, bool block) { SLOG("Socket::Data::OpenClient(" << host << ':' << port << ", timeout " << timeout << ", block " << block << ')'); int ticks = msecs(); sockaddr_in sin; sockaddr_in addr; { CriticalSection::Lock __(GetHostByNameMutex()); Socket::Init(); hostent *he = gethostbyname(host); if(!he) { SetSockError(NFormat("gethostbyname(%s) failed", host)); return false; } Zero(sin); sin.sin_family = AF_INET; sin.sin_port = htons(0); sin.sin_addr.s_addr = htonl(INADDR_ANY); Zero(addr); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr = *(in_addr *)(he -> h_addr_list[0]); } if(!Open(block)) return false; if(nodelay) NoDelay(); while(bind(socket, (const sockaddr *)&sin, sizeof(sin))) { if(Socket::GetErrorCode() != SOCKERR(EINPROGRESS) || !IsNull(timeout) && msecs(ticks) >= timeout) { SetSockError(NFormat("bind(host=%s, port=%d)", FormatIP(Peek32be(&addr.sin_addr)), port)); return false; } Sleep(500); } if(my_addr) *my_addr = sin.sin_addr.s_addr; #if FAKEERROR fake_error = (rand() * 11111) % 100000; SLOG("Socket::OpenClient -> fake error = " << fake_error); #else fake_error = 0; #endif if(!connect(socket, (sockaddr *)&addr, sizeof(addr))) return true; int err = Socket::GetErrorCode(); #ifdef PLATFORM_WIN32 if(err != SOCKERR(EWOULDBLOCK)) #else if(err != SOCKERR(EINPROGRESS)) #endif { SetSockError(NFormat("connect(%s:%d)", host, port)); SLOG("Socket::Data::OpenClient -> connect error, returning false"); return false; } /* if(!Peek(IsNull(timeout) ? NB_TIMEOUT : max<int>(0, timeout - msecs(ticks)), true)) { SetSockError("connect timeout expired"); return false; } */ return true; }
int Timestamp::msecsDiff(const Timestamp &ts) const { return msecs() - ts.msecs(); }
bool MakeBuild::Build(const Workspace& wspc, String mainparam, String outfile, bool clear_console) { String hfile = outfile + ".xxx"; SaveFile(hfile, ""); FileTime start_time = GetFileTime(hfile); // Defensive way to get correct filetime of start DeleteFile(hfile); ClearErrorEditor(); BeginBuilding(true, clear_console); bool ok = true; if(wspc.GetCount()) { for(int i = 0; i < wspc.GetCount(); i++) { const Package& pk = wspc.package[i]; for(int j = 0; j < pk.GetCount(); j++) if(pk[j] == "main.conf") { String pn = wspc[i]; String p = SourcePath(pn, "main.conf"); main_conf << "// " << pn << "\r\n" << LoadFile(p) << "\r\n"; PutConsole("Found " + p); } } if(main_conf.GetCount()) { VectorMap<String, String> bm = GetMethodVars(method); One<Host> host = CreateHost(false); One<Builder> b = CreateBuilder(~host); if(b) { Index<String> mcfg = PackageConfig(wspc, 0, bm, mainparam, *host, *b, NULL); String outdir = OutDir(mcfg, wspc[0], bm, false); String path = AppendFileName(outdir, "main.conf.h"); RealizePath(path); SaveChangedFile(path, main_conf); PutConsole("Saving " + path); add_includes << outdir << ';'; } } Vector<int> build_order; if(GetTargetMode().linkmode != 2) { for(int i = 1; i < wspc.GetCount(); i++) build_order.Add(i); } else { Index<int> remaining; for(int i = 1; i < wspc.GetCount(); i++) remaining.Add(i); while(!remaining.IsEmpty()) { int t; for(t = 0; t < remaining.GetCount(); t++) { const Package& pk = wspc.package[remaining[t]]; bool delay = false; for(int u = 0; u < pk.uses.GetCount(); u++) if(remaining.Find(wspc.package.Find(pk.uses[u].text)) >= 0) { delay = true; break; } if(!delay) break; } if(t >= remaining.GetCount()) t = 0; build_order.Add(remaining[t]); remaining.Remove(t); } } String mainpackage = wspc[0]; Vector<String> linkfile; String linkopt = GetMethodVars(method).Get(targetmode ? "RELEASE_LINK" : "DEBUG_LINK", Null); if(linkopt.GetCount()) linkopt << ' '; ok = true; int ms = msecs(); for(int i = 0; i < build_order.GetCount() && (ok || !stoponerrors); i++) { int px = build_order[i]; ok = BuildPackage(wspc, px, i, build_order.GetCount() + 1, mainparam, Null, linkfile, linkopt) && ok; if(msecs() - ms >= 200) { DoProcessEvents(); ms = msecs(); } } if(ok || !stoponerrors) { ok = BuildPackage(wspc, 0, build_order.GetCount(), build_order.GetCount() + 1, mainparam, outfile, linkfile, linkopt, ok) && ok; // Set the time of target to start-time, so that if any file changes during // compilation, it is recompiled during next build SetFileTime(target, start_time); } } EndBuilding(ok); ReQualifyCodeBase(); SetErrorEditor(); return ok; }
int main(int argc, char **argv) { char buf[32]; struct pru_data pru; int fd, rdsize; #ifndef DEBUG if (fork() != 0) { return 0; } #endif tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("Initializing pruss\n"); prussdrv_init(); if (prussdrv_open(PRU_EVTOUT_0)) { fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n"); return -EINVAL; } printf("Initializing interrupts\n"); prussdrv_pruintc_init(&pruss_intc_initdata); printf("Mapping PRUSS0 RAM\n"); prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem); if (pru.prumem == NULL) { fprintf(stderr, "Cannot map PRU0 memory buffer.\n"); return -ENOMEM; } printf("Creating FIFO\n"); /* Create the FIFO if it does not exist */ umask(0); mknod(FIFO_FILE, S_IFIFO|0666, 0); printf("Opening FIFO\n"); fd = open(FIFO_FILE, O_RDONLY); if (fd < 0) { fprintf(stderr, "Cannot open FIFO.\n"); return -EINVAL; } pru.prumem[RUN_FLAG_IDX] = 1; /* startup */ printf("Loading PRU0 program\n"); prussdrv_exec_program(0, "7seg_spi_test_fifo.bin"); signal(SIGINT, shutdown_clock); signal(SIGTERM, shutdown_clock); printf("Entering runloop\n"); while (running) { if ((rdsize = read(fd, buf, sizeof(buf) - 1)) > 0) { update_buffer((const char *) &buf, &pru, rdsize); } usleep(msecs(10)); } close(fd); pru.prumem[RUN_FLAG_IDX] = 0; #ifdef DEBUG fprintf(stdout, "Waiting for PRU core to shutdown..\n"); #endif prussdrv_pru_wait_event(PRU_EVTOUT_0); prussdrv_pru_clear_event(PRU0_ARM_INTERRUPT); prussdrv_pru_disable(0); prussdrv_exit(); return 0; }