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;
}