static char *
trim_comments(char *line)
{
char *ptr;
char *s1;
char *s2;
while ((ptr = strchr(line, '\n')) != NULL ||
(ptr = strchr(line, '\r')) != NULL) {
*ptr = 0;
}
line = skip_spaces(line);
if (*line == 0 || *line == '#') {
return NULL;
}
s1 = skip_chars(line);
if (*(s2 = skip_spaces(s1)) == 0) {
*s1 = 0;
return line;
}
if (*s2 == '#') {
return NULL;
}
*skip_chars(s2) = 0;
return s2;
}
void
handle_line(char *line, /* string to parse */
int len) /* length of line */
{
int n;
struct dt *dtp;
n = skip_chars (line, len);
if (n < 0) {
badmsg ("input line '%s'", line);
return;
}
for (dtp = dispatch_table; dtp->command != NULL; dtp++) {
if (n == dtp->length &&
strncmp (line, dtp->command, dtp->length) == 0) {
n += skip_space (line+n, len-n);
line += n, len -= n;
(*(dtp->proc)) (line, len);
return;
}
}
fprintf (stderr, "%s: unknown command on line %s:%d\n",
ProgramName, inputFilename, lineno+1);
parse_errors++;
}
int TextBuffer::currentIndent()
{
int bol=pointBOL();
int eol=pointEOL();
String txt=getTextSubstring(bol,eol);
return skip_chars(txt, T(" \t"), 0, txt.length());
}
static int read_key (struct cw_KTV_Reader *r, char *key, int max_len)
{
int c,n;
do {
c = skip_chars (r, " \t\n\a\v");
if (c == '#') {
c = skip_to_chars (r, "\n\a");
} else {
break;
}
} while (c != EOF);
unget_char(r,c);
c=get_char_q(r);
n=0;
while(c!=EOF && n<max_len){
if (!r->quote && !isalnum(c) && !strchr("._/-()@#|{}[]\\",c)){
unget_char(r,c);
break;
}
key[n]=c;
c=get_char_q(r);
n++;
}
key[n]=0;
return n;
}
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);
}
static int
skip_word (const char *s, int len)
{
register int n;
n = skip_chars (s, len);
return (n + skip_space (s+n, len-n));
}
static int read_val(struct cw_KTV_Reader *r, char *val, int max_len){
int c,n,quote;
c = skip_to_colon(r);
if (c==-1)
return -1;
c = skip_chars (r, " \t");
if (c=='"'){
quote=1;
c=get_char(r);
}
else{
quote=0;
}
n=0;
while(c!=EOF && n<max_len){
if (quote && c=='"'){
break;
}
if (c=='\n'){
break;
}
if (quote){
if (c=='\\'){
c = get_char(r);
switch(c){
case 'n':
c='\n';
break;
case '\\':
break;
case '"':
break;
default:
unget_char(r,c);
c='\\';
}
}
}
val[n++]=c;
c=get_char(r);
}
if(!quote && n>0){
while(n>0){
if (isspace(val[n-1]))
n--;
else
break;
}
}
val[n]=0;
return n;
}
static char *
host_only(char *line)
{
char *s1;
char *s2;
line = skip_spaces(line);
if (*line == 0 || *line == '#') {
return NULL;
}
s1 = skip_chars(line);
if (*(s2 = skip_spaces(s1)) == 0) {
*s1 = 0;
return line;
}
if (*s2 == '#') {
return NULL;
}
*skip_chars(s2) = 0;
return s2;
}
static int skip_to_colon(struct cw_KTV_Reader * r)
{
int c;
c = skip_chars (r, " \t");
if (c!=':' && c!='='){
if (c=='\n'){
unget_char(r,c);
sprintf(r->error,"Unexpected EOL, colon or equal sign expected.");
return -1;
}
sprintf(r->error,"Colon or equal sign expected.");
return -1;
}
return c;
}
static int read_type(struct cw_KTV_Reader * r, char *type, int max_len)
{
int c,n;
c = skip_to_colon(r);
if (c==-1)
return -1;
if (c=='='){
unget_char(r,c);
return sprintf(type,"%s","Str");
}
c = skip_chars (r, " \t");
if (c==':'){
unget_char(r,c);
sprintf(type,"%s","Str");
return 0;
}
if (!isalpha(c)){
if (c=='\n'){
unget_char(r,c);
/*sprintf(p->error,"Error at line %d, pos %d: Unexpected EOL.", p->line, p->pos);*/
return -1;
}
/*sprintf(p->error,"Error at line %d, pos %d: Letter expected.", p->line, p->pos);*/
return -1;
}
n=0;
while(c!=EOF && n<max_len){
if (!isalnum(c) && !strchr("_/-.()@#|{}[]",c)/*strchr(": \t\n\a",c)*/){
unget_char(r,c);
break;
}
type[n]=c;
c=get_char(r);
n++;
}
type[n]=0;
return n;
}
static void
do_keysym(char *line, int len)
{
int n;
KeyCode *keycodes;
KeySym keysym;
char *tmpname;
if (len < 3 || !line || *line == '\0') { /* a=b minimum */
badmsg0 ("keysym input line");
return;
}
n = skip_chars (line, len);
if (n < 1) {
badmsg0 ("target keysym name");
return;
}
if (!parse_keysym(line, n, &tmpname, &keysym)) {
badmsg ("keysym target key symbol '%s'", tmpname);
return;
}
keycodes = KeysymToKeycodes (dpy, keysym, &n);
if (n == 0) {
badmsg ("keysym target keysym '%s', no corresponding keycodes",
tmpname);
return;
}
if (verbose) {
int i;
printf ("! Keysym %s (0x%lx) corresponds to keycode(s)",
tmpname, (long) keysym);
for (i = 0; i < n; i++)
printf (" 0x%x", keycodes[i]);
printf("\n");
}
finish_keycodes (line, len, keycodes, n);
}
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);
}
void skip_blanks(char **data)
{
skip_chars(data, " \t");
}
static int
get_keysym_list(const char *line, int len, int *np, KeySym **kslistp)
{
int havesofar, maxcanhave;
KeySym *keysymlist;
*np = 0;
*kslistp = NULL;
if (len == 0) return (0); /* empty list */
havesofar = 0;
maxcanhave = 4; /* most lists are small */
keysymlist = (KeySym *) malloc (maxcanhave * sizeof (KeySym));
if (!keysymlist) {
badmsg ("attempt to allocate %ld byte initial keysymlist",
(long) (maxcanhave * sizeof (KeySym)));
return (-1);
}
while (len > 0) {
KeySym keysym;
int n;
char *tmpname;
Bool ok;
n = skip_space (line, len);
line += n, len -= n;
n = skip_chars (line, len);
if (n < 0) {
badmsg0 ("keysym name list");
free(keysymlist);
return (-1);
}
ok = parse_keysym (line, n, &tmpname, &keysym);
line += n, len -= n;
if (!ok) {
badmsg ("keysym name '%s' in keysym list", tmpname);
/* do NOT return here, look for others */
continue;
}
/*
* Do NOT test to see if the keysym translates to a keycode or you
* won't be able to assign new ones....
*/
/* grow the list bigger if necessary */
if (havesofar >= maxcanhave) {
KeySym *origkeysymlist = keysymlist;
maxcanhave *= 2;
keysymlist = (KeySym *) realloc (keysymlist,
maxcanhave * sizeof (KeySym));
if (!keysymlist) {
badmsg ("attempt to grow keysym list to %ld bytes",
(long) (maxcanhave * sizeof (KeySym)));
free(origkeysymlist);
return (-1);
}
}
/* and add it to the list */
keysymlist[havesofar++] = keysym;
}
*kslistp = keysymlist;
*np = havesofar;
return (0);
}
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);
}
