/drivers/staging/speakup/varhandlers.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C · 404 lines · 376 code · 23 blank · 5 comment · 144 complexity · 2521827b48ec98ee1c3135a693541903 MD5 · raw file

  1. #include <linux/ctype.h>
  2. #include "spk_types.h"
  3. #include "spk_priv.h"
  4. #include "speakup.h"
  5. static struct st_var_header var_headers[] = {
  6. { "version", VERSION, VAR_PROC, NULL, NULL },
  7. { "synth_name", SYNTH, VAR_PROC, NULL, NULL },
  8. { "keymap", KEYMAP, VAR_PROC, NULL, NULL },
  9. { "silent", SILENT, VAR_PROC, NULL, NULL },
  10. { "punc_some", PUNC_SOME, VAR_PROC, NULL, NULL },
  11. { "punc_most", PUNC_MOST, VAR_PROC, NULL, NULL },
  12. { "punc_all", PUNC_ALL, VAR_PROC, NULL, NULL },
  13. { "delimiters", DELIM, VAR_PROC, NULL, NULL },
  14. { "repeats", REPEATS, VAR_PROC, NULL, NULL },
  15. { "ex_num", EXNUMBER, VAR_PROC, NULL, NULL },
  16. { "characters", CHARS, VAR_PROC, NULL, NULL },
  17. { "synth_direct", SYNTH_DIRECT, VAR_PROC, NULL, NULL },
  18. { "caps_start", CAPS_START, VAR_STRING, str_caps_start, NULL },
  19. { "caps_stop", CAPS_STOP, VAR_STRING, str_caps_stop, NULL },
  20. { "delay_time", DELAY, VAR_TIME, NULL, NULL },
  21. { "trigger_time", TRIGGER, VAR_TIME, NULL, NULL },
  22. { "jiffy_delta", JIFFY, VAR_TIME, NULL, NULL },
  23. { "full_time", FULL, VAR_TIME, NULL, NULL },
  24. { "spell_delay", SPELL_DELAY, VAR_NUM, &spell_delay, NULL },
  25. { "bleeps", BLEEPS, VAR_NUM, &bleeps, NULL },
  26. { "attrib_bleep", ATTRIB_BLEEP, VAR_NUM, &attrib_bleep, NULL },
  27. { "bleep_time", BLEEP_TIME, VAR_TIME, &bleep_time, NULL },
  28. { "cursor_time", CURSOR_TIME, VAR_TIME, NULL, NULL },
  29. { "punc_level", PUNC_LEVEL, VAR_NUM, &punc_level, NULL },
  30. { "reading_punc", READING_PUNC, VAR_NUM, &reading_punc, NULL },
  31. { "say_control", SAY_CONTROL, VAR_NUM, &say_ctrl, NULL },
  32. { "say_word_ctl", SAY_WORD_CTL, VAR_NUM, &say_word_ctl, NULL },
  33. { "no_interrupt", NO_INTERRUPT, VAR_NUM, &no_intr, NULL },
  34. { "key_echo", KEY_ECHO, VAR_NUM, &key_echo, NULL },
  35. { "bell_pos", BELL_POS, VAR_NUM, &bell_pos, NULL },
  36. { "rate", RATE, VAR_NUM, NULL, NULL },
  37. { "pitch", PITCH, VAR_NUM, NULL, NULL },
  38. { "vol", VOL, VAR_NUM, NULL, NULL },
  39. { "tone", TONE, VAR_NUM, NULL, NULL },
  40. { "punct", PUNCT, VAR_NUM, NULL, NULL },
  41. { "voice", VOICE, VAR_NUM, NULL, NULL },
  42. { "freq", FREQUENCY, VAR_NUM, NULL, NULL },
  43. { "lang", LANG, VAR_NUM, NULL, NULL },
  44. { "chartab", CHARTAB, VAR_PROC, NULL, NULL },
  45. { "direct", DIRECT, VAR_NUM, NULL, NULL },
  46. };
  47. static struct st_var_header *var_ptrs[MAXVARS] = { 0, 0, 0 };
  48. static struct punc_var_t punc_vars[] = {
  49. { PUNC_SOME, 1 },
  50. { PUNC_MOST, 2 },
  51. { PUNC_ALL, 3 },
  52. { DELIM, 4 },
  53. { REPEATS, 5 },
  54. { EXNUMBER, 6 },
  55. { -1, -1 },
  56. };
  57. int chartab_get_value(char *keyword)
  58. {
  59. int value = 0;
  60. if (!strcmp(keyword, "ALPHA"))
  61. value = ALPHA;
  62. else if (!strcmp(keyword, "B_CTL"))
  63. value = B_CTL;
  64. else if (!strcmp(keyword, "WDLM"))
  65. value = WDLM;
  66. else if (!strcmp(keyword, "A_PUNC"))
  67. value = A_PUNC;
  68. else if (!strcmp(keyword, "PUNC"))
  69. value = PUNC;
  70. else if (!strcmp(keyword, "NUM"))
  71. value = NUM;
  72. else if (!strcmp(keyword, "A_CAP"))
  73. value = A_CAP;
  74. else if (!strcmp(keyword, "B_CAPSYM"))
  75. value = B_CAPSYM;
  76. else if (!strcmp(keyword, "B_SYM"))
  77. value = B_SYM;
  78. return value;
  79. }
  80. void speakup_register_var(struct var_t *var)
  81. {
  82. static char nothing[2] = "\0";
  83. int i;
  84. struct st_var_header *p_header;
  85. BUG_ON(!var || var->var_id < 0 || var->var_id >= MAXVARS);
  86. if (var_ptrs[0] == NULL) {
  87. for (i = 0; i < MAXVARS; i++) {
  88. p_header = &var_headers[i];
  89. var_ptrs[p_header->var_id] = p_header;
  90. p_header->data = NULL;
  91. }
  92. }
  93. p_header = var_ptrs[var->var_id];
  94. if (p_header->data != NULL)
  95. return;
  96. p_header->data = var;
  97. switch (p_header->var_type) {
  98. case VAR_STRING:
  99. set_string_var(nothing, p_header, 0);
  100. break;
  101. case VAR_NUM:
  102. case VAR_TIME:
  103. set_num_var(0, p_header, E_DEFAULT);
  104. break;
  105. default:
  106. break;
  107. }
  108. return;
  109. }
  110. void speakup_unregister_var(enum var_id_t var_id)
  111. {
  112. struct st_var_header *p_header;
  113. BUG_ON(var_id < 0 || var_id >= MAXVARS);
  114. p_header = var_ptrs[var_id];
  115. p_header->data = NULL;
  116. }
  117. struct st_var_header *get_var_header(enum var_id_t var_id)
  118. {
  119. struct st_var_header *p_header;
  120. if (var_id < 0 || var_id >= MAXVARS)
  121. return NULL;
  122. p_header = var_ptrs[var_id];
  123. if (p_header->data == NULL)
  124. return NULL;
  125. return p_header;
  126. }
  127. struct st_var_header *var_header_by_name(const char *name)
  128. {
  129. int i;
  130. struct st_var_header *where = NULL;
  131. if (name != NULL) {
  132. i = 0;
  133. while ((i < MAXVARS) && (where == NULL)) {
  134. if (strcmp(name, var_ptrs[i]->name) == 0)
  135. where = var_ptrs[i];
  136. else
  137. i++;
  138. }
  139. }
  140. return where;
  141. }
  142. struct var_t *get_var(enum var_id_t var_id)
  143. {
  144. BUG_ON(var_id < 0 || var_id >= MAXVARS);
  145. BUG_ON(!var_ptrs[var_id]);
  146. return var_ptrs[var_id]->data;
  147. }
  148. EXPORT_SYMBOL_GPL(get_var);
  149. struct punc_var_t *get_punc_var(enum var_id_t var_id)
  150. {
  151. struct punc_var_t *rv = NULL;
  152. struct punc_var_t *where;
  153. where = punc_vars;
  154. while ((where->var_id != -1) && (rv == NULL)) {
  155. if (where->var_id == var_id)
  156. rv = where;
  157. else
  158. where++;
  159. }
  160. return rv;
  161. }
  162. /* handlers for setting vars */
  163. int set_num_var(int input, struct st_var_header *var, int how)
  164. {
  165. int val;
  166. short ret = 0;
  167. int *p_val = var->p_val;
  168. int l;
  169. char buf[32];
  170. char *cp;
  171. struct var_t *var_data = var->data;
  172. if (var_data == NULL)
  173. return E_UNDEF;
  174. if (how == E_NEW_DEFAULT) {
  175. if (input < var_data->u.n.low || input > var_data->u.n.high)
  176. ret = E_RANGE;
  177. else
  178. var_data->u.n.default_val = input;
  179. return ret;
  180. }
  181. if (how == E_DEFAULT) {
  182. val = var_data->u.n.default_val;
  183. ret = SET_DEFAULT;
  184. } else {
  185. if (how == E_SET)
  186. val = input;
  187. else
  188. val = var_data->u.n.value;
  189. if (how == E_INC)
  190. val += input;
  191. else if (how == E_DEC)
  192. val -= input;
  193. if (val < var_data->u.n.low || val > var_data->u.n.high)
  194. return E_RANGE;
  195. }
  196. var_data->u.n.value = val;
  197. if (var->var_type == VAR_TIME && p_val != NULL) {
  198. *p_val = msecs_to_jiffies(val);
  199. return ret;
  200. }
  201. if (p_val != NULL)
  202. *p_val = val;
  203. if (var->var_id == PUNC_LEVEL) {
  204. punc_mask = punc_masks[val];
  205. return ret;
  206. }
  207. if (var_data->u.n.multiplier != 0)
  208. val *= var_data->u.n.multiplier;
  209. val += var_data->u.n.offset;
  210. if (var->var_id < FIRST_SYNTH_VAR || synth == NULL)
  211. return ret;
  212. if (synth->synth_adjust != NULL) {
  213. int status = synth->synth_adjust(var);
  214. return (status != 0) ? status : ret;
  215. }
  216. if (!var_data->u.n.synth_fmt)
  217. return ret;
  218. if (var->var_id == PITCH)
  219. cp = pitch_buff;
  220. else
  221. cp = buf;
  222. if (!var_data->u.n.out_str)
  223. l = sprintf(cp, var_data->u.n.synth_fmt, (int)val);
  224. else
  225. l = sprintf(cp,
  226. var_data->u.n.synth_fmt, var_data->u.n.out_str[val]);
  227. synth_printf("%s", cp);
  228. return ret;
  229. }
  230. int set_string_var(const char *page, struct st_var_header *var, int len)
  231. {
  232. int ret = 0;
  233. struct var_t *var_data = var->data;
  234. if (var_data == NULL)
  235. return E_UNDEF;
  236. if (len > MAXVARLEN)
  237. return -E_TOOLONG;
  238. if (!len) {
  239. if (!var_data->u.s.default_val)
  240. return 0;
  241. ret = SET_DEFAULT;
  242. if (!var->p_val)
  243. var->p_val = var_data->u.s.default_val;
  244. if (var->p_val != var_data->u.s.default_val)
  245. strcpy((char *)var->p_val, var_data->u.s.default_val);
  246. } else if (var->p_val)
  247. strcpy((char *)var->p_val, page);
  248. else
  249. return -E_TOOLONG;
  250. return ret;
  251. }
  252. /* set_mask_bits sets or clears the punc/delim/repeat bits,
  253. * if input is null uses the defaults.
  254. * values for how: 0 clears bits of chars supplied,
  255. * 1 clears allk, 2 sets bits for chars */
  256. int set_mask_bits(const char *input, const int which, const int how)
  257. {
  258. u_char *cp;
  259. short mask = punc_info[which].mask;
  260. if (how&1) {
  261. for (cp = (u_char *)punc_info[3].value; *cp; cp++)
  262. spk_chartab[*cp] &= ~mask;
  263. }
  264. cp = (u_char *)input;
  265. if (cp == 0)
  266. cp = punc_info[which].value;
  267. else {
  268. for ( ; *cp; cp++) {
  269. if (*cp < SPACE)
  270. break;
  271. if (mask < PUNC) {
  272. if (!(spk_chartab[*cp]&PUNC))
  273. break;
  274. } else if (spk_chartab[*cp]&B_NUM)
  275. break;
  276. }
  277. if (*cp)
  278. return -EINVAL;
  279. cp = (u_char *)input;
  280. }
  281. if (how&2) {
  282. for ( ; *cp; cp++)
  283. if (*cp > SPACE)
  284. spk_chartab[*cp] |= mask;
  285. } else {
  286. for ( ; *cp; cp++)
  287. if (*cp > SPACE)
  288. spk_chartab[*cp] &= ~mask;
  289. }
  290. return 0;
  291. }
  292. char *strlwr(char *s)
  293. {
  294. char *p;
  295. if (s == NULL)
  296. return NULL;
  297. for (p = s; *p; p++)
  298. *p = tolower(*p);
  299. return s;
  300. }
  301. char *speakup_s2i(char *start, int *dest)
  302. {
  303. int val;
  304. char ch = *start;
  305. if (ch == '-' || ch == '+')
  306. start++;
  307. if (*start < '0' || *start > '9')
  308. return start;
  309. val = (*start) - '0';
  310. start++;
  311. while (*start >= '0' && *start <= '9') {
  312. val *= 10;
  313. val += (*start) - '0';
  314. start++;
  315. }
  316. if (ch == '-')
  317. *dest = -val;
  318. else
  319. *dest = val;
  320. return start;
  321. }
  322. char *s2uchar(char *start, char *dest)
  323. {
  324. int val = 0;
  325. while (*start && *start <= SPACE)
  326. start++;
  327. while (*start >= '0' && *start <= '9') {
  328. val *= 10;
  329. val += (*start) - '0';
  330. start++;
  331. }
  332. if (*start == ',')
  333. start++;
  334. *dest = (u_char)val;
  335. return start;
  336. }
  337. char *xlate(char *s)
  338. {
  339. static const char finds[] = "nrtvafe";
  340. static const char subs[] = "\n\r\t\013\001\014\033";
  341. static const char hx[] = "0123456789abcdefABCDEF";
  342. char *p = s, *p1, *p2, c;
  343. int num;
  344. while ((p = strchr(p, '\\'))) {
  345. p1 = p+1;
  346. p2 = strchr(finds, *p1);
  347. if (p2) {
  348. *p++ = subs[p2-finds];
  349. p1++;
  350. } else if (*p1 >= '0' && *p1 <= '7') {
  351. num = (*p1++)&7;
  352. while (num < 256 && *p1 >= '0' && *p1 <= '7') {
  353. num <<= 3;
  354. num = (*p1++)&7;
  355. }
  356. *p++ = num;
  357. } else if (*p1 == 'x' &&
  358. strchr(hx, p1[1]) && strchr(hx, p1[2])) {
  359. p1++;
  360. c = *p1++;
  361. if (c > '9')
  362. c = (c - '7') & 0x0f;
  363. else
  364. c -= '0';
  365. num = c << 4;
  366. c = *p1++;
  367. if (c > '9')
  368. c = (c-'7')&0x0f;
  369. else
  370. c -= '0';
  371. num += c;
  372. *p++ = num;
  373. } else
  374. *p++ = *p1++;
  375. p2 = p;
  376. while (*p1)
  377. *p2++ = *p1++;
  378. *p2 = '\0';
  379. }
  380. return s;
  381. }