int parseKeyboardProperties (KeyboardProperties *properties, const char *string) { enum { KBD_PARM_TYPE, KBD_PARM_VENDOR, KBD_PARM_PRODUCT }; static const char *const names[] = {"type", "vendor", "product", NULL}; char **parameters = getParameters(names, NULL, string); int ok = 1; logParameters(names, parameters, "Keyboard Property"); *properties = anyKeyboard; if (*parameters[KBD_PARM_TYPE]) { static const KeyboardType types[] = {KBD_TYPE_Any, KBD_TYPE_PS2, KBD_TYPE_USB, KBD_TYPE_Bluetooth}; static const char *choices[] = {"any", "ps2", "usb", "bluetooth", NULL}; unsigned int choice; if (validateChoice(&choice, parameters[KBD_PARM_TYPE], choices)) { properties->type = types[choice]; } else { logMessage(LOG_WARNING, "invalid keyboard type: %s", parameters[KBD_PARM_TYPE]); ok = 0; } } if (*parameters[KBD_PARM_VENDOR]) { static const int minimum = 0; static const int maximum = 0XFFFF; int value; if (validateInteger(&value, parameters[KBD_PARM_VENDOR], &minimum, &maximum)) { properties->vendor = value; } else { logMessage(LOG_WARNING, "invalid keyboard vendor code: %s", parameters[KBD_PARM_VENDOR]); ok = 0; } } if (*parameters[KBD_PARM_PRODUCT]) { static const int minimum = 0; static const int maximum = 0XFFFF; int value; if (validateInteger(&value, parameters[KBD_PARM_PRODUCT], &minimum, &maximum)) { properties->product = value; } else { logMessage(LOG_WARNING, "invalid keyboard product code: %s", parameters[KBD_PARM_PRODUCT]); ok = 0; } } deallocateStrings(parameters); return ok; }
int parseTuneVolume (const char *setting) { if (setting && *setting) { static const int minimum = 0; static const int maximum = 100; int volume; if (!validateInteger(&volume, setting, &minimum, &maximum)) { logMessage(LOG_ERR, "%s: %s", "invalid volume percentage", setting); return 0; } switch (prefs.tuneDevice) { case tdPcm: prefs.pcmVolume = volume; break; case tdMidi: prefs.midiVolume = volume; break; case tdFm: prefs.fmVolume = volume; break; default: break; } } return 1; }
static int spk_construct (volatile SpeechSynthesizer *spk, char **parameters) { spk->setVolume = spk_setVolume; spk->setRate = spk_setRate; spk->setPitch = spk_setPitch; spk->setPunctuation = spk_setPunctuation; clearSettings(); if (parameters[PARM_PORT] && *parameters[PARM_PORT]) { static const int minimumPort = 0X1; static const int maximumPort = 0XFFFF; int port = 0; if (validateInteger(&port, parameters[PARM_PORT], &minimumPort, &maximumPort)) { char number[0X10]; snprintf(number, sizeof(number), "%d", port); setenv("SPEECHD_PORT", number, 1); } else { logMessage(LOG_WARNING, "%s: %s", "invalid port number", parameters[PARM_PORT]); } } if (parameters[PARM_MODULE] && *parameters[PARM_MODULE]) { moduleName = parameters[PARM_MODULE]; } if (parameters[PARM_LANGUAGE] && *parameters[PARM_LANGUAGE]) { languageName = parameters[PARM_LANGUAGE]; } if (parameters[PARM_VOICE] && *parameters[PARM_VOICE]) { static const SPDVoiceType voices[] = { SPD_MALE1, SPD_FEMALE1, SPD_MALE2, SPD_FEMALE2, SPD_MALE3, SPD_FEMALE3, SPD_CHILD_MALE, SPD_CHILD_FEMALE }; static const char *choices[] = { "male1", "female1", "male2", "female2", "male3", "female3", "child_male", "child_female", NULL }; unsigned int choice = 0; if (validateChoice(&choice, parameters[PARM_VOICE], choices)) { voiceType = voices[choice]; } else { logMessage(LOG_WARNING, "%s: %s", "invalid voice type", parameters[PARM_VOICE]); } } return openConnection(); }
static int spk_construct (volatile SpeechSynthesizer *spk, char **parameters) { int code; spk->setVolume = spk_setVolume; spk->setRate = spk_setRate; loadSynthesisLibrary(); if ((speechQueue = newQueue(deallocateSpeechItem, NULL))) { if (mpChannelInitEx) { if (!(code = mpChannelInitEx(&speechChannel, NULL, NULL, NULL))) { memset(&speechParameters, 0, sizeof(speechParameters)); speechParameters.nWriteWavHeader = 0; speechParameters.pfnWrite = writeSound; speechParameters.pWriteData = NULL; { const char *name = parameters[PARM_NAME]; if (name && *name) { char tag[0X100]; snprintf(tag, sizeof(tag), "<voice name=\"%s\"/>", name); enqueueTag(tag); } } { const char *pitch = parameters[PARM_PITCH]; if (pitch && *pitch) { int setting = 0; static const int minimum = -10; static const int maximum = 10; if (validateInteger(&setting, pitch, &minimum, &maximum)) { char tag[0X100]; snprintf(tag, sizeof(tag), "<pitch absmiddle=\"%d\"/>", setting); enqueueTag(tag); } else { logMessage(LOG_WARNING, "%s: %s", "invalid pitch specification", pitch); } } } return 1; } else { logSynthesisError(code, "channel initialization"); } } } else { logMessage(LOG_ERR, "Cannot allocate speech queue."); } spk_destruct(spk); return 0; }
END_OPTION_TABLE static int setRegion ( int *offsetValue, const char *offsetOption, const char *offsetName, int *sizeValue, const char *sizeOption, int sizeLimit, const char *sizeName ) { if (*offsetOption) { { const int minimum = 0; const int maximum = sizeLimit - 1; if (!validateInteger(offsetValue, offsetOption, &minimum, &maximum)) { logMessage(LOG_ERR, "invalid %s: %s", offsetName, offsetOption); return 0; } } if (*sizeOption) { const int minimum = 1; const int maximum = sizeLimit - *offsetValue; if (!validateInteger(sizeValue, sizeOption, &minimum, &maximum)) { logMessage(LOG_ERR, "invalid %s: %s", sizeName, sizeOption); return 0; } return 1; } } else if (*sizeOption) { const int minimum = 1; const int maximum = sizeLimit; if (!validateInteger(sizeValue, sizeOption, &minimum, &maximum)) { logMessage(LOG_ERR, "invalid %s: %s", sizeName, sizeOption); return 0; } *offsetValue = (sizeLimit - *sizeValue) / 2; return 1; } else { *offsetValue = sizeLimit / 4; } if ((*sizeValue = sizeLimit - (*offsetValue * 2)) < 1) *sizeValue = 1; return 1; }
/*! \fn validateData \return boolean - true, everything validated OK, false otherwise Validates data in this container. */ bool NmApiMailboxSettingsDataPrivate::validateData() const { NM_FUNCTION; QHash<int, QVariant>::const_iterator i = mSettings->constBegin(); while (i != mSettings->constEnd()) { bool validated = false; bool valid = false; int key = i.key(); QVariant val = i.value(); ++i; valid = validateString(key ,val, validated); if (validated) { if (!valid){ return valid; } continue; } valid = validateInteger(key ,val, validated); if (validated) { if (!valid){ return valid; } continue; } valid = validateBool(key ,val, validated); if (validated) { if (!valid){ return valid; } continue; } valid = validateDateTime(key ,val, validated); if (validated) { if (!valid){ return valid; } continue; } } return true; }
static int brl_construct (BrailleDisplay *brl, char **parameters, const char *device) { unsigned int ttyBaud = 9600; char *ttyType = "vt100"; int windowLines = 1; int windowColumns = 40; #ifdef HAVE_ICONV_H const char *characterSet = getLocaleCharset(); #endif /* HAVE_ICONV_H */ if (!isSerialDevice(&device)) { unsupportedDevice(device); return 0; } { unsigned int baud = ttyBaud; if (serialValidateBaud(&baud, "TTY baud", parameters[PARM_BAUD], NULL)) ttyBaud = baud; } #ifdef USE_CURSES if (*parameters[PARM_TERM]) ttyType = parameters[PARM_TERM]; #endif /* USE_CURSES */ { static const int minimum = 1; static const int maximum = MAX_WINDOW_LINES; int lines = windowLines; if (validateInteger(&lines, parameters[PARM_LINES], &minimum, &maximum)) { windowLines = lines; } else { logMessage(LOG_WARNING, "%s: %s", "invalid line count", parameters[PARM_LINES]); } } { static const int minimum = 1; static const int maximum = MAX_WINDOW_COLUMNS; int columns = windowColumns; if (validateInteger(&columns, parameters[PARM_COLUMNS], &minimum, &maximum)) { windowColumns = columns; } else { logMessage(LOG_WARNING, "%s: %s", "invalid column count", parameters[PARM_COLUMNS]); } } #ifdef HAVE_ICONV_H if (*parameters[PARM_CHARSET]) characterSet = parameters[PARM_CHARSET]; #endif /* HAVE_ICONV_H */ if (*parameters[PARM_LOCALE]) classificationLocale = parameters[PARM_LOCALE]; #ifdef HAVE_ICONV_H if ((conversionDescriptor = iconv_open(characterSet, "WCHAR_T")) != (iconv_t)-1) { #endif /* HAVE_ICONV_H */ if ((ttyDevice = serialOpenDevice(device))) { if (serialRestartDevice(ttyDevice, ttyBaud)) { #ifdef USE_CURSES if ((ttyStream = serialGetStream(ttyDevice))) { if ((ttyScreen = newterm(ttyType, ttyStream, ttyStream))) { cbreak(); noecho(); nonl(); nodelay(stdscr, TRUE); intrflush(stdscr, FALSE); keypad(stdscr, TRUE); clear(); refresh(); #endif /* USE_CURSES */ brl->textColumns = windowColumns; brl->textRows = windowLines; logMessage(LOG_INFO, "TTY: type=%s baud=%u size=%dx%d", ttyType, ttyBaud, windowColumns, windowLines); return 1; #ifdef USE_CURSES } else { logSystemError("newterm"); } ttyStream = NULL; } #endif /* USE_CURSES */ } serialCloseDevice(ttyDevice); ttyDevice = NULL; } #ifdef HAVE_ICONV_H iconv_close(conversionDescriptor); } else { logSystemError("iconv_open"); } conversionDescriptor = NULL; #endif /* HAVE_ICONV_H */ return 0; }
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; }
static int spk_construct (volatile SpeechSynthesizer *spk, char **parameters) { theta_voice_search criteria; memset(&criteria, 0, sizeof(criteria)); initializeTheta(); spk->setVolume = spk_setVolume; spk->setRate = spk_setRate; if (*parameters[PARM_GENDER]) { const char *const choices[] = {"male", "female", "neuter", NULL}; unsigned int choice; if (validateChoice(&choice, parameters[PARM_GENDER], choices)) { criteria.gender = (char *)choices[choice]; } else { logMessage(LOG_WARNING, "%s: %s", "invalid gender specification", parameters[PARM_GENDER]); } } if (*parameters[PARM_LANGUAGE]) criteria.lang = parameters[PARM_LANGUAGE]; if (*parameters[PARM_AGE]) { const char *word = parameters[PARM_AGE]; int value; int younger; static const int minimumAge = 1; static const int maximumAge = 99; if ((younger = word[0] == '-') && word[1]) ++word; if (validateInteger(&value, word, &minimumAge, &maximumAge)) { if (younger) value = -value; criteria.age = value; } else { logMessage(LOG_WARNING, "%s: %s", "invalid age specification", word); } } { const char *name = parameters[PARM_NAME]; if (name && (*name == '/')) { theta_voice_desc *descriptor = theta_try_voxdir(name, &criteria); if (descriptor) { loadVoice(descriptor); theta_free_voice_desc(descriptor); } } else { theta_voice_desc *descriptors = theta_enum_voices(theta_voxpath, &criteria); if (descriptors) { theta_voice_desc *descriptor; for (descriptor=descriptors; descriptor; descriptor=descriptor->next) { if (*name) if (strcasecmp(name, descriptor->human) != 0) continue; loadVoice(descriptor); if (voice) break; } theta_free_voicelist(descriptors); } } } if (voice) { { float pitch = 0.0; static const float minimumPitch = -2.0; static const float maximumPitch = 2.0; if (validateFloat(&pitch, parameters[PARM_PITCH], &minimumPitch, &maximumPitch)) { theta_set_pitch_shift(voice, pitch, NULL); } else { logMessage(LOG_WARNING, "%s: %s", "invalid pitch shift specification", parameters[PARM_PITCH]); } } logMessage(LOG_INFO, "Theta Engine: version %s", theta_version); return 1; } logMessage(LOG_WARNING, "No voices found."); return 0; }
/* the braille display can be resized without reloading the driver */ static int brl_construct(BrailleDisplay *brl, char **parameters, const char *device) { #ifdef SendIdReq unsigned char ch = '?'; int i; #endif /* SendIdReq */ int ds = BRAILLEDISPLAYSIZE; int promVersion = 4; unsigned int ttyBaud = 57600; if (*parameters[PARM_DISPSIZE]) { int dsmin=20, dsmax=40; if (!validateInteger(&ds, parameters[PARM_DISPSIZE], &dsmin, &dsmax)) logMessage(LOG_WARNING, "%s: %s", "invalid braille display size", parameters[PARM_DISPSIZE]); } if (*parameters[PARM_PROMVER]) { int pvmin=3, pvmax=6; if (!validateInteger(&promVersion, parameters[PARM_PROMVER], &pvmin, &pvmax)) logMessage(LOG_WARNING, "%s: %s", "invalid PROM version", parameters[PARM_PROMVER]); } if (*parameters[PARM_BAUD]) { unsigned int baud; if (serialValidateBaud(&baud, "TTY baud", parameters[PARM_BAUD], NULL)) { ttyBaud = baud; } } if (!isSerialDeviceIdentifier(&device)) { unsupportedDeviceIdentifier(device); return 0; } if (!(serialDevice = serialOpenDevice(device))) return 0; serialSetParity(serialDevice, SERIAL_PARITY_ODD); if (promVersion<4) serialSetFlowControl(serialDevice, SERIAL_FLOW_INPUT_CTS); serialRestartDevice(serialDevice,ttyBaud); #ifdef SendIdReq { brl_writePacket(brl,(unsigned char *) &ch,1); i=5; while (i>0) { if (brl_readPacket(brl,(unsigned char *) &terminfo,sizeof(terminfo))!=0) { if (terminfo.code=='?') { terminfo.f2[10] = '\0'; break; } } i--; } if (i==0) { logMessage(LOG_WARNING,"Unable to identify terminal properly"); if (!brl->textColumns) brl->textColumns = BRAILLEDISPLAYSIZE; } else { logMessage(LOG_INFO,"Braille terminal description:"); logMessage(LOG_INFO," version=%c%c%c",terminfo.version[0],terminfo.version[1],terminfo.version[2]); logMessage(LOG_INFO," f1=%c",terminfo.f1); logMessage(LOG_INFO," size=%c%c",terminfo.size[0],terminfo.size[1]); logMessage(LOG_INFO," dongle=%c",terminfo.dongle); logMessage(LOG_INFO," clock=%c",terminfo.clock); logMessage(LOG_INFO," routing=%c",terminfo.routing); logMessage(LOG_INFO," flash=%c",terminfo.flash); logMessage(LOG_INFO," prog=%c",terminfo.prog); logMessage(LOG_INFO," lcd=%c",terminfo.lcd); logMessage(LOG_INFO," f2=%s",terminfo.f2); if (brl->textColumns<=0) brl->textColumns = (terminfo.size[0]-'0')*10 + (terminfo.size[1]-'0'); } } #else /* SendIdReq */ brl->textColumns = ds; #endif /* SendIdReq */ brl->textRows=1; { /* The following table defines how internal brltty format is converted to */ /* VisioBraille format. */ /* The table is declared static so that it is in data segment and not */ /* in the stack */ static const TranslationTable outputTable = { #include "brl-out.h" }; setOutputTable(outputTable); } return 1; }