staging: speakup: Prefix externally-visible symbols
This prefixes all externally-visible symbols of speakup with "spk_". Signed-off-by: Samuel Thibault <samuel.thibault@ens-lyon.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Samuel Thibault
Greg Kroah-Hartman
parent
a129be84ba
commit
ca2beaf84d
|
|
@ -390,7 +390,7 @@ static struct msg_group_t all_groups[] = {
|
|||
|
||||
static const int num_groups = sizeof(all_groups) / sizeof(struct msg_group_t);
|
||||
|
||||
char *msg_get(enum msg_index_t index)
|
||||
char *spk_msg_get(enum msg_index_t index)
|
||||
{
|
||||
char *ch;
|
||||
|
||||
|
|
@ -540,7 +540,7 @@ static int fmt_validate(char *template, char *user)
|
|||
* -EINVAL - Invalid format specifiers in formatted message or illegal index.
|
||||
* -ENOMEM - Unable to allocate memory.
|
||||
*/
|
||||
ssize_t msg_set(enum msg_index_t index, char *text, size_t length)
|
||||
ssize_t spk_msg_set(enum msg_index_t index, char *text, size_t length)
|
||||
{
|
||||
int rc = 0;
|
||||
char *newstr = NULL;
|
||||
|
|
@ -576,7 +576,7 @@ ssize_t msg_set(enum msg_index_t index, char *text, size_t length)
|
|||
* Find a message group, given its name. Return a pointer to the structure
|
||||
* if found, or NULL otherwise.
|
||||
*/
|
||||
struct msg_group_t *find_msg_group(const char *group_name)
|
||||
struct msg_group_t *spk_find_msg_group(const char *group_name)
|
||||
{
|
||||
struct msg_group_t *group = NULL;
|
||||
int i;
|
||||
|
|
@ -590,7 +590,7 @@ struct msg_group_t *find_msg_group(const char *group_name)
|
|||
return group;
|
||||
}
|
||||
|
||||
void reset_msg_group(struct msg_group_t *group)
|
||||
void spk_reset_msg_group(struct msg_group_t *group)
|
||||
{
|
||||
unsigned long flags;
|
||||
enum msg_index_t i;
|
||||
|
|
@ -606,14 +606,14 @@ void reset_msg_group(struct msg_group_t *group)
|
|||
}
|
||||
|
||||
/* Called at initialization time, to establish default messages. */
|
||||
void initialize_msgs(void)
|
||||
void spk_initialize_msgs(void)
|
||||
{
|
||||
memcpy(speakup_msgs, speakup_default_msgs,
|
||||
sizeof(speakup_default_msgs));
|
||||
}
|
||||
|
||||
/* Free user-supplied strings when module is unloaded: */
|
||||
void free_user_msgs(void)
|
||||
void spk_free_user_msgs(void)
|
||||
{
|
||||
enum msg_index_t index;
|
||||
unsigned long flags;
|
||||
|
|
|
|||
|
|
@ -218,11 +218,11 @@ struct msg_group_t {
|
|||
enum msg_index_t end;
|
||||
};
|
||||
|
||||
extern char *msg_get(enum msg_index_t index);
|
||||
extern ssize_t msg_set(enum msg_index_t index, char *text, size_t length);
|
||||
extern struct msg_group_t *find_msg_group(const char *group_name);
|
||||
extern void reset_msg_group(struct msg_group_t *group);
|
||||
extern void initialize_msgs(void);
|
||||
extern void free_user_msgs(void);
|
||||
extern char *spk_msg_get(enum msg_index_t index);
|
||||
extern ssize_t spk_msg_set(enum msg_index_t index, char *text, size_t length);
|
||||
extern struct msg_group_t *spk_find_msg_group(const char *group_name);
|
||||
extern void spk_reset_msg_group(struct msg_group_t *group);
|
||||
extern void spk_initialize_msgs(void);
|
||||
extern void spk_free_user_msgs(void);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -115,10 +115,10 @@ static void say_key(int key)
|
|||
key &= 0xff;
|
||||
for (i = 0; i < 6; i++) {
|
||||
if (state & masks[i])
|
||||
synth_printf(" %s", msg_get(MSG_STATES_START + i));
|
||||
synth_printf(" %s", spk_msg_get(MSG_STATES_START + i));
|
||||
}
|
||||
if ((key > 0) && (key <= num_key_names))
|
||||
synth_printf(" %s\n", msg_get(MSG_KEYNAMES_START + (key - 1)));
|
||||
synth_printf(" %s\n", spk_msg_get(MSG_KEYNAMES_START + (key - 1)));
|
||||
}
|
||||
|
||||
static int help_init(void)
|
||||
|
|
@ -126,9 +126,9 @@ static int help_init(void)
|
|||
char start = SPACE;
|
||||
int i;
|
||||
int num_funcs = MSG_FUNCNAMES_END - MSG_FUNCNAMES_START + 1;
|
||||
state_tbl = our_keys[0]+SHIFT_TBL_SIZE+2;
|
||||
state_tbl = spk_our_keys[0]+SHIFT_TBL_SIZE+2;
|
||||
for (i = 0; i < num_funcs; i++) {
|
||||
char *cur_funcname = msg_get(MSG_FUNCNAMES_START + i);
|
||||
char *cur_funcname = spk_msg_get(MSG_FUNCNAMES_START + i);
|
||||
if (start == *cur_funcname)
|
||||
continue;
|
||||
start = *cur_funcname;
|
||||
|
|
@ -137,7 +137,7 @@ state_tbl = our_keys[0]+SHIFT_TBL_SIZE+2;
|
|||
return 0;
|
||||
}
|
||||
|
||||
int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
||||
int spk_handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
||||
{
|
||||
int i, n;
|
||||
char *name;
|
||||
|
|
@ -147,15 +147,15 @@ int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
|||
help_init();
|
||||
if (type == KT_LATIN) {
|
||||
if (ch == SPACE) {
|
||||
special_handler = NULL;
|
||||
synth_printf("%s\n", msg_get(MSG_LEAVING_HELP));
|
||||
spk_special_handler = NULL;
|
||||
synth_printf("%s\n", spk_msg_get(MSG_LEAVING_HELP));
|
||||
return 1;
|
||||
}
|
||||
ch |= 32; /* lower case */
|
||||
if (ch < 'a' || ch > 'z')
|
||||
return -1;
|
||||
if (letter_offsets[ch-'a'] == -1) {
|
||||
synth_printf(msg_get(MSG_NO_COMMAND), ch);
|
||||
synth_printf(spk_msg_get(MSG_NO_COMMAND), ch);
|
||||
synth_printf("\n");
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -169,47 +169,47 @@ int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
|||
cur_item--;
|
||||
else
|
||||
return -1;
|
||||
} else if (type == KT_SPKUP && ch == SPEAKUP_HELP && !special_handler) {
|
||||
special_handler = handle_help;
|
||||
synth_printf("%s\n", msg_get(MSG_HELP_INFO));
|
||||
} else if (type == KT_SPKUP && ch == SPEAKUP_HELP && !spk_special_handler) {
|
||||
spk_special_handler = spk_handle_help;
|
||||
synth_printf("%s\n", spk_msg_get(MSG_HELP_INFO));
|
||||
build_key_data(); /* rebuild each time in case new mapping */
|
||||
return 1;
|
||||
} else {
|
||||
name = NULL;
|
||||
if ((type != KT_SPKUP) && (key > 0) && (key <= num_key_names)) {
|
||||
synth_printf("%s\n",
|
||||
msg_get(MSG_KEYNAMES_START + key-1));
|
||||
spk_msg_get(MSG_KEYNAMES_START + key-1));
|
||||
return 1;
|
||||
}
|
||||
for (i = 0; funcvals[i] != 0 && !name; i++) {
|
||||
if (ch == funcvals[i])
|
||||
name = msg_get(MSG_FUNCNAMES_START + i);
|
||||
name = spk_msg_get(MSG_FUNCNAMES_START + i);
|
||||
}
|
||||
if (!name)
|
||||
return -1;
|
||||
kp = our_keys[key]+1;
|
||||
kp = spk_our_keys[key]+1;
|
||||
for (i = 0; i < nstates; i++) {
|
||||
if (ch == kp[i])
|
||||
break;
|
||||
}
|
||||
key += (state_tbl[i] << 8);
|
||||
say_key(key);
|
||||
synth_printf(msg_get(MSG_KEYDESC), name);
|
||||
synth_printf(spk_msg_get(MSG_KEYDESC), name);
|
||||
synth_printf("\n");
|
||||
return 1;
|
||||
}
|
||||
name = msg_get(MSG_FUNCNAMES_START + cur_item);
|
||||
name = spk_msg_get(MSG_FUNCNAMES_START + cur_item);
|
||||
func = funcvals[cur_item];
|
||||
synth_printf("%s", name);
|
||||
if (key_offsets[func] == 0) {
|
||||
synth_printf(" %s\n", msg_get(MSG_IS_UNASSIGNED));
|
||||
synth_printf(" %s\n", spk_msg_get(MSG_IS_UNASSIGNED));
|
||||
return 1;
|
||||
}
|
||||
p_keys = key_data + key_offsets[func];
|
||||
for (n = 0; p_keys[n]; n++) {
|
||||
val = p_keys[n];
|
||||
if (n > 0)
|
||||
synth_printf("%s ", msg_get(MSG_DISJUNCTION));
|
||||
synth_printf("%s ", spk_msg_get(MSG_DISJUNCTION));
|
||||
say_key(val);
|
||||
}
|
||||
return 1;
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ static ssize_t chars_chartab_show(struct kobject *kobj,
|
|||
break;
|
||||
if (strcmp("characters", attr->attr.name) == 0) {
|
||||
len = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
|
||||
i, characters[i]);
|
||||
i, spk_characters[i]);
|
||||
} else { /* show chartab entry */
|
||||
if (IS_TYPE(i, B_CTL))
|
||||
cp = "B_CTL";
|
||||
|
|
@ -185,12 +185,12 @@ static ssize_t chars_chartab_store(struct kobject *kobj,
|
|||
outptr[desc_length] = '\0';
|
||||
|
||||
if (do_characters) {
|
||||
if (characters[index] != default_chars[index])
|
||||
kfree(characters[index]);
|
||||
characters[index] = desc;
|
||||
if (spk_characters[index] != spk_default_chars[index])
|
||||
kfree(spk_characters[index]);
|
||||
spk_characters[index] = desc;
|
||||
used++;
|
||||
} else {
|
||||
charclass = chartab_get_value(keyword);
|
||||
charclass = spk_chartab_get_value(keyword);
|
||||
if (charclass == 0) {
|
||||
rejected++;
|
||||
cp = linefeed + 1;
|
||||
|
|
@ -206,9 +206,9 @@ static ssize_t chars_chartab_store(struct kobject *kobj,
|
|||
|
||||
if (reset) {
|
||||
if (do_characters)
|
||||
reset_default_chars();
|
||||
spk_reset_default_chars();
|
||||
else
|
||||
reset_default_chartab();
|
||||
spk_reset_default_chartab();
|
||||
}
|
||||
|
||||
spk_unlock(flags);
|
||||
|
|
@ -232,7 +232,7 @@ static ssize_t keymap_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
u_char ch;
|
||||
unsigned long flags;
|
||||
spk_lock(flags);
|
||||
cp1 = key_buf + SHIFT_TBL_SIZE;
|
||||
cp1 = spk_key_buf + SHIFT_TBL_SIZE;
|
||||
num_keys = (int)(*cp1);
|
||||
nstates = (int)cp1[1];
|
||||
cp += sprintf(cp, "%d, %d, %d,\n", KEY_MAP_VER, num_keys, nstates);
|
||||
|
|
@ -271,7 +271,7 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
return -ENOMEM;
|
||||
}
|
||||
if (strchr("dDrR", *in_buff)) {
|
||||
set_key_info(key_defaults, key_buf);
|
||||
spk_set_key_info(spk_key_defaults, spk_key_buf);
|
||||
pr_info("keymap set to default values\n");
|
||||
kfree(in_buff);
|
||||
spk_unlock(flags);
|
||||
|
|
@ -282,14 +282,14 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
cp = in_buff;
|
||||
cp1 = (u_char *)in_buff;
|
||||
for (i = 0; i < 3; i++) {
|
||||
cp = s2uchar(cp, cp1);
|
||||
cp = spk_s2uchar(cp, cp1);
|
||||
cp1++;
|
||||
}
|
||||
i = (int)cp1[-2]+1;
|
||||
i *= (int)cp1[-1]+1;
|
||||
i += 2; /* 0 and last map ver */
|
||||
if (cp1[-3] != KEY_MAP_VER || cp1[-1] > 10 ||
|
||||
i+SHIFT_TBL_SIZE+4 >= sizeof(key_buf)) {
|
||||
i+SHIFT_TBL_SIZE+4 >= sizeof(spk_key_buf)) {
|
||||
pr_warn("i %d %d %d %d\n", i,
|
||||
(int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
|
||||
kfree(in_buff);
|
||||
|
|
@ -297,7 +297,7 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
return -EINVAL;
|
||||
}
|
||||
while (--i >= 0) {
|
||||
cp = s2uchar(cp, cp1);
|
||||
cp = spk_s2uchar(cp, cp1);
|
||||
cp1++;
|
||||
if (!(*cp))
|
||||
break;
|
||||
|
|
@ -307,8 +307,8 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
pr_warn("end %d %d %d %d\n", i,
|
||||
(int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
|
||||
} else {
|
||||
if (set_key_info(in_buff, key_buf)) {
|
||||
set_key_info(key_defaults, key_buf);
|
||||
if (spk_set_key_info(in_buff, spk_key_buf)) {
|
||||
spk_set_key_info(spk_key_defaults, spk_key_buf);
|
||||
ret = -EINVAL;
|
||||
pr_warn("set key failed\n");
|
||||
}
|
||||
|
|
@ -343,7 +343,7 @@ static ssize_t silent_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
spk_lock(flags);
|
||||
if (ch&2) {
|
||||
shut = 1;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
} else {
|
||||
shut = 0;
|
||||
}
|
||||
|
|
@ -388,7 +388,7 @@ static ssize_t synth_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
if (new_synth_name[len - 1] == '\n')
|
||||
len--;
|
||||
new_synth_name[len] = '\0';
|
||||
strlwr(new_synth_name);
|
||||
spk_strlwr(new_synth_name);
|
||||
if ((synth != NULL) && (!strcmp(new_synth_name, synth->name))) {
|
||||
pr_warn("%s already in use\n", new_synth_name);
|
||||
} else if (synth_init(new_synth_name) != 0) {
|
||||
|
|
@ -417,7 +417,7 @@ static ssize_t synth_direct_store(struct kobject *kobj,
|
|||
bytes = min_t(size_t, len, 250);
|
||||
strncpy(tmp, ptr, bytes);
|
||||
tmp[bytes] = '\0';
|
||||
xlate(tmp);
|
||||
spk_xlate(tmp);
|
||||
synth_printf("%s", tmp);
|
||||
ptr += bytes;
|
||||
len -= bytes;
|
||||
|
|
@ -455,14 +455,14 @@ static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
short mask;
|
||||
unsigned long flags;
|
||||
|
||||
p_header = var_header_by_name(attr->attr.name);
|
||||
p_header = spk_var_header_by_name(attr->attr.name);
|
||||
if (p_header == NULL) {
|
||||
pr_warn("p_header is null, attr->attr.name is %s\n",
|
||||
attr->attr.name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
var = get_punc_var(p_header->var_id);
|
||||
var = spk_get_punc_var(p_header->var_id);
|
||||
if (var == NULL) {
|
||||
pr_warn("var is null, p_header->var_id is %i\n",
|
||||
p_header->var_id);
|
||||
|
|
@ -470,7 +470,7 @@ static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
}
|
||||
|
||||
spk_lock(flags);
|
||||
pb = (struct st_bits_data *) &punc_info[var->value];
|
||||
pb = (struct st_bits_data *) &spk_punc_info[var->value];
|
||||
mask = pb->mask;
|
||||
for (i = 33; i < 128; i++) {
|
||||
if (!(spk_chartab[i]&mask))
|
||||
|
|
@ -497,14 +497,14 @@ static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
if (x < 1 || x > 99)
|
||||
return -EINVAL;
|
||||
|
||||
p_header = var_header_by_name(attr->attr.name);
|
||||
p_header = spk_var_header_by_name(attr->attr.name);
|
||||
if (p_header == NULL) {
|
||||
pr_warn("p_header is null, attr->attr.name is %s\n",
|
||||
attr->attr.name);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
var = get_punc_var(p_header->var_id);
|
||||
var = spk_get_punc_var(p_header->var_id);
|
||||
if (var == NULL) {
|
||||
pr_warn("var is null, p_header->var_id is %i\n",
|
||||
p_header->var_id);
|
||||
|
|
@ -520,9 +520,9 @@ static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
spk_lock(flags);
|
||||
|
||||
if (*punc_buf == 'd' || *punc_buf == 'r')
|
||||
x = set_mask_bits(0, var->value, 3);
|
||||
x = spk_set_mask_bits(0, var->value, 3);
|
||||
else
|
||||
x = set_mask_bits(punc_buf, var->value, 3);
|
||||
x = spk_set_mask_bits(punc_buf, var->value, 3);
|
||||
|
||||
spk_unlock(flags);
|
||||
return count;
|
||||
|
|
@ -542,7 +542,7 @@ ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
char ch;
|
||||
unsigned long flags;
|
||||
|
||||
param = var_header_by_name(attr->attr.name);
|
||||
param = spk_var_header_by_name(attr->attr.name);
|
||||
if (param == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
|
|
@ -599,13 +599,13 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
int value;
|
||||
unsigned long flags;
|
||||
|
||||
param = var_header_by_name(attr->attr.name);
|
||||
param = spk_var_header_by_name(attr->attr.name);
|
||||
if (param == NULL)
|
||||
return -EINVAL;
|
||||
if (param->data == NULL)
|
||||
return 0;
|
||||
ret = 0;
|
||||
cp = xlate((char *) buf);
|
||||
cp = spk_xlate((char *) buf);
|
||||
|
||||
spk_lock(flags);
|
||||
switch (param->var_type) {
|
||||
|
|
@ -618,7 +618,7 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
else
|
||||
len = E_SET;
|
||||
speakup_s2i(cp, &value);
|
||||
ret = set_num_var(value, param, len);
|
||||
ret = spk_set_num_var(value, param, len);
|
||||
if (ret == E_RANGE) {
|
||||
var_data = param->data;
|
||||
pr_warn("value for %s out of range, expect %d to %d\n",
|
||||
|
|
@ -636,7 +636,7 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
}
|
||||
cp = (char *) buf;
|
||||
cp[len] = '\0';
|
||||
ret = set_string_var(buf, param, len);
|
||||
ret = spk_set_string_var(buf, param, len);
|
||||
if (ret == E_TOOLONG)
|
||||
pr_warn("value too long for %s\n",
|
||||
attr->attr.name);
|
||||
|
|
@ -652,19 +652,19 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
*/
|
||||
if (strcmp(attr->attr.name, "voice") == 0) {
|
||||
if (synth && synth->default_pitch) {
|
||||
param = var_header_by_name("pitch");
|
||||
param = spk_var_header_by_name("pitch");
|
||||
if (param) {
|
||||
set_num_var(synth->default_pitch[value], param,
|
||||
spk_set_num_var(synth->default_pitch[value], param,
|
||||
E_NEW_DEFAULT);
|
||||
set_num_var(0, param, E_DEFAULT);
|
||||
spk_set_num_var(0, param, E_DEFAULT);
|
||||
}
|
||||
}
|
||||
if (synth && synth->default_vol) {
|
||||
param = var_header_by_name("vol");
|
||||
param = spk_var_header_by_name("vol");
|
||||
if (param) {
|
||||
set_num_var(synth->default_vol[value], param,
|
||||
spk_set_num_var(synth->default_vol[value], param,
|
||||
E_NEW_DEFAULT);
|
||||
set_num_var(0, param, E_DEFAULT);
|
||||
spk_set_num_var(0, param, E_DEFAULT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -694,7 +694,7 @@ static ssize_t message_show_helper(char *buf, enum msg_index_t first,
|
|||
if (bufsize <= 1)
|
||||
break;
|
||||
printed = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
|
||||
index, msg_get(cursor));
|
||||
index, spk_msg_get(cursor));
|
||||
buf_pointer += printed;
|
||||
bufsize -= printed;
|
||||
}
|
||||
|
|
@ -788,7 +788,7 @@ static ssize_t message_store_helper(const char *buf, size_t count,
|
|||
continue;
|
||||
}
|
||||
|
||||
msg_stored = msg_set(curmessage, temp, desc_length);
|
||||
msg_stored = spk_msg_set(curmessage, temp, desc_length);
|
||||
if (msg_stored < 0) {
|
||||
retval = msg_stored;
|
||||
if (msg_stored == -ENOMEM)
|
||||
|
|
@ -802,7 +802,7 @@ static ssize_t message_store_helper(const char *buf, size_t count,
|
|||
}
|
||||
|
||||
if (reset)
|
||||
reset_msg_group(group);
|
||||
spk_reset_msg_group(group);
|
||||
|
||||
report_msg_status(reset, received, used, rejected, group->name);
|
||||
return retval;
|
||||
|
|
@ -812,7 +812,7 @@ static ssize_t message_show(struct kobject *kobj,
|
|||
struct kobj_attribute *attr, char *buf)
|
||||
{
|
||||
ssize_t retval = 0;
|
||||
struct msg_group_t *group = find_msg_group(attr->attr.name);
|
||||
struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
|
||||
unsigned long flags;
|
||||
|
||||
BUG_ON(!group);
|
||||
|
|
@ -826,7 +826,7 @@ static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr,
|
|||
const char *buf, size_t count)
|
||||
{
|
||||
ssize_t retval = 0;
|
||||
struct msg_group_t *group = find_msg_group(attr->attr.name);
|
||||
struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
|
||||
|
||||
BUG_ON(!group);
|
||||
retval = message_store_helper(buf, count, group);
|
||||
|
|
|
|||
|
|
@ -65,23 +65,23 @@ MODULE_VERSION(SPEAKUP_VERSION);
|
|||
|
||||
char *synth_name;
|
||||
module_param_named(synth, synth_name, charp, S_IRUGO);
|
||||
module_param_named(quiet, quiet_boot, bool, S_IRUGO);
|
||||
module_param_named(quiet, spk_quiet_boot, bool, S_IRUGO);
|
||||
|
||||
MODULE_PARM_DESC(synth, "Synth to start if speakup is built in.");
|
||||
MODULE_PARM_DESC(quiet, "Do not announce when the synthesizer is found.");
|
||||
|
||||
special_func special_handler;
|
||||
special_func spk_special_handler;
|
||||
|
||||
short pitch_shift, synth_flags;
|
||||
short spk_pitch_shift, synth_flags;
|
||||
static char buf[256];
|
||||
int attrib_bleep, bleeps, bleep_time = 10;
|
||||
int no_intr, spell_delay;
|
||||
int key_echo, say_word_ctl;
|
||||
int say_ctrl, bell_pos;
|
||||
short punc_mask;
|
||||
int punc_level, reading_punc;
|
||||
char str_caps_start[MAXVARLEN + 1] = "\0", str_caps_stop[MAXVARLEN + 1] = "\0";
|
||||
const struct st_bits_data punc_info[] = {
|
||||
int spk_attrib_bleep, spk_bleeps, spk_bleep_time = 10;
|
||||
int spk_no_intr, spk_spell_delay;
|
||||
int spk_key_echo, spk_say_word_ctl;
|
||||
int spk_say_ctrl, spk_bell_pos;
|
||||
short spk_punc_mask;
|
||||
int spk_punc_level, spk_reading_punc;
|
||||
char spk_str_caps_start[MAXVARLEN + 1] = "\0", spk_str_caps_stop[MAXVARLEN + 1] = "\0";
|
||||
const struct st_bits_data spk_punc_info[] = {
|
||||
{"none", "", 0},
|
||||
{"some", "/$%&@", SOME},
|
||||
{"most", "$%&#()=+*/@^<>|\\", MOST},
|
||||
|
|
@ -95,9 +95,9 @@ const struct st_bits_data punc_info[] = {
|
|||
|
||||
static char mark_cut_flag;
|
||||
#define MAX_KEY 160
|
||||
u_char *our_keys[MAX_KEY], *shift_table;
|
||||
u_char key_buf[600];
|
||||
const u_char key_defaults[] = {
|
||||
u_char *spk_our_keys[MAX_KEY], *spk_shift_table;
|
||||
u_char spk_key_buf[600];
|
||||
const u_char spk_key_defaults[] = {
|
||||
#include "speakupmap.h"
|
||||
};
|
||||
|
||||
|
|
@ -129,9 +129,9 @@ static char *phonetic[] = {
|
|||
/* array of 256 char pointers (one for each character description)
|
||||
* initialized to default_chars and user selectable via
|
||||
* /proc/speakup/characters */
|
||||
char *characters[256];
|
||||
char *spk_characters[256];
|
||||
|
||||
char *default_chars[256] = {
|
||||
char *spk_default_chars[256] = {
|
||||
/*000*/ "null", "^a", "^b", "^c", "^d", "^e", "^f", "^g",
|
||||
/*008*/ "^h", "^i", "^j", "^k", "^l", "^m", "^n", "^o",
|
||||
/*016*/ "^p", "^q", "^r", "^s", "^t", "^u", "^v", "^w",
|
||||
|
|
@ -238,7 +238,7 @@ static u_short default_chartab[256] = {
|
|||
};
|
||||
|
||||
struct task_struct *speakup_task;
|
||||
struct bleep unprocessed_sound;
|
||||
struct bleep spk_unprocessed_sound;
|
||||
static int spk_keydown;
|
||||
static u_char spk_lastkey, spk_close_press, keymap_flags;
|
||||
static u_char last_keycode, this_speakup_key;
|
||||
|
|
@ -282,13 +282,13 @@ static void bleep(u_short val)
|
|||
350, 370, 392, 414, 440, 466, 491, 523, 554, 587, 619, 659
|
||||
};
|
||||
short freq;
|
||||
int time = bleep_time;
|
||||
int time = spk_bleep_time;
|
||||
freq = vals[val % 12];
|
||||
if (val > 11)
|
||||
freq *= (1 << (val / 12));
|
||||
unprocessed_sound.freq = freq;
|
||||
unprocessed_sound.jiffies = msecs_to_jiffies(time);
|
||||
unprocessed_sound.active = 1;
|
||||
spk_unprocessed_sound.freq = freq;
|
||||
spk_unprocessed_sound.jiffies = msecs_to_jiffies(time);
|
||||
spk_unprocessed_sound.active = 1;
|
||||
/* We can only have 1 active sound at a time. */
|
||||
}
|
||||
|
||||
|
|
@ -300,7 +300,7 @@ static void speakup_shut_up(struct vc_data *vc)
|
|||
spk_parked &= 0xfe;
|
||||
speakup_date(vc);
|
||||
if (synth != NULL)
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
}
|
||||
|
||||
static void speech_kill(struct vc_data *vc)
|
||||
|
|
@ -313,9 +313,9 @@ static void speech_kill(struct vc_data *vc)
|
|||
if (val == 2 || spk_killed) {
|
||||
/* dead */
|
||||
spk_shut_up &= ~0x40;
|
||||
synth_printf("%s\n", msg_get(MSG_IAM_ALIVE));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_IAM_ALIVE));
|
||||
} else {
|
||||
synth_printf("%s\n", msg_get(MSG_YOU_KILLED_SPEAKUP));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_YOU_KILLED_SPEAKUP));
|
||||
spk_shut_up |= 0x40;
|
||||
}
|
||||
}
|
||||
|
|
@ -324,10 +324,10 @@ static void speakup_off(struct vc_data *vc)
|
|||
{
|
||||
if (spk_shut_up & 0x80) {
|
||||
spk_shut_up &= 0x7f;
|
||||
synth_printf("%s\n", msg_get(MSG_HEY_THATS_BETTER));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_HEY_THATS_BETTER));
|
||||
} else {
|
||||
spk_shut_up |= 0x80;
|
||||
synth_printf("%s\n", msg_get(MSG_YOU_TURNED_ME_OFF));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_YOU_TURNED_ME_OFF));
|
||||
}
|
||||
speakup_date(vc);
|
||||
}
|
||||
|
|
@ -336,10 +336,10 @@ static void speakup_parked(struct vc_data *vc)
|
|||
{
|
||||
if (spk_parked & 0x80) {
|
||||
spk_parked = 0;
|
||||
synth_printf("%s\n", msg_get(MSG_UNPARKED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_UNPARKED));
|
||||
} else {
|
||||
spk_parked |= 0x80;
|
||||
synth_printf("%s\n", msg_get(MSG_PARKED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_PARKED));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -350,16 +350,16 @@ static void speakup_cut(struct vc_data *vc)
|
|||
|
||||
if (!mark_cut_flag) {
|
||||
mark_cut_flag = 1;
|
||||
xs = (u_short) spk_x;
|
||||
ys = (u_short) spk_y;
|
||||
spk_xs = (u_short) spk_x;
|
||||
spk_ys = (u_short) spk_y;
|
||||
spk_sel_cons = vc;
|
||||
synth_printf("%s\n", msg_get(MSG_MARK));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_MARK));
|
||||
return;
|
||||
}
|
||||
xe = (u_short) spk_x;
|
||||
ye = (u_short) spk_y;
|
||||
spk_xe = (u_short) spk_x;
|
||||
spk_ye = (u_short) spk_y;
|
||||
mark_cut_flag = 0;
|
||||
synth_printf("%s\n", msg_get(MSG_CUT));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_CUT));
|
||||
|
||||
speakup_clear_selection();
|
||||
ret = speakup_set_selection(tty);
|
||||
|
|
@ -383,9 +383,9 @@ static void speakup_paste(struct vc_data *vc)
|
|||
{
|
||||
if (mark_cut_flag) {
|
||||
mark_cut_flag = 0;
|
||||
synth_printf("%s\n", msg_get(MSG_MARK_CLEARED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_MARK_CLEARED));
|
||||
} else {
|
||||
synth_printf("%s\n", msg_get(MSG_PASTE));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_PASTE));
|
||||
speakup_paste_selection(tty);
|
||||
}
|
||||
}
|
||||
|
|
@ -395,16 +395,16 @@ static void say_attributes(struct vc_data *vc)
|
|||
int fg = spk_attr & 0x0f;
|
||||
int bg = spk_attr >> 4;
|
||||
if (fg > 8) {
|
||||
synth_printf("%s ", msg_get(MSG_BRIGHT));
|
||||
synth_printf("%s ", spk_msg_get(MSG_BRIGHT));
|
||||
fg -= 8;
|
||||
}
|
||||
synth_printf("%s", msg_get(MSG_COLORS_START + fg));
|
||||
synth_printf("%s", spk_msg_get(MSG_COLORS_START + fg));
|
||||
if (bg > 7) {
|
||||
synth_printf(" %s ", msg_get(MSG_ON_BLINKING));
|
||||
synth_printf(" %s ", spk_msg_get(MSG_ON_BLINKING));
|
||||
bg -= 8;
|
||||
} else
|
||||
synth_printf(" %s ", msg_get(MSG_ON));
|
||||
synth_printf("%s\n", msg_get(MSG_COLORS_START + bg));
|
||||
synth_printf(" %s ", spk_msg_get(MSG_ON));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_COLORS_START + bg));
|
||||
}
|
||||
|
||||
enum {
|
||||
|
|
@ -417,24 +417,24 @@ enum {
|
|||
|
||||
static void announce_edge(struct vc_data *vc, int msg_id)
|
||||
{
|
||||
if (bleeps & 1)
|
||||
if (spk_bleeps & 1)
|
||||
bleep(spk_y);
|
||||
if ((bleeps & 2) && (msg_id < edge_quiet))
|
||||
synth_printf("%s\n", msg_get(MSG_EDGE_MSGS_START + msg_id - 1));
|
||||
if ((spk_bleeps & 2) && (msg_id < edge_quiet))
|
||||
synth_printf("%s\n", spk_msg_get(MSG_EDGE_MSGS_START + msg_id - 1));
|
||||
}
|
||||
|
||||
static void speak_char(u_char ch)
|
||||
{
|
||||
char *cp = characters[ch];
|
||||
struct var_t *direct = get_var(DIRECT);
|
||||
char *cp = spk_characters[ch];
|
||||
struct var_t *direct = spk_get_var(DIRECT);
|
||||
if (direct && direct->u.n.value) {
|
||||
if (IS_CHAR(ch, B_CAP)) {
|
||||
pitch_shift++;
|
||||
synth_printf("%s", str_caps_start);
|
||||
spk_pitch_shift++;
|
||||
synth_printf("%s", spk_str_caps_start);
|
||||
}
|
||||
synth_printf("%c", ch);
|
||||
if (IS_CHAR(ch, B_CAP))
|
||||
synth_printf("%s", str_caps_stop);
|
||||
synth_printf("%s", spk_str_caps_stop);
|
||||
return;
|
||||
}
|
||||
if (cp == NULL) {
|
||||
|
|
@ -443,13 +443,13 @@ static void speak_char(u_char ch)
|
|||
}
|
||||
synth_buffer_add(SPACE);
|
||||
if (IS_CHAR(ch, B_CAP)) {
|
||||
pitch_shift++;
|
||||
synth_printf("%s", str_caps_start);
|
||||
spk_pitch_shift++;
|
||||
synth_printf("%s", spk_str_caps_start);
|
||||
synth_printf("%s", cp);
|
||||
synth_printf("%s", str_caps_stop);
|
||||
synth_printf("%s", spk_str_caps_stop);
|
||||
} else {
|
||||
if (*cp == '^') {
|
||||
synth_printf("%s", msg_get(MSG_CTRL));
|
||||
synth_printf("%s", spk_msg_get(MSG_CTRL));
|
||||
cp++;
|
||||
}
|
||||
synth_printf("%s", cp);
|
||||
|
|
@ -479,9 +479,9 @@ static void say_char(struct vc_data *vc)
|
|||
spk_old_attr = spk_attr;
|
||||
ch = get_char(vc, (u_short *) spk_pos, &spk_attr);
|
||||
if (spk_attr != spk_old_attr) {
|
||||
if (attrib_bleep & 1)
|
||||
if (spk_attrib_bleep & 1)
|
||||
bleep(spk_y);
|
||||
if (attrib_bleep & 2)
|
||||
if (spk_attrib_bleep & 2)
|
||||
say_attributes(vc);
|
||||
}
|
||||
speak_char(ch & 0xff);
|
||||
|
|
@ -497,7 +497,7 @@ static void say_phonetic_char(struct vc_data *vc)
|
|||
synth_printf("%s\n", phonetic[--ch]);
|
||||
} else {
|
||||
if (IS_CHAR(ch, B_NUM))
|
||||
synth_printf("%s ", msg_get(MSG_NUMBER));
|
||||
synth_printf("%s ", spk_msg_get(MSG_NUMBER));
|
||||
speak_char(ch);
|
||||
}
|
||||
}
|
||||
|
|
@ -527,8 +527,8 @@ static void say_next_char(struct vc_data *vc)
|
|||
}
|
||||
|
||||
/* get_word - will first check to see if the character under the
|
||||
* reading cursor is a space and if say_word_ctl is true it will
|
||||
* return the word space. If say_word_ctl is not set it will check to
|
||||
* reading cursor is a space and if spk_say_word_ctl is true it will
|
||||
* return the word space. If spk_say_word_ctl is not set it will check to
|
||||
* see if there is a word starting on the next position to the right
|
||||
* and return that word if it exists. If it does not exist it will
|
||||
* move left to the beginning of any previous word on the line or the
|
||||
|
|
@ -544,9 +544,9 @@ static u_long get_word(struct vc_data *vc)
|
|||
ch = (char)get_char(vc, (u_short *) tmp_pos, &temp);
|
||||
|
||||
/* decided to take out the sayword if on a space (mis-information */
|
||||
if (say_word_ctl && ch == SPACE) {
|
||||
if (spk_say_word_ctl && ch == SPACE) {
|
||||
*buf = '\0';
|
||||
synth_printf("%s\n", msg_get(MSG_SPACE));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_SPACE));
|
||||
return 0;
|
||||
} else if ((tmpx < vc->vc_cols - 2)
|
||||
&& (ch == SPACE || ch == 0 || IS_WDLM(ch))
|
||||
|
|
@ -582,13 +582,13 @@ static u_long get_word(struct vc_data *vc)
|
|||
static void say_word(struct vc_data *vc)
|
||||
{
|
||||
u_long cnt = get_word(vc);
|
||||
u_short saved_punc_mask = punc_mask;
|
||||
u_short saved_punc_mask = spk_punc_mask;
|
||||
if (cnt == 0)
|
||||
return;
|
||||
punc_mask = PUNC;
|
||||
spk_punc_mask = PUNC;
|
||||
buf[cnt++] = SPACE;
|
||||
spkup_write(buf, cnt);
|
||||
punc_mask = saved_punc_mask;
|
||||
spk_punc_mask = saved_punc_mask;
|
||||
}
|
||||
|
||||
static void say_prev_word(struct vc_data *vc)
|
||||
|
|
@ -686,22 +686,22 @@ static void say_next_word(struct vc_data *vc)
|
|||
static void spell_word(struct vc_data *vc)
|
||||
{
|
||||
static char *delay_str[] = { "", ",", ".", ". .", ". . ." };
|
||||
char *cp = buf, *str_cap = str_caps_stop;
|
||||
char *cp1, *last_cap = str_caps_stop;
|
||||
char *cp = buf, *str_cap = spk_str_caps_stop;
|
||||
char *cp1, *last_cap = spk_str_caps_stop;
|
||||
u_char ch;
|
||||
if (!get_word(vc))
|
||||
return;
|
||||
while ((ch = (u_char) *cp)) {
|
||||
if (cp != buf)
|
||||
synth_printf(" %s ", delay_str[spell_delay]);
|
||||
synth_printf(" %s ", delay_str[spk_spell_delay]);
|
||||
if (IS_CHAR(ch, B_CAP)) {
|
||||
str_cap = str_caps_start;
|
||||
if (*str_caps_stop)
|
||||
pitch_shift++;
|
||||
str_cap = spk_str_caps_start;
|
||||
if (*spk_str_caps_stop)
|
||||
spk_pitch_shift++;
|
||||
else /* synth has no pitch */
|
||||
last_cap = str_caps_stop;
|
||||
last_cap = spk_str_caps_stop;
|
||||
} else
|
||||
str_cap = str_caps_stop;
|
||||
str_cap = spk_str_caps_stop;
|
||||
if (str_cap != last_cap) {
|
||||
synth_printf("%s", str_cap);
|
||||
last_cap = str_cap;
|
||||
|
|
@ -711,17 +711,17 @@ static void spell_word(struct vc_data *vc)
|
|||
ch &= 31;
|
||||
cp1 = phonetic[--ch];
|
||||
} else {
|
||||
cp1 = characters[ch];
|
||||
cp1 = spk_characters[ch];
|
||||
if (*cp1 == '^') {
|
||||
synth_printf("%s", msg_get(MSG_CTRL));
|
||||
synth_printf("%s", spk_msg_get(MSG_CTRL));
|
||||
cp1++;
|
||||
}
|
||||
}
|
||||
synth_printf("%s", cp1);
|
||||
cp++;
|
||||
}
|
||||
if (str_cap != str_caps_stop)
|
||||
synth_printf("%s", str_caps_stop);
|
||||
if (str_cap != spk_str_caps_stop)
|
||||
synth_printf("%s", spk_str_caps_stop);
|
||||
}
|
||||
|
||||
static int get_line(struct vc_data *vc)
|
||||
|
|
@ -746,9 +746,9 @@ static void say_line(struct vc_data *vc)
|
|||
{
|
||||
int i = get_line(vc);
|
||||
char *cp;
|
||||
u_short saved_punc_mask = punc_mask;
|
||||
u_short saved_punc_mask = spk_punc_mask;
|
||||
if (i == 0) {
|
||||
synth_printf("%s\n", msg_get(MSG_BLANK));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_BLANK));
|
||||
return;
|
||||
}
|
||||
buf[i++] = '\n';
|
||||
|
|
@ -758,9 +758,9 @@ static void say_line(struct vc_data *vc)
|
|||
cp++;
|
||||
synth_printf("%d, ", (cp - buf) + 1);
|
||||
}
|
||||
punc_mask = punc_masks[reading_punc];
|
||||
spk_punc_mask = spk_punc_masks[spk_reading_punc];
|
||||
spkup_write(buf, i);
|
||||
punc_mask = saved_punc_mask;
|
||||
spk_punc_mask = saved_punc_mask;
|
||||
}
|
||||
|
||||
static void say_prev_line(struct vc_data *vc)
|
||||
|
|
@ -792,7 +792,7 @@ static int say_from_to(struct vc_data *vc, u_long from, u_long to,
|
|||
{
|
||||
int i = 0;
|
||||
u_char tmp;
|
||||
u_short saved_punc_mask = punc_mask;
|
||||
u_short saved_punc_mask = spk_punc_mask;
|
||||
spk_old_attr = spk_attr;
|
||||
spk_attr = get_attributes((u_short *) from);
|
||||
while (from < to) {
|
||||
|
|
@ -809,10 +809,10 @@ static int say_from_to(struct vc_data *vc, u_long from, u_long to,
|
|||
if (i < 1)
|
||||
return i;
|
||||
if (read_punc)
|
||||
punc_mask = punc_info[reading_punc].mask;
|
||||
spk_punc_mask = spk_punc_info[spk_reading_punc].mask;
|
||||
spkup_write(buf, i);
|
||||
if (read_punc)
|
||||
punc_mask = saved_punc_mask;
|
||||
spk_punc_mask = saved_punc_mask;
|
||||
return i - 1;
|
||||
}
|
||||
|
||||
|
|
@ -824,7 +824,7 @@ static void say_line_from_to(struct vc_data *vc, u_long from, u_long to,
|
|||
start += from * 2;
|
||||
if (say_from_to(vc, start, end, read_punc) <= 0)
|
||||
if (cursor_track != read_all_mode)
|
||||
synth_printf("%s\n", msg_get(MSG_BLANK));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_BLANK));
|
||||
}
|
||||
|
||||
/* Sentence Reading Commands */
|
||||
|
|
@ -924,7 +924,7 @@ static void speakup_win_say(struct vc_data *vc)
|
|||
{
|
||||
u_long start, end, from, to;
|
||||
if (win_start < 2) {
|
||||
synth_printf("%s\n", msg_get(MSG_NO_WINDOW));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW));
|
||||
return;
|
||||
}
|
||||
start = vc->vc_origin + (win_top * vc->vc_size_row);
|
||||
|
|
@ -975,7 +975,7 @@ static void say_first_char(struct vc_data *vc)
|
|||
u_char ch;
|
||||
spk_parked |= 0x01;
|
||||
if (len == 0) {
|
||||
synth_printf("%s\n", msg_get(MSG_BLANK));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_BLANK));
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < len; i++)
|
||||
|
|
@ -994,7 +994,7 @@ static void say_last_char(struct vc_data *vc)
|
|||
u_char ch;
|
||||
spk_parked |= 0x01;
|
||||
if (len == 0) {
|
||||
synth_printf("%s\n", msg_get(MSG_BLANK));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_BLANK));
|
||||
return;
|
||||
}
|
||||
ch = buf[--len];
|
||||
|
|
@ -1006,7 +1006,7 @@ static void say_last_char(struct vc_data *vc)
|
|||
|
||||
static void say_position(struct vc_data *vc)
|
||||
{
|
||||
synth_printf(msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1,
|
||||
synth_printf(spk_msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1,
|
||||
vc->vc_num + 1);
|
||||
synth_printf("\n");
|
||||
}
|
||||
|
|
@ -1017,7 +1017,7 @@ static void say_char_num(struct vc_data *vc)
|
|||
u_char tmp;
|
||||
u_short ch = get_char(vc, (u_short *) spk_pos, &tmp);
|
||||
ch &= 0xff;
|
||||
synth_printf(msg_get(MSG_CHAR_INFO), ch, ch);
|
||||
synth_printf(spk_msg_get(MSG_CHAR_INFO), ch, ch);
|
||||
}
|
||||
|
||||
/* these are stub functions to keep keyboard.c happy. */
|
||||
|
|
@ -1066,7 +1066,7 @@ static void spkup_write(const char *in_buf, int count)
|
|||
} else {
|
||||
if ((last_type & CH_RPT) && rep_count > 2) {
|
||||
synth_printf(" ");
|
||||
synth_printf(msg_get(MSG_REPEAT_DESC),
|
||||
synth_printf(spk_msg_get(MSG_REPEAT_DESC),
|
||||
++rep_count);
|
||||
synth_printf(" ");
|
||||
}
|
||||
|
|
@ -1074,7 +1074,7 @@ static void spkup_write(const char *in_buf, int count)
|
|||
}
|
||||
if (ch == spk_lastkey) {
|
||||
rep_count = 0;
|
||||
if (key_echo == 1 && ch >= MINECHOCHAR)
|
||||
if (spk_key_echo == 1 && ch >= MINECHOCHAR)
|
||||
speak_char(ch);
|
||||
} else if (char_type & B_ALPHA) {
|
||||
if ((synth_flags & SF_DEC) && (last_type & PUNC))
|
||||
|
|
@ -1083,7 +1083,7 @@ static void spkup_write(const char *in_buf, int count)
|
|||
} else if (char_type & B_NUM) {
|
||||
rep_count = 0;
|
||||
synth_printf("%c", ch);
|
||||
} else if (char_type & punc_mask) {
|
||||
} else if (char_type & spk_punc_mask) {
|
||||
speak_char(ch);
|
||||
char_type &= ~PUNC; /* for dec nospell processing */
|
||||
} else if (char_type & SYNTH_OK) {
|
||||
|
|
@ -1111,7 +1111,7 @@ static void spkup_write(const char *in_buf, int count)
|
|||
if (in_count > 2 && rep_count > 2) {
|
||||
if (last_type & CH_RPT) {
|
||||
synth_printf(" ");
|
||||
synth_printf(msg_get(MSG_REPEAT_DESC2), ++rep_count);
|
||||
synth_printf(spk_msg_get(MSG_REPEAT_DESC2), ++rep_count);
|
||||
synth_printf(" ");
|
||||
}
|
||||
rep_count = 0;
|
||||
|
|
@ -1135,22 +1135,22 @@ static void do_handle_shift(struct vc_data *vc, u_char value, char up_flag)
|
|||
case KVAL(K_SHIFT):
|
||||
del_timer(&cursor_timer);
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
read_all_doc(vc);
|
||||
break;
|
||||
case KVAL(K_CTRL):
|
||||
del_timer(&cursor_timer);
|
||||
cursor_track = prev_cursor_track;
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
}
|
||||
if (say_ctrl && value < NUM_CTL_LABELS)
|
||||
synth_printf("%s", msg_get(MSG_CTL_START + value));
|
||||
if (spk_say_ctrl && value < NUM_CTL_LABELS)
|
||||
synth_printf("%s", spk_msg_get(MSG_CTL_START + value));
|
||||
spk_unlock(flags);
|
||||
}
|
||||
|
||||
|
|
@ -1171,12 +1171,12 @@ static void do_handle_latin(struct vc_data *vc, u_char value, char up_flag)
|
|||
spk_lastkey = value;
|
||||
spk_keydown++;
|
||||
spk_parked &= 0xfe;
|
||||
if (key_echo == 2 && value >= MINECHOCHAR)
|
||||
if (spk_key_echo == 2 && value >= MINECHOCHAR)
|
||||
speak_char(value);
|
||||
spk_unlock(flags);
|
||||
}
|
||||
|
||||
int set_key_info(const u_char *key_info, u_char *k_buffer)
|
||||
int spk_set_key_info(const u_char *key_info, u_char *k_buffer)
|
||||
{
|
||||
int i = 0, states, key_data_len;
|
||||
const u_char *cp = key_info;
|
||||
|
|
@ -1188,12 +1188,12 @@ int set_key_info(const u_char *key_info, u_char *k_buffer)
|
|||
num_keys = *cp;
|
||||
states = (int)cp[1];
|
||||
key_data_len = (states + 1) * (num_keys + 1);
|
||||
if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(key_buf))
|
||||
if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf))
|
||||
return -2;
|
||||
memset(k_buffer, 0, SHIFT_TBL_SIZE);
|
||||
memset(our_keys, 0, sizeof(our_keys));
|
||||
shift_table = k_buffer;
|
||||
our_keys[0] = shift_table;
|
||||
memset(spk_our_keys, 0, sizeof(spk_our_keys));
|
||||
spk_shift_table = k_buffer;
|
||||
spk_our_keys[0] = spk_shift_table;
|
||||
cp1 += SHIFT_TBL_SIZE;
|
||||
memcpy(cp1, cp, key_data_len + 3);
|
||||
/* get num_keys, states and data */
|
||||
|
|
@ -1202,13 +1202,13 @@ int set_key_info(const u_char *key_info, u_char *k_buffer)
|
|||
ch = *cp1++;
|
||||
if (ch >= SHIFT_TBL_SIZE)
|
||||
return -3;
|
||||
shift_table[ch] = i;
|
||||
spk_shift_table[ch] = i;
|
||||
}
|
||||
keymap_flags = *cp1++;
|
||||
while ((ch = *cp1)) {
|
||||
if (ch >= MAX_KEY)
|
||||
return -4;
|
||||
our_keys[ch] = cp1;
|
||||
spk_our_keys[ch] = cp1;
|
||||
cp1 += states + 1;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -1237,24 +1237,24 @@ static void toggle_cursoring(struct vc_data *vc)
|
|||
cursor_track = prev_cursor_track;
|
||||
if (++cursor_track >= CT_Max)
|
||||
cursor_track = 0;
|
||||
synth_printf("%s\n", msg_get(MSG_CURSOR_MSGS_START + cursor_track));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_CURSOR_MSGS_START + cursor_track));
|
||||
}
|
||||
|
||||
void reset_default_chars(void)
|
||||
void spk_reset_default_chars(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* First, free any non-default */
|
||||
for (i = 0; i < 256; i++) {
|
||||
if ((characters[i] != NULL)
|
||||
&& (characters[i] != default_chars[i]))
|
||||
kfree(characters[i]);
|
||||
if ((spk_characters[i] != NULL)
|
||||
&& (spk_characters[i] != spk_default_chars[i]))
|
||||
kfree(spk_characters[i]);
|
||||
}
|
||||
|
||||
memcpy(characters, default_chars, sizeof(default_chars));
|
||||
memcpy(spk_characters, spk_default_chars, sizeof(spk_default_chars));
|
||||
}
|
||||
|
||||
void reset_default_chartab(void)
|
||||
void spk_reset_default_chartab(void)
|
||||
{
|
||||
memcpy(spk_chartab, default_chartab, sizeof(default_chartab));
|
||||
}
|
||||
|
|
@ -1267,8 +1267,8 @@ static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
|||
if (type != KT_LATIN || (ch_type & B_NUM) || ch < SPACE)
|
||||
return -1;
|
||||
if (ch == SPACE) {
|
||||
synth_printf("%s\n", msg_get(MSG_EDIT_DONE));
|
||||
special_handler = NULL;
|
||||
synth_printf("%s\n", spk_msg_get(MSG_EDIT_DONE));
|
||||
spk_special_handler = NULL;
|
||||
return 1;
|
||||
}
|
||||
if (mask < PUNC && !(ch_type & PUNC))
|
||||
|
|
@ -1276,8 +1276,8 @@ static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
|||
spk_chartab[ch] ^= mask;
|
||||
speak_char(ch);
|
||||
synth_printf(" %s\n",
|
||||
(spk_chartab[ch] & mask) ? msg_get(MSG_ON) :
|
||||
msg_get(MSG_OFF));
|
||||
(spk_chartab[ch] & mask) ? spk_msg_get(MSG_ON) :
|
||||
spk_msg_get(MSG_OFF));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -1346,7 +1346,7 @@ static void read_all_doc(struct vc_data *vc)
|
|||
if (cursor_track != read_all_mode)
|
||||
prev_cursor_track = cursor_track;
|
||||
cursor_track = read_all_mode;
|
||||
reset_index_count(0);
|
||||
spk_reset_index_count(0);
|
||||
if (get_sentence_buf(vc, 0) == -1)
|
||||
kbd_fakekey2(vc, RA_DOWN_ARROW);
|
||||
else {
|
||||
|
|
@ -1361,7 +1361,7 @@ static void stop_read_all(struct vc_data *vc)
|
|||
del_timer(&cursor_timer);
|
||||
cursor_track = prev_cursor_track;
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
}
|
||||
|
||||
static void start_read_all_timer(struct vc_data *vc, int command)
|
||||
|
|
@ -1370,7 +1370,7 @@ static void start_read_all_timer(struct vc_data *vc, int command)
|
|||
|
||||
cursor_con = vc->vc_num;
|
||||
read_all_key = command;
|
||||
cursor_timeout = get_var(CURSOR_TIME);
|
||||
cursor_timeout = spk_get_var(CURSOR_TIME);
|
||||
mod_timer(&cursor_timer,
|
||||
jiffies + msecs_to_jiffies(cursor_timeout->u.n.value));
|
||||
}
|
||||
|
|
@ -1382,9 +1382,9 @@ static void handle_cursor_read_all(struct vc_data *vc, int command)
|
|||
switch (command) {
|
||||
case RA_NEXT_SENT:
|
||||
/* Get Current Sentence */
|
||||
get_index_count(&indcount, &sentcount);
|
||||
spk_get_index_count(&indcount, &sentcount);
|
||||
/*printk("%d %d ", indcount, sentcount); */
|
||||
reset_index_count(sentcount + 1);
|
||||
spk_reset_index_count(sentcount + 1);
|
||||
if (indcount == 1) {
|
||||
if (!say_sentence_num(sentcount + 1, 0)) {
|
||||
kbd_fakekey2(vc, RA_FIND_NEXT_SENT);
|
||||
|
|
@ -1395,7 +1395,7 @@ static void handle_cursor_read_all(struct vc_data *vc, int command)
|
|||
sn = 0;
|
||||
if (!say_sentence_num(sentcount + 1, 1)) {
|
||||
sn = 1;
|
||||
reset_index_count(sn);
|
||||
spk_reset_index_count(sn);
|
||||
} else
|
||||
synth_insert_next_index(0);
|
||||
if (!say_sentence_num(sn, 0)) {
|
||||
|
|
@ -1437,7 +1437,7 @@ static void handle_cursor_read_all(struct vc_data *vc, int command)
|
|||
case RA_FIND_PREV_SENT:
|
||||
break;
|
||||
case RA_TIMER:
|
||||
get_index_count(&indcount, &sentcount);
|
||||
spk_get_index_count(&indcount, &sentcount);
|
||||
if (indcount < 2)
|
||||
kbd_fakekey2(vc, RA_DOWN_ARROW);
|
||||
else
|
||||
|
|
@ -1458,7 +1458,7 @@ static int pre_handle_cursor(struct vc_data *vc, u_char value, char up_flag)
|
|||
}
|
||||
del_timer(&cursor_timer);
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
start_read_all_timer(vc, value + 1);
|
||||
spk_unlock(flags);
|
||||
return NOTIFY_STOP;
|
||||
|
|
@ -1479,8 +1479,8 @@ static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag)
|
|||
return;
|
||||
}
|
||||
spk_shut_up &= 0xfe;
|
||||
if (no_intr)
|
||||
do_flush();
|
||||
if (spk_no_intr)
|
||||
spk_do_flush();
|
||||
/* the key press flushes if !no_inter but we want to flush on cursor
|
||||
* moves regardless of no_inter state */
|
||||
is_cursor = value + 1;
|
||||
|
|
@ -1491,7 +1491,7 @@ static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag)
|
|||
cursor_con = vc->vc_num;
|
||||
if (cursor_track == CT_Highlight)
|
||||
reset_highlight_buffers(vc);
|
||||
cursor_timeout = get_var(CURSOR_TIME);
|
||||
cursor_timeout = spk_get_var(CURSOR_TIME);
|
||||
mod_timer(&cursor_timer,
|
||||
jiffies + msecs_to_jiffies(cursor_timeout->u.n.value));
|
||||
spk_unlock(flags);
|
||||
|
|
@ -1603,7 +1603,7 @@ static int speak_highlight(struct vc_data *vc)
|
|||
if (speakup_console[vc_num]->ht.ry[hc] != vc->vc_y)
|
||||
return 0;
|
||||
spk_parked |= 0x01;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
spkup_write(speakup_console[vc_num]->ht.highbuf[hc],
|
||||
speakup_console[vc_num]->ht.highsize[hc]);
|
||||
spk_pos = spk_cp = speakup_console[vc_num]->ht.rpos[hc];
|
||||
|
|
@ -1685,7 +1685,7 @@ static void speakup_con_write(struct vc_data *vc, const char *str, int len)
|
|||
if (!spk_trylock(flags))
|
||||
/* Speakup output, discard */
|
||||
return;
|
||||
if (bell_pos && spk_keydown && (vc->vc_x == bell_pos - 1))
|
||||
if (spk_bell_pos && spk_keydown && (vc->vc_x == spk_bell_pos - 1))
|
||||
bleep(3);
|
||||
if ((is_cursor) || (cursor_track == read_all_mode)) {
|
||||
if (cursor_track == CT_Highlight)
|
||||
|
|
@ -1726,19 +1726,19 @@ static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag)
|
|||
return;
|
||||
spk_lock(flags);
|
||||
spk_shut_up &= 0xfe;
|
||||
if (no_intr)
|
||||
do_flush();
|
||||
if (spk_no_intr)
|
||||
spk_do_flush();
|
||||
switch (value) {
|
||||
case KVAL(K_CAPS):
|
||||
label = msg_get(MSG_KEYNAME_CAPSLOCK);
|
||||
label = spk_msg_get(MSG_KEYNAME_CAPSLOCK);
|
||||
on_off = vt_get_leds(fg_console, VC_CAPSLOCK);
|
||||
break;
|
||||
case KVAL(K_NUM):
|
||||
label = msg_get(MSG_KEYNAME_NUMLOCK);
|
||||
label = spk_msg_get(MSG_KEYNAME_NUMLOCK);
|
||||
on_off = vt_get_leds(fg_console, VC_NUMLOCK);
|
||||
break;
|
||||
case KVAL(K_HOLD):
|
||||
label = msg_get(MSG_KEYNAME_SCROLLLOCK);
|
||||
label = spk_msg_get(MSG_KEYNAME_SCROLLLOCK);
|
||||
on_off = vt_get_leds(fg_console, VC_SCROLLOCK);
|
||||
if (speakup_console[vc->vc_num])
|
||||
speakup_console[vc->vc_num]->tty_stopped = on_off;
|
||||
|
|
@ -1750,7 +1750,7 @@ static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag)
|
|||
}
|
||||
if (on_off < 2)
|
||||
synth_printf("%s %s\n",
|
||||
label, msg_get(MSG_STATUS_START + on_off));
|
||||
label, spk_msg_get(MSG_STATUS_START + on_off));
|
||||
spk_unlock(flags);
|
||||
}
|
||||
|
||||
|
|
@ -1764,13 +1764,13 @@ static int inc_dec_var(u_char value)
|
|||
int var_id = (int)value - VAR_START;
|
||||
int how = (var_id & 1) ? E_INC : E_DEC;
|
||||
var_id = var_id / 2 + FIRST_SET_VAR;
|
||||
p_header = get_var_header(var_id);
|
||||
p_header = spk_get_var_header(var_id);
|
||||
if (p_header == NULL)
|
||||
return -1;
|
||||
if (p_header->var_type != VAR_NUM)
|
||||
return -1;
|
||||
var_data = p_header->data;
|
||||
if (set_num_var(1, p_header, how) != 0)
|
||||
if (spk_set_num_var(1, p_header, how) != 0)
|
||||
return -1;
|
||||
if (!spk_close_press) {
|
||||
for (pn = p_header->name; *pn; pn++) {
|
||||
|
|
@ -1790,18 +1790,18 @@ static void speakup_win_set(struct vc_data *vc)
|
|||
{
|
||||
char info[40];
|
||||
if (win_start > 1) {
|
||||
synth_printf("%s\n", msg_get(MSG_WINDOW_ALREADY_SET));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_WINDOW_ALREADY_SET));
|
||||
return;
|
||||
}
|
||||
if (spk_x < win_left || spk_y < win_top) {
|
||||
synth_printf("%s\n", msg_get(MSG_END_BEFORE_START));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_END_BEFORE_START));
|
||||
return;
|
||||
}
|
||||
if (win_start && spk_x == win_left && spk_y == win_top) {
|
||||
win_left = 0;
|
||||
win_right = vc->vc_cols - 1;
|
||||
win_bottom = spk_y;
|
||||
snprintf(info, sizeof(info), msg_get(MSG_WINDOW_LINE),
|
||||
snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_LINE),
|
||||
(int)win_top + 1);
|
||||
} else {
|
||||
if (!win_start) {
|
||||
|
|
@ -1811,8 +1811,8 @@ static void speakup_win_set(struct vc_data *vc)
|
|||
win_bottom = spk_y;
|
||||
win_right = spk_x;
|
||||
}
|
||||
snprintf(info, sizeof(info), msg_get(MSG_WINDOW_BOUNDARY),
|
||||
(win_start) ? msg_get(MSG_END) : msg_get(MSG_START),
|
||||
snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_BOUNDARY),
|
||||
(win_start) ? spk_msg_get(MSG_END) : spk_msg_get(MSG_START),
|
||||
(int)spk_y + 1, (int)spk_x + 1);
|
||||
}
|
||||
synth_printf("%s\n", info);
|
||||
|
|
@ -1824,32 +1824,32 @@ static void speakup_win_clear(struct vc_data *vc)
|
|||
win_top = win_bottom = 0;
|
||||
win_left = win_right = 0;
|
||||
win_start = 0;
|
||||
synth_printf("%s\n", msg_get(MSG_WINDOW_CLEARED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_WINDOW_CLEARED));
|
||||
}
|
||||
|
||||
static void speakup_win_enable(struct vc_data *vc)
|
||||
{
|
||||
if (win_start < 2) {
|
||||
synth_printf("%s\n", msg_get(MSG_NO_WINDOW));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW));
|
||||
return;
|
||||
}
|
||||
win_enabled ^= 1;
|
||||
if (win_enabled)
|
||||
synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCED));
|
||||
else
|
||||
synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCE_DISABLED));
|
||||
synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCE_DISABLED));
|
||||
}
|
||||
|
||||
static void speakup_bits(struct vc_data *vc)
|
||||
{
|
||||
int val = this_speakup_key - (FIRST_EDIT_BITS - 1);
|
||||
if (special_handler != NULL || val < 1 || val > 6) {
|
||||
synth_printf("%s\n", msg_get(MSG_ERROR));
|
||||
if (spk_special_handler != NULL || val < 1 || val > 6) {
|
||||
synth_printf("%s\n", spk_msg_get(MSG_ERROR));
|
||||
return;
|
||||
}
|
||||
pb_edit = &punc_info[val];
|
||||
synth_printf(msg_get(MSG_EDIT_PROMPT), pb_edit->name);
|
||||
special_handler = edit_bits;
|
||||
pb_edit = &spk_punc_info[val];
|
||||
synth_printf(spk_msg_get(MSG_EDIT_PROMPT), pb_edit->name);
|
||||
spk_special_handler = edit_bits;
|
||||
}
|
||||
|
||||
static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
||||
|
|
@ -1887,9 +1887,9 @@ static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key)
|
|||
if (ch < 'x' || ch > 'y') {
|
||||
oops:
|
||||
if (!spk_killed)
|
||||
synth_printf(" %s\n", msg_get(MSG_GOTO_CANCELED));
|
||||
synth_printf(" %s\n", spk_msg_get(MSG_GOTO_CANCELED));
|
||||
goto_buf[num = 0] = '\0';
|
||||
special_handler = NULL;
|
||||
spk_special_handler = NULL;
|
||||
return 1;
|
||||
}
|
||||
cp = speakup_s2i(goto_buf, &go_pos);
|
||||
|
|
@ -1917,7 +1917,7 @@ oops:
|
|||
}
|
||||
goto_buf[num = 0] = '\0';
|
||||
do_goto:
|
||||
special_handler = NULL;
|
||||
spk_special_handler = NULL;
|
||||
spk_parked |= 0x01;
|
||||
if (goto_x) {
|
||||
spk_pos -= spk_x * 2;
|
||||
|
|
@ -1934,18 +1934,18 @@ do_goto:
|
|||
|
||||
static void speakup_goto(struct vc_data *vc)
|
||||
{
|
||||
if (special_handler != NULL) {
|
||||
synth_printf("%s\n", msg_get(MSG_ERROR));
|
||||
if (spk_special_handler != NULL) {
|
||||
synth_printf("%s\n", spk_msg_get(MSG_ERROR));
|
||||
return;
|
||||
}
|
||||
synth_printf("%s\n", msg_get(MSG_GOTO));
|
||||
special_handler = handle_goto;
|
||||
synth_printf("%s\n", spk_msg_get(MSG_GOTO));
|
||||
spk_special_handler = handle_goto;
|
||||
return;
|
||||
}
|
||||
|
||||
static void speakup_help(struct vc_data *vc)
|
||||
{
|
||||
handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0);
|
||||
spk_handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0);
|
||||
}
|
||||
|
||||
static void do_nothing(struct vc_data *vc)
|
||||
|
|
@ -1992,7 +1992,7 @@ static void do_spkup(struct vc_data *vc, u_char value)
|
|||
spk_shut_up &= 0xfe;
|
||||
this_speakup_key = value;
|
||||
if (value < SPKUP_MAX_FUNC && spkup_handler[value]) {
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
(*spkup_handler[value]) (vc);
|
||||
} else {
|
||||
if (inc_dec_var(value) < 0)
|
||||
|
|
@ -2032,7 +2032,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
|
|||
}
|
||||
if (keycode >= MAX_KEY)
|
||||
goto no_map;
|
||||
key_info = our_keys[keycode];
|
||||
key_info = spk_our_keys[keycode];
|
||||
if (key_info == 0)
|
||||
goto no_map;
|
||||
/* Check valid read all mode keys */
|
||||
|
|
@ -2051,7 +2051,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
|
|||
}
|
||||
}
|
||||
shift_info = (shift_state & 0x0f) + key_speakup;
|
||||
offset = shift_table[shift_info];
|
||||
offset = spk_shift_table[shift_info];
|
||||
if (offset) {
|
||||
new_key = key_info[offset];
|
||||
if (new_key) {
|
||||
|
|
@ -2062,7 +2062,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
|
|||
if (up_flag || spk_killed)
|
||||
goto out;
|
||||
spk_shut_up &= 0xfe;
|
||||
do_flush();
|
||||
spk_do_flush();
|
||||
goto out;
|
||||
}
|
||||
if (up_flag)
|
||||
|
|
@ -2070,7 +2070,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
|
|||
if (last_keycode == keycode &&
|
||||
last_spk_jiffy + MAX_DELAY > jiffies) {
|
||||
spk_close_press = 1;
|
||||
offset = shift_table[shift_info + 32];
|
||||
offset = spk_shift_table[shift_info + 32];
|
||||
/* double press? */
|
||||
if (offset && key_info[offset])
|
||||
new_key = key_info[offset];
|
||||
|
|
@ -2082,7 +2082,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym,
|
|||
}
|
||||
}
|
||||
no_map:
|
||||
if (type == KT_SPKUP && special_handler == NULL) {
|
||||
if (type == KT_SPKUP && spk_special_handler == NULL) {
|
||||
do_spkup(vc, new_key);
|
||||
spk_close_press = 0;
|
||||
ret = 1;
|
||||
|
|
@ -2096,9 +2096,9 @@ no_map:
|
|||
|| (value == KVAL(K_LEFT))
|
||||
|| (value == KVAL(K_RIGHT));
|
||||
if ((cursor_track != read_all_mode) || !kh)
|
||||
if (!no_intr)
|
||||
do_flush();
|
||||
if (special_handler) {
|
||||
if (!spk_no_intr)
|
||||
spk_do_flush();
|
||||
if (spk_special_handler) {
|
||||
if (type == KT_SPEC && value == 1) {
|
||||
value = '\n';
|
||||
type = KT_LATIN;
|
||||
|
|
@ -2106,7 +2106,7 @@ no_map:
|
|||
type = KT_LATIN;
|
||||
else if (value == 0x7f)
|
||||
value = 8; /* make del = backspace */
|
||||
ret = (*special_handler) (vc, type, value, keycode);
|
||||
ret = (*spk_special_handler) (vc, type, value, keycode);
|
||||
spk_close_press = 0;
|
||||
if (ret < 0)
|
||||
bleep(9);
|
||||
|
|
@ -2237,11 +2237,11 @@ static void __exit speakup_exit(void)
|
|||
speakup_unregister_var(i);
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (characters[i] != default_chars[i])
|
||||
kfree(characters[i]);
|
||||
if (spk_characters[i] != spk_default_chars[i])
|
||||
kfree(spk_characters[i]);
|
||||
}
|
||||
|
||||
free_user_msgs();
|
||||
spk_free_user_msgs();
|
||||
}
|
||||
|
||||
/* call by: module_init() */
|
||||
|
|
@ -2254,20 +2254,20 @@ static int __init speakup_init(void)
|
|||
struct var_t *var;
|
||||
|
||||
/* These first few initializations cannot fail. */
|
||||
initialize_msgs(); /* Initialize arrays for i18n. */
|
||||
reset_default_chars();
|
||||
reset_default_chartab();
|
||||
strlwr(synth_name);
|
||||
spk_initialize_msgs(); /* Initialize arrays for i18n. */
|
||||
spk_reset_default_chars();
|
||||
spk_reset_default_chartab();
|
||||
spk_strlwr(synth_name);
|
||||
spk_vars[0].u.n.high = vc->vc_cols;
|
||||
for (var = spk_vars; var->var_id != MAXVARS; var++)
|
||||
speakup_register_var(var);
|
||||
for (var = synth_time_vars;
|
||||
(var->var_id >= 0) && (var->var_id < MAXVARS); var++)
|
||||
speakup_register_var(var);
|
||||
for (i = 1; punc_info[i].mask != 0; i++)
|
||||
set_mask_bits(0, i, 2);
|
||||
for (i = 1; spk_punc_info[i].mask != 0; i++)
|
||||
spk_set_mask_bits(0, i, 2);
|
||||
|
||||
set_key_info(key_defaults, key_buf);
|
||||
spk_set_key_info(spk_key_defaults, spk_key_buf);
|
||||
|
||||
/* From here on out, initializations can fail. */
|
||||
err = speakup_add_virtual_keyboard();
|
||||
|
|
@ -2290,7 +2290,7 @@ static int __init speakup_init(void)
|
|||
goto error_kobjects;
|
||||
}
|
||||
|
||||
if (quiet_boot)
|
||||
if (spk_quiet_boot)
|
||||
spk_shut_up |= 0x01;
|
||||
|
||||
err = speakup_kobj_init();
|
||||
|
|
@ -2352,11 +2352,11 @@ error_virtkeyboard:
|
|||
speakup_unregister_var(i);
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (characters[i] != default_chars[i])
|
||||
kfree(characters[i]);
|
||||
if (spk_characters[i] != spk_default_chars[i])
|
||||
kfree(spk_characters[i]);
|
||||
}
|
||||
|
||||
free_user_msgs();
|
||||
spk_free_user_msgs();
|
||||
|
||||
out:
|
||||
return err;
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
/* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */
|
||||
#define ishardspace(c) ((c) == ' ')
|
||||
|
||||
unsigned short xs, ys, xe, ye; /* our region points */
|
||||
unsigned short spk_xs, spk_ys, spk_xe, spk_ye; /* our region points */
|
||||
|
||||
/* Variables for selection control. */
|
||||
/* must not be disallocated */
|
||||
|
|
@ -51,12 +51,12 @@ int speakup_set_selection(struct tty_struct *tty)
|
|||
int i, ps, pe;
|
||||
struct vc_data *vc = vc_cons[fg_console].d;
|
||||
|
||||
xs = limit(xs, vc->vc_cols - 1);
|
||||
ys = limit(ys, vc->vc_rows - 1);
|
||||
xe = limit(xe, vc->vc_cols - 1);
|
||||
ye = limit(ye, vc->vc_rows - 1);
|
||||
ps = ys * vc->vc_size_row + (xs << 1);
|
||||
pe = ye * vc->vc_size_row + (xe << 1);
|
||||
spk_xs = limit(spk_xs, vc->vc_cols - 1);
|
||||
spk_ys = limit(spk_ys, vc->vc_rows - 1);
|
||||
spk_xe = limit(spk_xe, vc->vc_cols - 1);
|
||||
spk_ye = limit(spk_ye, vc->vc_rows - 1);
|
||||
ps = spk_ys * vc->vc_size_row + (spk_xs << 1);
|
||||
pe = spk_ye * vc->vc_size_row + (spk_xe << 1);
|
||||
|
||||
if (ps > pe) {
|
||||
/* make sel_start <= sel_end */
|
||||
|
|
|
|||
|
|
@ -116,7 +116,7 @@ static void start_serial_interrupt(int irq)
|
|||
outb(1, speakup_info.port_tts + UART_FCR); /* Turn FIFO On */
|
||||
}
|
||||
|
||||
void stop_serial_interrupt(void)
|
||||
void spk_stop_serial_interrupt(void)
|
||||
{
|
||||
if (speakup_info.port_tts == 0)
|
||||
return;
|
||||
|
|
@ -130,7 +130,7 @@ void stop_serial_interrupt(void)
|
|||
free_irq(serstate->irq, (void *) synth_readbuf_handler);
|
||||
}
|
||||
|
||||
int wait_for_xmitr(void)
|
||||
int spk_wait_for_xmitr(void)
|
||||
{
|
||||
int tmout = SPK_XMITR_TIMEOUT;
|
||||
if ((synth->alive) && (timeouts >= NUM_DISABLE_TIMEOUTS)) {
|
||||
|
|
@ -195,7 +195,7 @@ EXPORT_SYMBOL_GPL(spk_serial_in_nowait);
|
|||
|
||||
int spk_serial_out(const char ch)
|
||||
{
|
||||
if (synth->alive && wait_for_xmitr()) {
|
||||
if (synth->alive && spk_wait_for_xmitr()) {
|
||||
outb_p(ch, speakup_info.port_tts);
|
||||
return 1;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,34 +50,34 @@
|
|||
#define E_UNDEF -1
|
||||
|
||||
extern int speakup_thread(void *data);
|
||||
extern void reset_default_chars(void);
|
||||
extern void reset_default_chartab(void);
|
||||
extern void spk_reset_default_chars(void);
|
||||
extern void spk_reset_default_chartab(void);
|
||||
extern void synth_start(void);
|
||||
void synth_insert_next_index(int sent_num);
|
||||
void reset_index_count(int sc);
|
||||
void get_index_count(int *linecount, int *sentcount);
|
||||
extern int set_key_info(const u_char *key_info, u_char *k_buffer);
|
||||
extern char *strlwr(char *s);
|
||||
void spk_reset_index_count(int sc);
|
||||
void spk_get_index_count(int *linecount, int *sentcount);
|
||||
extern int spk_set_key_info(const u_char *key_info, u_char *k_buffer);
|
||||
extern char *spk_strlwr(char *s);
|
||||
extern char *speakup_s2i(char *start, int *dest);
|
||||
extern char *s2uchar(char *start, char *dest);
|
||||
extern char *xlate(char *s);
|
||||
extern char *spk_s2uchar(char *start, char *dest);
|
||||
extern char *spk_xlate(char *s);
|
||||
extern int speakup_kobj_init(void);
|
||||
extern void speakup_kobj_exit(void);
|
||||
extern int chartab_get_value(char *keyword);
|
||||
extern int spk_chartab_get_value(char *keyword);
|
||||
extern void speakup_register_var(struct var_t *var);
|
||||
extern void speakup_unregister_var(enum var_id_t var_id);
|
||||
extern struct st_var_header *get_var_header(enum var_id_t var_id);
|
||||
extern struct st_var_header *var_header_by_name(const char *name);
|
||||
extern struct punc_var_t *get_punc_var(enum var_id_t var_id);
|
||||
extern int set_num_var(int val, struct st_var_header *var, int how);
|
||||
extern int set_string_var(const char *page, struct st_var_header *var, int len);
|
||||
extern int set_mask_bits(const char *input, const int which, const int how);
|
||||
extern special_func special_handler;
|
||||
extern int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key);
|
||||
extern struct st_var_header *spk_get_var_header(enum var_id_t var_id);
|
||||
extern struct st_var_header *spk_var_header_by_name(const char *name);
|
||||
extern struct punc_var_t *spk_get_punc_var(enum var_id_t var_id);
|
||||
extern int spk_set_num_var(int val, struct st_var_header *var, int how);
|
||||
extern int spk_set_string_var(const char *page, struct st_var_header *var, int len);
|
||||
extern int spk_set_mask_bits(const char *input, const int which, const int how);
|
||||
extern special_func spk_special_handler;
|
||||
extern int spk_handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key);
|
||||
extern int synth_init(char *name);
|
||||
extern void synth_release(void);
|
||||
|
||||
extern void do_flush(void);
|
||||
extern void spk_do_flush(void);
|
||||
extern void speakup_start_ttys(void);
|
||||
extern void synth_buffer_add(char ch);
|
||||
extern void synth_buffer_clear(void);
|
||||
|
|
@ -90,35 +90,35 @@ extern void synth_write(const char *buf, size_t count);
|
|||
extern int synth_supports_indexing(void);
|
||||
|
||||
extern struct vc_data *spk_sel_cons;
|
||||
extern unsigned short xs, ys, xe, ye; /* our region points */
|
||||
extern unsigned short spk_xs, spk_ys, spk_xe, spk_ye; /* our region points */
|
||||
|
||||
extern wait_queue_head_t speakup_event;
|
||||
extern struct kobject *speakup_kobj;
|
||||
extern struct task_struct *speakup_task;
|
||||
extern const u_char key_defaults[];
|
||||
extern const u_char spk_key_defaults[];
|
||||
|
||||
/* Protect speakup synthesizer list */
|
||||
extern struct mutex spk_mutex;
|
||||
extern struct st_spk_t *speakup_console[];
|
||||
extern struct spk_synth *synth;
|
||||
extern char pitch_buff[];
|
||||
extern u_char *our_keys[];
|
||||
extern short punc_masks[];
|
||||
extern char str_caps_start[], str_caps_stop[];
|
||||
extern const struct st_bits_data punc_info[];
|
||||
extern u_char key_buf[600];
|
||||
extern char *characters[];
|
||||
extern char *default_chars[];
|
||||
extern char spk_pitch_buff[];
|
||||
extern u_char *spk_our_keys[];
|
||||
extern short spk_punc_masks[];
|
||||
extern char spk_str_caps_start[], spk_str_caps_stop[];
|
||||
extern const struct st_bits_data spk_punc_info[];
|
||||
extern u_char spk_key_buf[600];
|
||||
extern char *spk_characters[];
|
||||
extern char *spk_default_chars[];
|
||||
extern u_short spk_chartab[];
|
||||
extern int no_intr, say_ctrl, say_word_ctl, punc_level;
|
||||
extern int reading_punc, attrib_bleep, bleeps;
|
||||
extern int bleep_time, bell_pos;
|
||||
extern int spell_delay, key_echo;
|
||||
extern short punc_mask;
|
||||
extern short pitch_shift, synth_flags;
|
||||
extern bool quiet_boot;
|
||||
extern int spk_no_intr, spk_say_ctrl, spk_say_word_ctl, spk_punc_level;
|
||||
extern int spk_reading_punc, spk_attrib_bleep, spk_bleeps;
|
||||
extern int spk_bleep_time, spk_bell_pos;
|
||||
extern int spk_spell_delay, spk_key_echo;
|
||||
extern short spk_punc_mask;
|
||||
extern short spk_pitch_shift, synth_flags;
|
||||
extern bool spk_quiet_boot;
|
||||
extern char *synth_name;
|
||||
extern struct bleep unprocessed_sound;
|
||||
extern struct bleep spk_unprocessed_sound;
|
||||
|
||||
/* Prototypes from fakekey.c. */
|
||||
int speakup_add_virtual_keyboard(void);
|
||||
|
|
|
|||
|
|
@ -182,9 +182,9 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
struct var_t *full_time;
|
||||
struct var_t *jiffy_delta;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
full_time = get_var(FULL);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
full_time = spk_get_var(FULL);
|
||||
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ static int synth_probe(struct spk_synth *synth)
|
|||
{
|
||||
int failed;
|
||||
|
||||
failed = serial_synth_probe(synth);
|
||||
failed = spk_serial_synth_probe(synth);
|
||||
if (failed == 0) {
|
||||
spk_synth_immediate(synth, "\033=R\r");
|
||||
mdelay(100);
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ static struct spk_synth synth_apollo = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = do_catch_up,
|
||||
|
|
@ -145,9 +145,9 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int delay_time_val = 0;
|
||||
int jiffy_delta_val = 0;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
full_time = get_var(FULL);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
full_time = spk_get_var(FULL);
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
spk_unlock(flags);
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ static int synth_probe(struct spk_synth *synth)
|
|||
{
|
||||
int failed = 0;
|
||||
|
||||
failed = serial_synth_probe(synth);
|
||||
failed = spk_serial_synth_probe(synth);
|
||||
if (failed == 0)
|
||||
synth_version(synth);
|
||||
synth->alive = !failed;
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ static struct spk_synth synth_bns = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = spk_do_catch_up,
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ static struct spk_synth synth_decext = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = do_catch_up,
|
||||
|
|
@ -162,8 +162,8 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int jiffy_delta_val = 0;
|
||||
int delay_time_val = 0;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
|
|
|
|||
|
|
@ -375,8 +375,8 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int jiffy_delta_val;
|
||||
int delay_time_val;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
spk_unlock(flags);
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ static struct spk_synth synth_dectlk = {
|
|||
.vars = vars,
|
||||
.default_pitch = ap_defaults,
|
||||
.default_vol = g5_defaults,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = do_catch_up,
|
||||
|
|
@ -214,8 +214,8 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int jiffy_delta_val;
|
||||
int delay_time_val;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
spk_unlock(flags);
|
||||
|
|
|
|||
|
|
@ -198,8 +198,8 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int jiffy_delta_val;
|
||||
int delay_time_val;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
spk_unlock(flags);
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ static struct spk_synth synth_dummy = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = spk_do_catch_up,
|
||||
|
|
|
|||
|
|
@ -184,9 +184,9 @@ static void do_catch_up(struct spk_synth *synth)
|
|||
int full_time_val;
|
||||
int jiffy_delta_val;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
delay_time = get_var(DELAY);
|
||||
full_time = get_var(FULL);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
full_time = spk_get_var(FULL);
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
spk_unlock(flags);
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ static int synth_probe(struct spk_synth *synth)
|
|||
{
|
||||
int failed = 0;
|
||||
|
||||
failed = serial_synth_probe(synth);
|
||||
failed = spk_serial_synth_probe(synth);
|
||||
if (failed == 0)
|
||||
synth_interrogate(synth);
|
||||
synth->alive = !failed;
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ static struct spk_synth synth_spkout = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = spk_do_catch_up,
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ static struct spk_synth synth_txprt = {
|
|||
.startup = SYNTH_START,
|
||||
.checkval = SYNTH_CHECK,
|
||||
.vars = vars,
|
||||
.probe = serial_synth_probe,
|
||||
.probe = spk_serial_synth_probe,
|
||||
.release = spk_serial_release,
|
||||
.synth_immediate = spk_synth_immediate,
|
||||
.catch_up = spk_do_catch_up,
|
||||
|
|
|
|||
|
|
@ -45,8 +45,8 @@
|
|||
#define KT_SPKUP 15
|
||||
|
||||
extern const struct old_serial_port *spk_serial_init(int index);
|
||||
extern void stop_serial_interrupt(void);
|
||||
extern int wait_for_xmitr(void);
|
||||
extern void spk_stop_serial_interrupt(void);
|
||||
extern int spk_wait_for_xmitr(void);
|
||||
extern unsigned char spk_serial_in(void);
|
||||
extern unsigned char spk_serial_in_nowait(void);
|
||||
extern int spk_serial_out(const char ch);
|
||||
|
|
@ -55,13 +55,13 @@ extern void spk_serial_release(void);
|
|||
extern char synth_buffer_getc(void);
|
||||
extern char synth_buffer_peek(void);
|
||||
extern int synth_buffer_empty(void);
|
||||
extern struct var_t *get_var(enum var_id_t var_id);
|
||||
extern struct var_t *spk_get_var(enum var_id_t var_id);
|
||||
extern ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr,
|
||||
char *buf);
|
||||
extern ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
|
||||
const char *buf, size_t count);
|
||||
|
||||
extern int serial_synth_probe(struct spk_synth *synth);
|
||||
extern int spk_serial_synth_probe(struct spk_synth *synth);
|
||||
extern const char *spk_synth_immediate(struct spk_synth *synth, const char *buff);
|
||||
extern void spk_do_catch_up(struct spk_synth *synth);
|
||||
extern void spk_synth_flush(struct spk_synth *synth);
|
||||
|
|
|
|||
|
|
@ -20,9 +20,9 @@
|
|||
#define MAXSYNTHS 16 /* Max number of synths in array. */
|
||||
static struct spk_synth *synths[MAXSYNTHS];
|
||||
struct spk_synth *synth;
|
||||
char pitch_buff[32] = "";
|
||||
char spk_pitch_buff[32] = "";
|
||||
static int module_status;
|
||||
bool quiet_boot;
|
||||
bool spk_quiet_boot;
|
||||
|
||||
struct speakup_info_t speakup_info = {
|
||||
.spinlock = __SPIN_LOCK_UNLOCKED(speakup_info.spinlock),
|
||||
|
|
@ -32,7 +32,7 @@ EXPORT_SYMBOL_GPL(speakup_info);
|
|||
|
||||
static int do_synth_init(struct spk_synth *in_synth);
|
||||
|
||||
int serial_synth_probe(struct spk_synth *synth)
|
||||
int spk_serial_synth_probe(struct spk_synth *synth)
|
||||
{
|
||||
const struct old_serial_port *ser;
|
||||
int failed = 0;
|
||||
|
|
@ -59,7 +59,7 @@ int serial_synth_probe(struct spk_synth *synth)
|
|||
synth->alive = 1;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(serial_synth_probe);
|
||||
EXPORT_SYMBOL_GPL(spk_serial_synth_probe);
|
||||
|
||||
/* Main loop of the progression thread: keep eating from the buffer
|
||||
* and push to the serial port, waiting as needed
|
||||
|
|
@ -79,9 +79,9 @@ void spk_do_catch_up(struct spk_synth *synth)
|
|||
int delay_time_val;
|
||||
int full_time_val;
|
||||
|
||||
jiffy_delta = get_var(JIFFY);
|
||||
full_time = get_var(FULL);
|
||||
delay_time = get_var(DELAY);
|
||||
jiffy_delta = spk_get_var(JIFFY);
|
||||
full_time = spk_get_var(FULL);
|
||||
delay_time = spk_get_var(DELAY);
|
||||
|
||||
spk_lock(flags);
|
||||
jiffy_delta_val = jiffy_delta->u.n.value;
|
||||
|
|
@ -139,7 +139,7 @@ const char *spk_synth_immediate(struct spk_synth *synth, const char *buff)
|
|||
while ((ch = *buff)) {
|
||||
if (ch == '\n')
|
||||
ch = synth->procspeech;
|
||||
if (wait_for_xmitr())
|
||||
if (spk_wait_for_xmitr())
|
||||
outb(ch, speakup_info.port_tts);
|
||||
else
|
||||
return buff;
|
||||
|
|
@ -166,7 +166,7 @@ int spk_synth_is_alive_restart(struct spk_synth *synth)
|
|||
{
|
||||
if (synth->alive)
|
||||
return 1;
|
||||
if (!synth->alive && wait_for_xmitr() > 0) {
|
||||
if (!synth->alive && spk_wait_for_xmitr() > 0) {
|
||||
/* restart */
|
||||
synth->alive = 1;
|
||||
synth_printf("%s", synth->init);
|
||||
|
|
@ -192,20 +192,20 @@ void synth_start(void)
|
|||
synth_buffer_clear();
|
||||
return;
|
||||
}
|
||||
trigger_time = get_var(TRIGGER);
|
||||
trigger_time = spk_get_var(TRIGGER);
|
||||
if (!timer_pending(&thread_timer))
|
||||
mod_timer(&thread_timer, jiffies +
|
||||
msecs_to_jiffies(trigger_time->u.n.value));
|
||||
}
|
||||
|
||||
void do_flush(void)
|
||||
void spk_do_flush(void)
|
||||
{
|
||||
speakup_info.flushing = 1;
|
||||
synth_buffer_clear();
|
||||
if (synth->alive) {
|
||||
if (pitch_shift) {
|
||||
synth_printf("%s", pitch_buff);
|
||||
pitch_shift = 0;
|
||||
if (spk_pitch_shift) {
|
||||
synth_printf("%s", spk_pitch_buff);
|
||||
spk_pitch_shift = 0;
|
||||
}
|
||||
}
|
||||
wake_up_interruptible_all(&speakup_event);
|
||||
|
|
@ -241,7 +241,7 @@ EXPORT_SYMBOL_GPL(synth_printf);
|
|||
static int index_count;
|
||||
static int sentence_count;
|
||||
|
||||
void reset_index_count(int sc)
|
||||
void spk_reset_index_count(int sc)
|
||||
{
|
||||
static int first = 1;
|
||||
if (first)
|
||||
|
|
@ -277,7 +277,7 @@ void synth_insert_next_index(int sent_num)
|
|||
}
|
||||
}
|
||||
|
||||
void get_index_count(int *linecount, int *sentcount)
|
||||
void spk_get_index_count(int *linecount, int *sentcount)
|
||||
{
|
||||
int ind = synth->get_index();
|
||||
if (ind) {
|
||||
|
|
@ -384,7 +384,7 @@ static int do_synth_init(struct spk_synth *in_synth)
|
|||
for (var = synth->vars;
|
||||
(var->var_id >= 0) && (var->var_id < MAXVARS); var++)
|
||||
speakup_register_var(var);
|
||||
if (!quiet_boot)
|
||||
if (!spk_quiet_boot)
|
||||
synth_printf("%s found\n", synth->long_name);
|
||||
if (synth->attributes.name
|
||||
&& sysfs_create_group(speakup_kobj, &(synth->attributes)) < 0)
|
||||
|
|
@ -412,7 +412,7 @@ void synth_release(void)
|
|||
sysfs_remove_group(speakup_kobj, &(synth->attributes));
|
||||
for (var = synth->vars; var->var_id != MAXVARS; var++)
|
||||
speakup_unregister_var(var->var_id);
|
||||
stop_serial_interrupt();
|
||||
spk_stop_serial_interrupt();
|
||||
synth->release();
|
||||
synth = NULL;
|
||||
}
|
||||
|
|
@ -460,4 +460,4 @@ void synth_remove(struct spk_synth *in_synth)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(synth_remove);
|
||||
|
||||
short punc_masks[] = { 0, SOME, MOST, PUNC, PUNC|B_SYM };
|
||||
short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC|B_SYM };
|
||||
|
|
|
|||
|
|
@ -23,8 +23,8 @@ int speakup_thread(void *data)
|
|||
DEFINE_WAIT(wait);
|
||||
while (1) {
|
||||
spk_lock(flags);
|
||||
our_sound = unprocessed_sound;
|
||||
unprocessed_sound.active = 0;
|
||||
our_sound = spk_unprocessed_sound;
|
||||
spk_unprocessed_sound.active = 0;
|
||||
prepare_to_wait(&speakup_event, &wait,
|
||||
TASK_INTERRUPTIBLE);
|
||||
should_break = kthread_should_stop() ||
|
||||
|
|
|
|||
|
|
@ -16,24 +16,24 @@ static struct st_var_header var_headers[] = {
|
|||
{ "ex_num", EXNUMBER, VAR_PROC, NULL, NULL },
|
||||
{ "characters", CHARS, VAR_PROC, NULL, NULL },
|
||||
{ "synth_direct", SYNTH_DIRECT, VAR_PROC, NULL, NULL },
|
||||
{ "caps_start", CAPS_START, VAR_STRING, str_caps_start, NULL },
|
||||
{ "caps_stop", CAPS_STOP, VAR_STRING, str_caps_stop, NULL },
|
||||
{ "caps_start", CAPS_START, VAR_STRING, spk_str_caps_start, NULL },
|
||||
{ "caps_stop", CAPS_STOP, VAR_STRING, spk_str_caps_stop, NULL },
|
||||
{ "delay_time", DELAY, VAR_TIME, NULL, NULL },
|
||||
{ "trigger_time", TRIGGER, VAR_TIME, NULL, NULL },
|
||||
{ "jiffy_delta", JIFFY, VAR_TIME, NULL, NULL },
|
||||
{ "full_time", FULL, VAR_TIME, NULL, NULL },
|
||||
{ "spell_delay", SPELL_DELAY, VAR_NUM, &spell_delay, NULL },
|
||||
{ "bleeps", BLEEPS, VAR_NUM, &bleeps, NULL },
|
||||
{ "attrib_bleep", ATTRIB_BLEEP, VAR_NUM, &attrib_bleep, NULL },
|
||||
{ "bleep_time", BLEEP_TIME, VAR_TIME, &bleep_time, NULL },
|
||||
{ "spell_delay", SPELL_DELAY, VAR_NUM, &spk_spell_delay, NULL },
|
||||
{ "bleeps", BLEEPS, VAR_NUM, &spk_bleeps, NULL },
|
||||
{ "attrib_bleep", ATTRIB_BLEEP, VAR_NUM, &spk_attrib_bleep, NULL },
|
||||
{ "bleep_time", BLEEP_TIME, VAR_TIME, &spk_bleep_time, NULL },
|
||||
{ "cursor_time", CURSOR_TIME, VAR_TIME, NULL, NULL },
|
||||
{ "punc_level", PUNC_LEVEL, VAR_NUM, &punc_level, NULL },
|
||||
{ "reading_punc", READING_PUNC, VAR_NUM, &reading_punc, NULL },
|
||||
{ "say_control", SAY_CONTROL, VAR_NUM, &say_ctrl, NULL },
|
||||
{ "say_word_ctl", SAY_WORD_CTL, VAR_NUM, &say_word_ctl, NULL },
|
||||
{ "no_interrupt", NO_INTERRUPT, VAR_NUM, &no_intr, NULL },
|
||||
{ "key_echo", KEY_ECHO, VAR_NUM, &key_echo, NULL },
|
||||
{ "bell_pos", BELL_POS, VAR_NUM, &bell_pos, NULL },
|
||||
{ "punc_level", PUNC_LEVEL, VAR_NUM, &spk_punc_level, NULL },
|
||||
{ "reading_punc", READING_PUNC, VAR_NUM, &spk_reading_punc, NULL },
|
||||
{ "say_control", SAY_CONTROL, VAR_NUM, &spk_say_ctrl, NULL },
|
||||
{ "say_word_ctl", SAY_WORD_CTL, VAR_NUM, &spk_say_word_ctl, NULL },
|
||||
{ "no_interrupt", NO_INTERRUPT, VAR_NUM, &spk_no_intr, NULL },
|
||||
{ "key_echo", KEY_ECHO, VAR_NUM, &spk_key_echo, NULL },
|
||||
{ "bell_pos", BELL_POS, VAR_NUM, &spk_bell_pos, NULL },
|
||||
{ "rate", RATE, VAR_NUM, NULL, NULL },
|
||||
{ "pitch", PITCH, VAR_NUM, NULL, NULL },
|
||||
{ "vol", VOL, VAR_NUM, NULL, NULL },
|
||||
|
|
@ -58,7 +58,7 @@ static struct punc_var_t punc_vars[] = {
|
|||
{ -1, -1 },
|
||||
};
|
||||
|
||||
int chartab_get_value(char *keyword)
|
||||
int spk_chartab_get_value(char *keyword)
|
||||
{
|
||||
int value = 0;
|
||||
|
||||
|
|
@ -103,11 +103,11 @@ void speakup_register_var(struct var_t *var)
|
|||
p_header->data = var;
|
||||
switch (p_header->var_type) {
|
||||
case VAR_STRING:
|
||||
set_string_var(nothing, p_header, 0);
|
||||
spk_set_string_var(nothing, p_header, 0);
|
||||
break;
|
||||
case VAR_NUM:
|
||||
case VAR_TIME:
|
||||
set_num_var(0, p_header, E_DEFAULT);
|
||||
spk_set_num_var(0, p_header, E_DEFAULT);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -123,7 +123,7 @@ void speakup_unregister_var(enum var_id_t var_id)
|
|||
p_header->data = NULL;
|
||||
}
|
||||
|
||||
struct st_var_header *get_var_header(enum var_id_t var_id)
|
||||
struct st_var_header *spk_get_var_header(enum var_id_t var_id)
|
||||
{
|
||||
struct st_var_header *p_header;
|
||||
if (var_id < 0 || var_id >= MAXVARS)
|
||||
|
|
@ -134,7 +134,7 @@ struct st_var_header *get_var_header(enum var_id_t var_id)
|
|||
return p_header;
|
||||
}
|
||||
|
||||
struct st_var_header *var_header_by_name(const char *name)
|
||||
struct st_var_header *spk_var_header_by_name(const char *name)
|
||||
{
|
||||
int i;
|
||||
struct st_var_header *where = NULL;
|
||||
|
|
@ -151,15 +151,15 @@ struct st_var_header *var_header_by_name(const char *name)
|
|||
return where;
|
||||
}
|
||||
|
||||
struct var_t *get_var(enum var_id_t var_id)
|
||||
struct var_t *spk_get_var(enum var_id_t var_id)
|
||||
{
|
||||
BUG_ON(var_id < 0 || var_id >= MAXVARS);
|
||||
BUG_ON(!var_ptrs[var_id]);
|
||||
return var_ptrs[var_id]->data;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(get_var);
|
||||
EXPORT_SYMBOL_GPL(spk_get_var);
|
||||
|
||||
struct punc_var_t *get_punc_var(enum var_id_t var_id)
|
||||
struct punc_var_t *spk_get_punc_var(enum var_id_t var_id)
|
||||
{
|
||||
struct punc_var_t *rv = NULL;
|
||||
struct punc_var_t *where;
|
||||
|
|
@ -175,7 +175,7 @@ struct punc_var_t *get_punc_var(enum var_id_t var_id)
|
|||
}
|
||||
|
||||
/* handlers for setting vars */
|
||||
int set_num_var(int input, struct st_var_header *var, int how)
|
||||
int spk_set_num_var(int input, struct st_var_header *var, int how)
|
||||
{
|
||||
int val;
|
||||
short ret = 0;
|
||||
|
|
@ -217,7 +217,7 @@ int set_num_var(int input, struct st_var_header *var, int how)
|
|||
if (p_val != NULL)
|
||||
*p_val = val;
|
||||
if (var->var_id == PUNC_LEVEL) {
|
||||
punc_mask = punc_masks[val];
|
||||
spk_punc_mask = spk_punc_masks[val];
|
||||
return ret;
|
||||
}
|
||||
if (var_data->u.n.multiplier != 0)
|
||||
|
|
@ -232,7 +232,7 @@ int set_num_var(int input, struct st_var_header *var, int how)
|
|||
if (!var_data->u.n.synth_fmt)
|
||||
return ret;
|
||||
if (var->var_id == PITCH)
|
||||
cp = pitch_buff;
|
||||
cp = spk_pitch_buff;
|
||||
else
|
||||
cp = buf;
|
||||
if (!var_data->u.n.out_str)
|
||||
|
|
@ -244,7 +244,7 @@ int set_num_var(int input, struct st_var_header *var, int how)
|
|||
return ret;
|
||||
}
|
||||
|
||||
int set_string_var(const char *page, struct st_var_header *var, int len)
|
||||
int spk_set_string_var(const char *page, struct st_var_header *var, int len)
|
||||
{
|
||||
int ret = 0;
|
||||
struct var_t *var_data = var->data;
|
||||
|
|
@ -267,21 +267,21 @@ int set_string_var(const char *page, struct st_var_header *var, int len)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/* set_mask_bits sets or clears the punc/delim/repeat bits,
|
||||
/* spk_set_mask_bits sets or clears the punc/delim/repeat bits,
|
||||
* if input is null uses the defaults.
|
||||
* values for how: 0 clears bits of chars supplied,
|
||||
* 1 clears allk, 2 sets bits for chars */
|
||||
int set_mask_bits(const char *input, const int which, const int how)
|
||||
int spk_set_mask_bits(const char *input, const int which, const int how)
|
||||
{
|
||||
u_char *cp;
|
||||
short mask = punc_info[which].mask;
|
||||
short mask = spk_punc_info[which].mask;
|
||||
if (how&1) {
|
||||
for (cp = (u_char *)punc_info[3].value; *cp; cp++)
|
||||
for (cp = (u_char *)spk_punc_info[3].value; *cp; cp++)
|
||||
spk_chartab[*cp] &= ~mask;
|
||||
}
|
||||
cp = (u_char *)input;
|
||||
if (cp == 0)
|
||||
cp = punc_info[which].value;
|
||||
cp = spk_punc_info[which].value;
|
||||
else {
|
||||
for ( ; *cp; cp++) {
|
||||
if (*cp < SPACE)
|
||||
|
|
@ -308,7 +308,7 @@ int set_mask_bits(const char *input, const int which, const int how)
|
|||
return 0;
|
||||
}
|
||||
|
||||
char *strlwr(char *s)
|
||||
char *spk_strlwr(char *s)
|
||||
{
|
||||
char *p;
|
||||
if (s == NULL)
|
||||
|
|
@ -341,7 +341,7 @@ char *speakup_s2i(char *start, int *dest)
|
|||
return start;
|
||||
}
|
||||
|
||||
char *s2uchar(char *start, char *dest)
|
||||
char *spk_s2uchar(char *start, char *dest)
|
||||
{
|
||||
int val = 0;
|
||||
while (*start && *start <= SPACE)
|
||||
|
|
@ -357,7 +357,7 @@ char *s2uchar(char *start, char *dest)
|
|||
return start;
|
||||
}
|
||||
|
||||
char *xlate(char *s)
|
||||
char *spk_xlate(char *s)
|
||||
{
|
||||
static const char finds[] = "nrtvafe";
|
||||
static const char subs[] = "\n\r\t\013\001\014\033";
|
||||
|
|
|
|||
Loading…
Reference in a new issue