static void
do_add(char *line, int len)
{
int n;
int modifier;
KeySym *kslist;
union op *uop;
struct op_addmodifier *opam;
if (len < 6 || !line || *line == '\0') { /* Lock=a minimum */
badmsg0 ("add modifier input line");
return;
}
n = skip_chars (line, len);
if (n < 1) {
badmsg ("add modifier name %s", line);
return;
}
modifier = parse_modifier (line, n);
if (modifier < 0) {
badmsgn ("add modifier name '%s', not allowed", line, n);
return;
}
line += n, len -= n;
n = skip_until_char (line, len, '=');
if (n < 0) {
badmsg0 ("add modifier = keysym");
return;
}
n++; /* skip = */
n += skip_space (line+n, len-n);
line += n, len -= n;
if (get_keysym_list (line, len, &n, &kslist) < 0)
return;
if (n == 0) {
badmsg0 ("add modifier keysym list (empty)");
return;
}
uop = AllocStruct (union op);
if (!uop) {
badmsg ("attempt to allocate %ld byte addmodifier opcode",
(long) sizeof (struct op_addmodifier));
return;
}
opam = &uop->addmodifier;
opam->type = doAddModifier;
opam->modifier = modifier;
opam->count = n;
opam->keysyms = kslist;
add_to_work_queue (uop);
}
void compile_modifier(const char *mod_str) {
enum modifier mod;
if (!parse_modifier(mod_str, &mod)) {
fprintf(stderr, "Invlalid modifier '%s'\n", mod_str);
exit(1);
}
if (!set_pedal_type(KEY_TYPE)) {
fprintf(stderr, "Invalid combination of options\n");
usage();
}
curr_pedal->data[2] |= mod;
}
static void parsing(const char **format, t_opt *opt, int *ret)
{
*ret = 0;
if (parse_attr(format, &(opt->attri)))
*ret = 1;
if (parse_width(format, opt))
*ret = 1;
if (parse_pres(format, opt))
*ret = 1;
if (ft_check_charset(**format, "lhjz"))
{
if (parse_modifier(format, opt))
*ret = 1;
}
}
static void
do_clear(char *line, int len)
{
int n;
int modifier;
union op *uop;
struct op_clearmodifier *opcm;
if (len < 4 || !line || *line == '\0') { /* Lock minimum */
badmsg0 ("clear modifier input line");
return;
}
n = skip_chars (line, len);
modifier = parse_modifier (line, n);
if (modifier < 0) {
badmsgn ("clear modifier name '%s'", line, n);
return;
}
n += skip_space (line+n, len-n);
if (n != len) {
badmsgn ("extra argument '%s' to clear modifier", line+n, len-n);
/* okay to continue */
}
uop = AllocStruct (union op);
if (!uop) {
badmsg ("attempt to allocate %ld byte clearmodifier opcode",
(long) sizeof (struct op_clearmodifier));
return;
}
opcm = &uop->clearmodifier;
opcm->type = doClearModifier;
opcm->modifier = modifier;
add_to_work_queue (uop);
}
string
r_language_rep::get_color (tree t, int start, int end) {
static bool setup_done= false;
if (!setup_done) {
r_color_setup_constants (colored);
r_color_setup_keywords (colored);
r_color_setup_otherlexeme (colored);
setup_done= true;
}
static string none= "";
if (start >= end) return none;
string s= t->label;
string r1=s(0,start) ;
int pos=0;int opos;
bool backquote= false;
bool after_backquote;
bool postfix= false;
bool possible_function= true;
bool possible_type= false;
bool possible_class= false;
bool possible_future_type= false;
bool possible_future_function= true;
bool possible_future_class= false;
string type;
bool is_markup;
#if 0
// There isn't much point to the following, because its only effet is pos and type, and both are reset below.
do {
do {
opos=pos;
parse_string (s, pos);
if (opos<pos) break;
parse_comment_single_line (s, pos);
if (opos < pos) {
type= "comment";
break;
}
pos++;
} while(false);
} while( pos<N(s) );
#endif
pos=0;
do {
type= none;
do {
after_backquote= backquote;
possible_function= possible_future_function;
possible_type= possible_future_type;
possible_class= possible_future_class;
opos= pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_string (s, pos);
if (opos<pos) {
type= "string";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_number (s, pos);
if (opos<pos) {
type= "number";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_comment_single_line (s, pos);
if (opos<pos) {
type= "comment";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
break;
}
parse_modifier (colored, s, pos);
if (opos<pos) {
type="keyword";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
possible_function= false;
break;
}
parse_postfix (colored, s, pos);
if (opos<pos) {
type="keyword";
backquote= false;
postfix= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
possible_function= false;
possible_future_class= false;
break;
}
parse_class (colored, s, pos);
if (opos<pos) {
type= "keyword";
backquote=false;
postfix=false;
possible_future_type= false;
possible_type= false;
possible_future_class=true;
possible_future_function= false;
break;
}
parse_keyword (colored, s, pos);
if (opos<pos) {
type= "keyword";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
possible_function= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_other_op_assign (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "op assign" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_other_op_index (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "op index" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_other_lexeme (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "operator" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_constant (colored, s, pos);
if (opos<pos) {
type= "constant";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_backquote (s, pos);
if (opos<pos) {
backquote= true;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_identifier_or_markup (colored, s, pos, postfix, is_markup);
if (opos<pos) {
if (is_markup) {type= "identifier_markup";} else type= "identifier";
backquote= false;
postfix= false;
possible_future_function=false;
possible_future_class= false;
break;
}
parse_parenthesized (s, pos);
// stops after well parenthesized ) or before // or /{ or " or /"
if (opos<pos && pos<=start) {
type="left_parenthesis";
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_class= false;
break;
}
if (opos<pos && possible_type==true)
return "dark green";
if (opos<pos && after_backquote)
return none;
backquote= false;
postfix= false;
pos= opos;
pos++;
} while (false); // This while() is so that we can easily escape with break.
} while (pos<=start);
if (possible_type) return "dark green";
if (type=="string") return "#a06040";
if (type=="operator") return "red";
if (type=="op assign") return "dark green";
if (type=="op index") return "dark blue";
if (type=="comment") return "brown";
if (type=="keyword" && !after_backquote) return "#8020c0";
if (type=="other_lexeme") return none;
if (type=="constant") return "#2060c0";
if (type=="number") return "#2060c0";
if (type=="left_parenthesis") return none;
if (type=="identifier" && !possible_function && !possible_class ) return none;
if (type=="identifier_markup" && !possible_function && !possible_class ) return COLOR_MARKUP;
if ( (type=="identifier" || type=="identifier_markup") && possible_function) {
possible_function= false;
do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) { possible_function= true; break; }
parse_number (s, pos);
if (opos<pos) { possible_function= true; break; }
parse_constant (colored, s, pos);
if (opos<pos) { possible_function= true; break; }
parse_comment_single_line (s, pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) { possible_function= true; break; }
} while (false);
} while (opos != pos);
if (!possible_function) {
if (type=="identifier") {return none;}
else return COLOR_MARKUP; // type=="identifier_markup"
} else do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) break;
parse_number(s,pos);
if (opos<pos) break;
parse_constant (colored, s, pos);
if (opos<pos) break;
parse_comment_single_line(s,pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) break;
if (type=="identifier") {return none;}
else return COLOR_MARKUP;
} while (false);
}
while (pos<N(s));
} // type==identifier || type==identifier_markup && possible function
if ( (type=="identifier" || type=="identifier_markup") && possible_class) {
do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) break;
parse_number(s,pos);
if (opos<pos) break;
parse_constant (colored, s, pos);
if (opos<pos) break;
parse_comment_single_line(s,pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) break;
if (type=="identifier") {return none;}
else return COLOR_MARKUP;
} while (false);
}
while (pos<N(s));
}
if (type=="identifier_markup") {return COLOR_MARKUP;}
else return none;
}
static void
do_remove(char *line, int len)
{
int n;
int nc;
int i;
int tot;
int modifier;
KeySym *kslist;
KeyCode *kclist;
union op *uop;
struct op_removemodifier *oprm;
if (len < 6 || !line || *line == '\0') { /* Lock=a minimum */
badmsg0 ("remove modifier input line");
return;
}
n = skip_chars (line, len);
if (n < 1) {
badmsg ("remove modifier name %s", line);
return;
}
modifier = parse_modifier (line, n);
if (modifier < 0) {
badmsgn ("remove modifier name '%s', not allowed", line, n);
return;
}
line += n, len -= n;
n = skip_until_char (line, len, '=');
if (n < 0) {
badmsg0 ("remove modifier = keysym");
return;
}
n++;
n += skip_space (line+n, len-n);
line += n, len -= n;
if (get_keysym_list (line, len, &n, &kslist) < 0)
return;
if (n == 0) {
badmsg0 ("remove modifier keysym list (empty)");
return;
}
/*
* unlike the add command, we have to now evaluate the keysyms
*/
kclist = (KeyCode *) malloc (n * sizeof (KeyCode));
if (!kclist) {
badmsg ("attempt to allocate %ld byte keycode list",
(long) (n * sizeof (KeyCode)));
free ((char *) kslist);
return;
}
tot = n;
nc = 0;
for (i = 0; i < n; i++) {
int num_kcs;
KeyCode *kcs;
kcs = KeysymToKeycodes (dpy, kslist[i], &num_kcs);
if (num_kcs == 0) {
char *tmpname = XKeysymToString (kslist[i]);
badmsg ("keysym in remove modifier list '%s', no corresponding keycodes",
tmpname ? tmpname : "?");
continue;
}
if (verbose) {
int j;
char *tmpname = XKeysymToString (kslist[i]);
printf ("! Keysym %s (0x%lx) corresponds to keycode(s)",
tmpname ? tmpname : "?", (long) kslist[i]);
for (j = 0; j < num_kcs; j++)
printf(" 0x%x", kcs[j]);
printf("\n");
}
if (nc + num_kcs > tot) {
tot = nc + num_kcs;
kclist = (KeyCode *)realloc((char *)kclist, tot * sizeof(KeyCode));
if (!kclist) {
badmsg ("attempt to allocate %ld byte keycode list",
(long) (tot * sizeof (KeyCode)));
free ((char *) kslist);
return;
}
}
while (--num_kcs >= 0)
kclist[nc++] = *kcs++; /* okay, add it to list */
}
free ((char *) kslist); /* all done with it */
uop = AllocStruct (union op);
if (!uop) {
badmsg ("attempt to allocate %ld byte removemodifier opcode",
(long) sizeof (struct op_removemodifier));
return;
}
oprm = &uop->removemodifier;
oprm->type = doRemoveModifier;
oprm->modifier = modifier;
oprm->count = nc;
oprm->keycodes = kclist;
add_to_work_queue (uop);
}
