int main (int argc, char *argv[]) { ProgramExitStatus exitStatus = PROG_EXIT_FATAL; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "brltty-trtxt", .argumentsSummary = "[{input-file | -} ...]" }; PROCESS_OPTIONS(descriptor, argc, argv); } if (getTable(&inputTable, opt_inputTable)) { if (getTable(&outputTable, opt_outputTable)) { outputStream = stdout; outputName = standardOutputName; toDots = inputTable? toDots_mapped: toDots_unicode; toCharacter = outputTable? toCharacter_mapped: toCharacter_unicode; if (argc) { do { const char *file = argv[0]; FILE *stream; if (strcmp(file, standardStreamArgument) == 0) { if (!processStream(stdin, standardInputName)) break; } else if ((stream = fopen(file, "r"))) { int ok = processStream(stream, file); fclose(stream); if (!ok) break; } else { logMessage(LOG_ERR, "cannot open file: %s: %s", file, strerror(errno)); exitStatus = PROG_EXIT_SEMANTIC; break; } argv += 1, argc -= 1; } while (argc); if (!argc) exitStatus = PROG_EXIT_SUCCESS; } else if (processStream(stdin, standardInputName)) { exitStatus = PROG_EXIT_SUCCESS; } if (outputTable) destroyTextTable(outputTable); } if (inputTable) destroyTextTable(inputTable); } return exitStatus; }
int main (int argc, char *argv[]) { ProgramExitStatus exitStatus = PROG_EXIT_SUCCESS; brlapi_fileDescriptor fd; settings.host = NULL; settings.auth = NULL; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "apitest" }; PROCESS_OPTIONS(descriptor, argc, argv); } fprintf(stderr, "Connecting to BrlAPI... "); if ((fd=brlapi_openConnection(&settings, &settings)) != (brlapi_fileDescriptor)(-1)) { fprintf(stderr, "done (fd=%"PRIfd")\n", fd); fprintf(stderr,"Connected to %s using auth %s\n", settings.host, settings.auth); if (opt_showName) { showDriverName(); } if (opt_showSize) { showDisplaySize(); } if (opt_showDots) { showDots(); } if (opt_learnMode) { enterLearnMode(); } if (opt_showKeyCodes) { showKeyCodes(); } if (opt_suspendMode) { suspendDriver(); } brlapi_closeConnection(); fprintf(stderr, "Disconnected\n"); } else { fprintf(stderr, "failed to connect to %s using auth %s",settings.host, settings.auth); brlapi_perror(""); exitStatus = PROG_EXIT_FATAL; } return exitStatus; }
int main (int argc, char *argv[]) { { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "tunetest", .argumentsSummary = "{note duration} ..." }; PROCESS_OPTIONS(descriptor, argc, argv); } resetPreferences(); if (opt_tuneDevice && *opt_tuneDevice) { unsigned int device; if (!validateChoice(&device, opt_tuneDevice, deviceNames)) { logMessage(LOG_ERR, "%s: %s", "invalid tune device", opt_tuneDevice); return PROG_EXIT_SYNTAX; } prefs.tuneDevice = device; } #ifdef HAVE_MIDI_SUPPORT if (opt_midiInstrument && *opt_midiInstrument) { unsigned char instrument; if (!validateInstrument(&instrument, opt_midiInstrument)) { logMessage(LOG_ERR, "%s: %s", "invalid musical instrument", opt_midiInstrument); return PROG_EXIT_SYNTAX; } prefs.midiInstrument = instrument; } #endif /* HAVE_MIDI_SUPPORT */ if (opt_outputVolume && *opt_outputVolume) { static const int minimum = 0; static const int maximum = 100; int volume; if (!validateInteger(&volume, opt_outputVolume, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid volume percentage", opt_outputVolume); return PROG_EXIT_SYNTAX; } switch (prefs.tuneDevice) { case tdPcm: prefs.pcmVolume = volume; break; case tdMidi: prefs.midiVolume = volume; break; case tdFm: prefs.fmVolume = volume; break; default: break; } } if (!argc) { logMessage(LOG_ERR, "missing tune."); return PROG_EXIT_SYNTAX; } if (argc % 2) { logMessage(LOG_ERR, "missing note duration."); return PROG_EXIT_SYNTAX; } { unsigned int count = argc / 2; TuneElement *elements = malloc((sizeof(*elements) * count) + 1); if (elements) { TuneElement *element = elements; while (argc) { int note; int duration; { static const int minimum = 0X01; static const int maximum = 0X7F; const char *argument = *argv++; if (!validateInteger(¬e, argument, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid note number", argument); return PROG_EXIT_SYNTAX; } --argc; } { static const int minimum = 1; static const int maximum = 255; const char *argument = *argv++; if (!validateInteger(&duration, argument, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid note duration", argument); return PROG_EXIT_SYNTAX; } --argc; } { TuneElement te = TUNE_NOTE(duration, note); *(element++) = te; } } { TuneElement te = TUNE_STOP(); *element = te; } } else { logMallocError(); return PROG_EXIT_FATAL; } if (!setTuneDevice(prefs.tuneDevice)) { logMessage(LOG_ERR, "unsupported tune device: %s", deviceNames[prefs.tuneDevice]); return PROG_EXIT_SEMANTIC; } { playTune(elements); closeTuneDevice(); } free(elements); } return PROG_EXIT_SUCCESS; }
int main (int argc, char *argv[]) { ProgramExitStatus exitStatus = PROG_EXIT_SUCCESS; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "ktbtest", .argumentsSummary = "key-table" }; PROCESS_OPTIONS(descriptor, argc, argv); } { char **const paths[] = { &opt_driversDirectory, &opt_tablesDirectory, NULL }; fixInstallPaths(paths); } if (argc) { const char *keyTableName = (argc--, *argv++); char *keyTablePath = makeKeyTablePath(opt_tablesDirectory, keyTableName); if (keyTablePath) { KEY_NAME_TABLES_REFERENCE keyNameTables; { const char *file = locatePathName(keyTablePath); size_t length = strrchr(file, '.') - file; char name[length + 1]; memcpy(name, file, length); name[length] = 0; keyNameTables = getKeyNameTables(name); } if (keyNameTables) { if (opt_listKeyNames) if (!listKeyNames(keyNameTables, listLine, NULL)) exitStatus = PROG_EXIT_FATAL; if (exitStatus == PROG_EXIT_SUCCESS) { KeyTable *keyTable = compileKeyTable(keyTablePath, keyNameTables); if (keyTable) { if (opt_listKeyTable) if (!listKeyTable(keyTable, listLine, NULL)) exitStatus = PROG_EXIT_FATAL; destroyKeyTable(keyTable); } else { exitStatus = PROG_EXIT_FATAL; } } } else { exitStatus = PROG_EXIT_FATAL; } free(keyTablePath); } else { exitStatus = PROG_EXIT_FATAL; } } else { logMessage(LOG_ERR, "missing key table name"); exitStatus = PROG_EXIT_SYNTAX; } return exitStatus; }
int main (int argc, char *argv[]) { ProgramExitStatus exitStatus; const char *driver = NULL; void *object; float speechRate; float speechVolume; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "spktest", .argumentsSummary = "[driver [parameter=value ...]]" }; PROCESS_OPTIONS(descriptor, argc, argv); } { char **const paths[] = { &opt_driversDirectory, &opt_dataDirectory, NULL }; fixInstallPaths(paths); } speechRate = 1.0; if (opt_speechRate && *opt_speechRate) { static const float minimum = 0.1; static const float maximum = 10.0; if (!validateFloat(&speechRate, opt_speechRate, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid rate multiplier", opt_speechRate); return PROG_EXIT_SYNTAX; } } speechVolume = 1.0; if (opt_speechVolume && *opt_speechVolume) { static const float minimum = 0.0; static const float maximum = 2.0; if (!validateFloat(&speechVolume, opt_speechVolume, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid volume multiplier", opt_speechVolume); return PROG_EXIT_SYNTAX; } } if (argc) { driver = *argv++; --argc; } if ((speech = loadSpeechDriver(driver, &object, opt_driversDirectory))) { const char *const *parameterNames = speech->parameters; char **parameterSettings; if (!parameterNames) { static const char *const noNames[] = {NULL}; parameterNames = noNames; } { const char *const *name = parameterNames; unsigned int count; char **setting; while (*name) ++name; count = name - parameterNames; if (!(parameterSettings = malloc((count + 1) * sizeof(*parameterSettings)))) { logMallocError(); return PROG_EXIT_FATAL; } setting = parameterSettings; while (count--) *setting++ = ""; *setting = NULL; } while (argc) { char *assignment = *argv++; int ok = 0; char *delimiter = strchr(assignment, '='); if (!delimiter) { logMessage(LOG_ERR, "missing speech driver parameter value: %s", assignment); } else if (delimiter == assignment) { logMessage(LOG_ERR, "missing speech driver parameter name: %s", assignment); } else { size_t nameLength = delimiter - assignment; const char *const *name = parameterNames; while (*name) { if (strncasecmp(assignment, *name, nameLength) == 0) { parameterSettings[name - parameterNames] = delimiter + 1; ok = 1; break; } ++name; } if (!ok) logMessage(LOG_ERR, "invalid speech driver parameter: %s", assignment); } if (!ok) return PROG_EXIT_SYNTAX; --argc; } initializeSpeechSynthesizer(&spk); identifySpeechDriver(speech, 0); /* start-up messages */ if (speech->construct(&spk, parameterSettings)) { if (speech->setVolume) speech->setVolume(&spk, speechVolume); if (speech->setRate) speech->setRate(&spk, speechRate); if (opt_textString && *opt_textString) { sayString(&spk, opt_textString, 0); } else { processLines(stdin, sayLine, NULL); } speech->destruct(&spk); /* finish with the display */ exitStatus = PROG_EXIT_SUCCESS; } else { logMessage(LOG_ERR, "can't initialize speech driver."); exitStatus = PROG_EXIT_FATAL; } } else { logMessage(LOG_ERR, "can't load speech driver."); exitStatus = PROG_EXIT_FATAL; } return exitStatus; }
int main (int argc, char *argv[]) { ProgramExitStatus exitStatus = PROG_EXIT_SUCCESS; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "brltty-ktb", .argumentsSummary = "key-table" }; PROCESS_OPTIONS(descriptor, argc, argv); } driverObject = NULL; if (argc) { const char *tableName = (argc--, *argv++); KeyTableDescriptor ktd; int gotKeyTableDescriptor; { const char *file = locatePathName(tableName); const char *delimiter = strrchr(file, '.'); size_t length = delimiter? (delimiter - file): strlen(file); char name[length + 1]; memcpy(name, file, length); name[length] = 0; gotKeyTableDescriptor = getKeyTableDescriptor(&ktd, name); } if (gotKeyTableDescriptor) { if (opt_listKeyNames) { if (!listKeyNames(ktd.names, hlpWriteLine, NULL)) { exitStatus = PROG_EXIT_FATAL; } } if (exitStatus == PROG_EXIT_SUCCESS) { KeyTable *keyTable = compileKeyTable(ktd.path, ktd.names); if (keyTable) { if (opt_audit) { if (!auditKeyTable(keyTable, ktd.path)) { exitStatus = PROG_EXIT_FATAL; } } if (opt_listHelpScreen) { if (!listKeyTable(keyTable, NULL, hlpWriteLine, NULL)) { exitStatus = PROG_EXIT_FATAL; } } if (opt_listRestructuredText) { RestructuredTextData rst = { .headerLevel = 0, .elementLevel = 0, .elementBullet = WC_C(' '), .blankLine = 0 }; if (!listKeyTable(keyTable, &rstMethods, rstWriteLine, &rst)) { exitStatus = PROG_EXIT_FATAL; } } destroyKeyTable(keyTable); } else { exitStatus = PROG_EXIT_FATAL; } } free(ktd.path); } else {
int main (int argc, char *argv[]) { ProgramExitStatus exitStatus; void *driverObject; { static const OptionsDescriptor descriptor = { OPTION_TABLE(programOptions), .applicationName = "scrtest", .argumentsSummary = "[parameter=value ...]" }; PROCESS_OPTIONS(descriptor, argc, argv); } if ((screen = loadScreenDriver(opt_screenDriver, &driverObject, opt_driversDirectory))) { const char *const *parameterNames = getScreenParameters(screen); char **parameterSettings; if (!parameterNames) { static const char *const noNames[] = {NULL}; parameterNames = noNames; } { const char *const *name = parameterNames; unsigned int count; char **setting; while (*name) ++name; count = name - parameterNames; if (!(parameterSettings = malloc((count + 1) * sizeof(*parameterSettings)))) { logMallocError(); return PROG_EXIT_FATAL; } setting = parameterSettings; while (count--) *setting++ = ""; *setting = NULL; } while (argc) { char *assignment = *argv++; int ok = 0; char *delimiter = strchr(assignment, '='); if (!delimiter) { logMessage(LOG_ERR, "missing screen parameter value: %s", assignment); } else if (delimiter == assignment) { logMessage(LOG_ERR, "missing screen parameter name: %s", assignment); } else { size_t nameLength = delimiter - assignment; const char *const *name = parameterNames; while (*name) { if (strncasecmp(assignment, *name, nameLength) == 0) { parameterSettings[name - parameterNames] = delimiter + 1; ok = 1; break; } ++name; } if (!ok) logMessage(LOG_ERR, "invalid screen parameter: %s", assignment); } if (!ok) return PROG_EXIT_SYNTAX; --argc; } if (constructScreenDriver(parameterSettings)) { ScreenDescription description; int left, top, width, height; describeScreen(&description); printf("Screen: %dx%d\n", description.cols, description.rows); printf("Cursor: [%d,%d]\n", description.posx, description.posy); if (setRegion(&left, opt_boxLeft, "starting column", &width, opt_boxWidth, description.cols, "region width")) { if (setRegion(&top, opt_boxTop, "starting row", &height, opt_boxHeight, description.rows, "region height")) { printf("Region: %dx%d@[%d,%d]\n", width, height, left, top); { ScreenCharacter buffer[width * height]; if (readScreen(left, top, width, height, buffer)) { int line; for (line=0; line<height; line++) { int column; for (column=0; column<width; column++) { wchar_t character = buffer[line * width + column].text; if (!iswLatin1(character)) { putchar('?'); } else if (!isprint(character)) { putchar('*'); } else { putchar(character); } } putchar('\n'); } exitStatus = PROG_EXIT_SUCCESS; } else { logMessage(LOG_ERR, "Can't read screen."); exitStatus = PROG_EXIT_FATAL; } } } else { exitStatus = PROG_EXIT_SYNTAX; } } else { exitStatus = PROG_EXIT_SYNTAX; } } else { logMessage(LOG_ERR, "can't open screen."); exitStatus = PROG_EXIT_FATAL; } destructScreenDriver(); } else { logMessage(LOG_ERR, "can't load screen driver."); exitStatus = PROG_EXIT_FATAL; } return exitStatus; }