static void report_pcm_state(struct audio *audio, const char *prefix) { char buf[32]; snd_pcm_state_t state; #define HANDLE_CASE(_c) case _c: strncpy(buf, #_c, sizeof(buf)); break switch (state = snd_pcm_state(audio->pcm)) { HANDLE_CASE(SND_PCM_STATE_OPEN); HANDLE_CASE(SND_PCM_STATE_SETUP); HANDLE_CASE(SND_PCM_STATE_PREPARED); HANDLE_CASE(SND_PCM_STATE_RUNNING); HANDLE_CASE(SND_PCM_STATE_XRUN); HANDLE_CASE(SND_PCM_STATE_DRAINING); HANDLE_CASE(SND_PCM_STATE_PAUSED); HANDLE_CASE(SND_PCM_STATE_SUSPENDED); HANDLE_CASE(SND_PCM_STATE_DISCONNECTED); default: snprintf(buf, sizeof(buf), "UNKNOWN<%d>", state); break; } #undef HANDLE_CASE fprintf(stderr, "%s: %s(): %s\n", prefix, __func__, buf); }
int audio_getid(const char *name) { for (int i = 0; i < _sounds_count; ++i) { if (strcmp(name, _sounds_desc[i].name) == 0) return i; } HANDLE_CASE(false); return 0; }
void audio_play(int id) { assert(id < _sounds_count); // Find a free stream int free_stream; for (free_stream = 0; free_stream < _STREAM_COUNT; ++free_stream) { if (_VOLATILE(_streams[free_stream].begin) == -1) break; } HANDLE_CASE(free_stream == _STREAM_COUNT); // Play on the free stream _VOLATILE(_streams[free_stream].end) = _sounds_desc[id].end; _VOLATILE(_streams[free_stream].begin) = _sounds_desc[id].begin; }
void CreateExceptionInfoString(int32 Signal, struct __siginfo* Info) { FString ErrorString = TEXT("Unhandled Exception: "); #define HANDLE_CASE(a,b) case a: ErrorString += TEXT(#a #b); break; switch (Signal) { case SIGSEGV: ErrorString += TEXT("SIGSEGV segmentation violation at address "); ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr); break; case SIGBUS: ErrorString += TEXT("SIGBUS bus error at address "); ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr); break; HANDLE_CASE(SIGINT, "interrupt program") HANDLE_CASE(SIGQUIT, "quit program") HANDLE_CASE(SIGILL, "illegal instruction") HANDLE_CASE(SIGTRAP, "trace trap") HANDLE_CASE(SIGABRT, "abort() call") HANDLE_CASE(SIGFPE, "floating-point exception") HANDLE_CASE(SIGKILL, "kill program") HANDLE_CASE(SIGSYS, "non-existent system call invoked") HANDLE_CASE(SIGPIPE, "write on a pipe with no reader") HANDLE_CASE(SIGTERM, "software termination signal") HANDLE_CASE(SIGSTOP, "stop") default: ErrorString += FString::Printf(TEXT("0x%08x"), (uint32)Signal); } #if WITH_EDITORONLY_DATA FCString::Strncpy(GErrorExceptionDescription, *ErrorString, FMath::Min(ErrorString.Len() + 1, (int32)ARRAY_COUNT(GErrorExceptionDescription))); #endif #undef HANDLE_CASE }
FString DescribeSignal(int32 Signal, siginfo_t* Info) { FString ErrorString; #define HANDLE_CASE(a,b) case a: ErrorString += TEXT(#a ": " b); break; switch (Signal) { case 0: // No signal - used for initialization stacktrace on non-fatal errors (ex: ensure) break; case SIGSEGV: ErrorString += TEXT("SIGSEGV: invalid attempt to access memory at address "); ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr); break; case SIGBUS: ErrorString += TEXT("SIGBUS: invalid attempt to access memory at address "); ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr); break; HANDLE_CASE(SIGINT, "program interrupted") HANDLE_CASE(SIGQUIT, "user-requested crash") HANDLE_CASE(SIGILL, "illegal instruction") HANDLE_CASE(SIGTRAP, "trace trap") HANDLE_CASE(SIGABRT, "abort() called") HANDLE_CASE(SIGFPE, "floating-point exception") HANDLE_CASE(SIGKILL, "program killed") HANDLE_CASE(SIGSYS, "non-existent system call invoked") HANDLE_CASE(SIGPIPE, "write on a pipe with no reader") HANDLE_CASE(SIGTERM, "software termination signal") HANDLE_CASE(SIGSTOP, "stop") default: ErrorString += FString::Printf(TEXT("Signal %d (unknown)"), Signal); } return ErrorString; #undef HANDLE_CASE }
// [[register]] SEXP transpose_list(SEXP x_) { SEXP x; bool do_coerce = false; int n = length(x_); int N = length(VECTOR_ELT(x_, 0)); char type = max_type1(x_); for (int i=0; i < n; ++i) { if (length(VECTOR_ELT(x_, i)) != N) { Rf_error("Each element in the list must be of the same length"); } } for (int i=0; i < n; ++i) { if (TYPEOF( VECTOR_ELT(x_, i) ) != type) { Rf_warning("Coercing vectors in the list to type '%s'", type2char(type)); do_coerce = true; break; } } if (do_coerce) { x = PROTECT( duplicate(x_) ); for (int i=0; i < n; ++i) { if (TYPEOF(VECTOR_ELT(x, i)) != type) { SET_VECTOR_ELT(x, i, coerceVector(VECTOR_ELT(x, i), type)); } } } else { x = x_; } SEXP output = PROTECT( allocVector(VECSXP, N) ); #define HANDLE_CASE(RTYPE, CTYPE, ACCESSOR) { \ for (int j=0; j < N; ++j) { \ SET_VECTOR_ELT(output, j, allocVector(RTYPE, n)); \ CTYPE* ptr = ACCESSOR( VECTOR_ELT(output, j) ); \ for (int i=0; i < n; ++i) { \ ptr[i] = ACCESSOR( VECTOR_ELT(x, i) )[j]; \ } \ } \ break; \ } \ switch (type) { case LGLSXP: HANDLE_CASE(LGLSXP, int, LOGICAL); case INTSXP: HANDLE_CASE(INTSXP, int, INTEGER); case REALSXP: HANDLE_CASE(REALSXP, double, REAL); case STRSXP: HANDLE_CASE(STRSXP, SEXP, STRING_PTR); } #undef HANDLE_CASE UNPROTECT(1); if (do_coerce) UNPROTECT(1); return output; }
void FApplePlatformCrashContext::CreateExceptionInfoString(int32 Signal, siginfo_t* Info) { #define HANDLE_CASE(a,b) case a: FCString::Strncpy(GErrorExceptionDescription, TEXT(#a ": " b), ARRAY_COUNT( SignalDescription ) - 1); break; switch (Signal) { case SIGSEGV: FCString::Strncpy(GErrorExceptionDescription, TEXT("SIGSEGV: invalid attempt to access memory at address 0x"), ARRAY_COUNT( SignalDescription ) - 1); FCString::Strcat(GErrorExceptionDescription, ItoTCHAR((uintptr_t)Info->si_addr, 16)); break; case SIGBUS: FCString::Strncpy(GErrorExceptionDescription, TEXT("SIGBUS: invalid attempt to access memory at address 0x"), ARRAY_COUNT( SignalDescription ) - 1); FCString::Strcat(GErrorExceptionDescription, ItoTCHAR((uintptr_t)Info->si_addr, 16)); break; HANDLE_CASE(SIGINT, "program interrupted") HANDLE_CASE(SIGQUIT, "user-requested crash") HANDLE_CASE(SIGILL, "illegal instruction") HANDLE_CASE(SIGTRAP, "trace trap") HANDLE_CASE(SIGABRT, "abort() called") HANDLE_CASE(SIGFPE, "floating-point exception") HANDLE_CASE(SIGKILL, "program killed") HANDLE_CASE(SIGSYS, "non-existent system call invoked") HANDLE_CASE(SIGPIPE, "write on a pipe with no reader") HANDLE_CASE(SIGTERM, "software termination signal") HANDLE_CASE(SIGSTOP, "stop") default: FCString::Strncpy(GErrorExceptionDescription, TEXT("Signal "), ARRAY_COUNT( SignalDescription ) - 1); FCString::Strcat(GErrorExceptionDescription, ItoTCHAR(Signal, 10)); FCString::Strcat(GErrorExceptionDescription, TEXT(" (unknown)")); break; } #undef HANDLE_CASE }
void FApplePlatformCrashContext::InitFromSignal(int32 InSignal, siginfo_t* InInfo, void* InContext) { Signal = InSignal; Info = InInfo; Context = reinterpret_cast< ucontext_t* >( InContext ); #define HANDLE_CASE(a,b) case a: FCStringAnsi::Strncpy(SignalDescription, #a ": " b, ARRAY_COUNT( SignalDescription ) - 1); break; switch (Signal) { case SIGSEGV: FCStringAnsi::Strncpy(SignalDescription, "SIGSEGV: invalid attempt to access memory at address 0x", ARRAY_COUNT( SignalDescription ) - 1); FCStringAnsi::Strcat(SignalDescription, ItoANSI((uintptr_t)Info->si_addr, 16)); break; case SIGBUS: FCStringAnsi::Strncpy(SignalDescription, "SIGBUS: invalid attempt to access memory at address 0x", ARRAY_COUNT( SignalDescription ) - 1); FCStringAnsi::Strcat(SignalDescription, ItoANSI((uintptr_t)Info->si_addr, 16)); break; HANDLE_CASE(SIGINT, "program interrupted") HANDLE_CASE(SIGQUIT, "user-requested crash") HANDLE_CASE(SIGILL, "illegal instruction") HANDLE_CASE(SIGTRAP, "trace trap") HANDLE_CASE(SIGABRT, "abort() called") HANDLE_CASE(SIGFPE, "floating-point exception") HANDLE_CASE(SIGKILL, "program killed") HANDLE_CASE(SIGSYS, "non-existent system call invoked") HANDLE_CASE(SIGPIPE, "write on a pipe with no reader") HANDLE_CASE(SIGTERM, "software termination signal") HANDLE_CASE(SIGSTOP, "stop") default: FCStringAnsi::Strncpy(SignalDescription, "Signal ", ARRAY_COUNT( SignalDescription ) - 1); FCStringAnsi::Strcat(SignalDescription, ItoANSI(Signal, 10)); FCStringAnsi::Strcat(SignalDescription, " (unknown)"); break; } #undef HANDLE_CASE }
void audio_init(void) { FILE *f; puts("Initializing the audio subsystem"); memset(_streams, -1, sizeof _streams); puts("\tInitializing SDL audio"); HANDLE_CASE(SDL_Init(SDL_INIT_AUDIO) == -1); SDL_AudioSpec fmt; fmt.freq = 22050; fmt.format = AUDIO_S16; fmt.channels = 1; fmt.samples = 512; fmt.callback = _mixaudio; fmt.userdata = NULL; HANDLE_CASE(SDL_OpenAudio(&fmt, NULL) == -1); SDL_PauseAudio(0); puts("\tLoading sounds.raw"); f = fopen("sounds.raw", "r"); HANDLE_CASE(f == NULL); HANDLE_CASE(fseek(f, 0, SEEK_END) != 0); int filesize = ftell(f); HANDLE_CASE(filesize <= 0); HANDLE_CASE(fseek(f, 0, SEEK_SET) != 0); _all_sounds = malloc(filesize); HANDLE_CASE(fread(_all_sounds, filesize, 1, f) != 1); HANDLE_CASE(fclose(f) != 0); _all_sounds_length = filesize / 2; puts("\tLoading sounds.desc"); // sounds.desc consists of two entries per line: // <name of the sound> <the number of samples it has> f = fopen("sounds.desc", "r"); HANDLE_CASE(f == NULL); char name[MAXSTR]; int begin = 0, length; while (fscanf(f, "%60s %d", name, &length) == 2) { HANDLE_CASE(_sounds_count >= _MAX_SOUNDS); int idx = _sounds_count++; _sounds_desc[idx].begin = begin; begin += length; _sounds_desc[idx].end = begin; strcpy(_sounds_desc[idx].name, name); HANDLE_CASE(begin > _all_sounds_length); } HANDLE_CASE(fclose(f) != 0); }
// [[register]] SEXP unmelt(SEXP data, SEXP uniq_id, SEXP other_ind_, SEXP id_ind_, SEXP value_ind_) { // int id_ind = asInteger(id_ind_); int value_ind = asInteger(value_ind_); int* other_ind = INTEGER(other_ind_); int nRow = (int)(length(VECTOR_ELT(data, 0)) / length(uniq_id)); int numprotect = 0; if (TYPEOF(uniq_id) != STRSXP) { GUARD(uniq_id = coerceVector(uniq_id, STRSXP)); } int n_uniq = length(uniq_id); SEXP output; GUARD(output = allocVector(VECSXP, length(other_ind_) + length(uniq_id))); int n_other = length(other_ind_); // ensure that the unmelting process will go smoothly #define HANDLE_CASE(RTYPE, CTYPE, ACCESSOR) \ case RTYPE: { \ CTYPE* tmp = ACCESSOR( VECTOR_ELT(data, other_ind[i]) ); \ for (int j=0; j < nRow; ++j) { \ for (int k=1; k < n_uniq; ++k) { \ if (tmp[j] != tmp[j + nRow*k]) { \ Rf_error("Mismatch in elements at indices %i and %i in vector %s", j+1, j + nRow*k+1, CHAR(STRING_ELT(getAttrib(data, R_NamesSymbol), other_ind[i]))); \ } \ } \ } \ break; \ } \ if (n_uniq > 1) { for (int i=0; i < n_other; ++i) { switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) { HANDLE_CASE(LGLSXP, int, LOGICAL); HANDLE_CASE(INTSXP, int, INTEGER); HANDLE_CASE(REALSXP, double, REAL); HANDLE_CASE(STRSXP, SEXP, STRING_PTR); default: Rf_error("Unhandled type %s", type2char(TYPEOF(VECTOR_ELT(data, other_ind[i])))); } } } #undef HANDLE_CASE // copy in the 'other' variables first #define COPY(RTYPE, CTYPE, ACCESSOR) { \ PROTECT(tmp = allocVector(RTYPE, nRow)); \ CTYPE* tmp_ptr = ACCESSOR(tmp); \ CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, other_ind[i])); \ for (int i=0; i < nRow; ++i) { \ tmp_ptr[i] = data_ptr[i]; \ } \ SET_VECTOR_ELT(output, i, tmp); \ UNPROTECT(1); \ break; \ } \ SEXP tmp; for (int i=0; i < n_other; ++i) { switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) { case LGLSXP: COPY(LGLSXP, int, LOGICAL); case INTSXP: COPY(INTSXP, int, INTEGER); case REALSXP: COPY(REALSXP, double, REAL); case STRSXP: COPY(STRSXP, SEXP, STRING_PTR); default: Rf_error("Unhandled SEXP type"); } } #undef COPY #define COPY(RTYPE, CTYPE, ACCESSOR) { \ PROTECT(tmp = allocVector(RTYPE, nRow)); \ CTYPE* tmp_ptr = ACCESSOR(tmp); \ CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, value_ind)); \ for (int j=0; j < nRow; ++j) { \ tmp_ptr[j] = data_ptr[j + (i*nRow)]; \ } \ SET_VECTOR_ELT(output, i + n_other, tmp); \ UNPROTECT(1); \ break; \ } \ // copy the value int valuetype = TYPEOF(VECTOR_ELT(data, value_ind)); for (int i=0; i < n_uniq; ++i) { switch (valuetype) { case LGLSXP: COPY(LGLSXP, int, LOGICAL); case INTSXP: COPY(INTSXP, int, INTEGER); case REALSXP: COPY(REALSXP, double, REAL); case STRSXP: COPY(STRSXP, SEXP, STRING_PTR); } } // set the names SEXP datanames = getAttrib(data, R_NamesSymbol); SEXP names; GUARD(names = allocVector(STRSXP, n_other + n_uniq)); for (int i=0; i < n_other; ++i) { SET_STRING_ELT(names, i, STRING_ELT(datanames, i)); } for (int i=0; i < n_uniq; ++i) { SET_STRING_ELT(names, n_other+i, STRING_ELT(uniq_id, i)); } setAttrib(output, R_NamesSymbol, names); // set the class setAttrib(output, R_ClassSymbol, mkString("data.frame")); // set the rows SEXP rownames; GUARD( rownames=allocVector(INTSXP, nRow) ); int* rownames_ptr = INTEGER(rownames); for (int i=0; i < nRow; ++i) { rownames_ptr[i] = i+1; } setAttrib(output, R_RowNamesSymbol, rownames); UNGUARD; return output; }