keymap/main.c

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include "cmd.h"
#include "parser.h"
 
extern int yylex();
extern int yyparse();
extern FILE* yyin;
extern char** environ;
extern YYSTYPE yylval;
 
#ifndef NOT_PEDIGREE
extern int pedigree_load_keymap(char* buffer, size_t len);
#endif
 
typedef struct sparse_entry sparse_t;
 
cmd_t* cmds[MAX_CMDS];
int n_cmds = 0;
 
int sparse_pos = 0;
int sparse_buffsz = 0;
sparse_t* sparse_buff = 0;
 
int data_pos = 0;
int data_buffsz = 0;
char* data_buff = 0;
 
// Modifiers are CTRL and SHIFT, ALT, ALTGR.
// Combinators are 256 user-programmable combining flags (used for accents).
 
#define SPECIAL 0x80000000
 
typedef struct table_entry {
  uint32_t flags;  // SPECIAL | modifiers
  uint32_t val;    // If flags & SPECIAL, 4 char string for special key, else U+val.
} table_entry_t;
 
#define TABLE_IDX(combinator, modifiers, scancode) \
  (((combinator & 0xFF) << 11) | ((modifiers & 0xF) << 7) | (scancode & 0x7F))
#define TABLE_MAX TABLE_IDX(0xFF, 0xF, 0x7F)
 
table_entry_t table[TABLE_MAX + 1];
 
#define SPARSE_NULL 0
#define SPARSE_DATA_FLAG 0x8000
 
typedef struct sparse_entry {
  uint16_t left;
  uint16_t right;
} sparse_t;
 
int sparse_add() {
  int ret = sparse_pos;
  int sz = sizeof(sparse_t);
  if (sparse_pos + sz > sparse_buffsz) {
    if (sparse_pos + sz >= 32768) {
      fprintf(stderr, "Too many sparse nodes.\n");
      exit(1);
    }
    sparse_t* new_sparse_buff = realloc(sparse_buff, sparse_buffsz + sz + sizeof(sparse_t));
    if (!new_sparse_buff) {
      fprintf(stderr, "Couldn't allocate buffer for new sparse buffer: %s.\n", strerror(errno));
      exit(1);
    }
    sparse_buff = new_sparse_buff;
    sparse_buffsz += sz + sizeof(sparse_t);
  }
  sparse_pos += sz;
 
  return ret;
}
 
int data_add(table_entry_t* start, table_entry_t* end) {
  int ret = data_pos;
  int sz = (unsigned long)end - (unsigned long)start;
  if (data_pos + sz > data_buffsz) {
    if (data_pos + sz >= 32768) {
      fprintf(stderr, "Too much data.\n");
      exit(1);
    }
    char* new_data_buff = realloc(data_buff, data_buffsz + sz + sizeof(sparse_t));
    if (!new_data_buff) {
      fprintf(stderr, "Couldn't allocate buffer for new data buffer: %s.\n", strerror(errno));
      exit(1);
    }
    data_buff = new_data_buff;
    data_buffsz += sz + sizeof(sparse_t);
  }
 
  memcpy(&data_buff[data_pos], (char*)start, sz);
  data_pos += sz;
 
  return ret;
}
 
int all_set(table_entry_t* start, table_entry_t* end) {
  for (; start < end; start++) {
    if (start->flags == 0 && start->val == 0)
      return 0;
  }
  return 1;
}
 
int all_clear(table_entry_t* start, table_entry_t* end) {
  for (; start < end; start++) {
    if (start->flags != 0 || start->val != 0)
      return 0;
  }
  return 1;
}
 
int yywrap() {
  return 1;
}
 
int yyerror(const char* str) __attribute__((noreturn));
int yyerror(const char* str) {
  printf("Syntax error: %s\n", str);
  exit(1);
}
 
void usage() {
  printf(
      "keymap: Compile or install a keyboard mapping.\n\
Usage: keymap [compile|install] file \n");
}
 
void parse(char* filename) {
  FILE* stream = fopen(filename, "r");
  if (!stream) {
    fprintf(stderr, "Unable to open file `%s'\n", filename);
    exit(1);
  }
  yyin = stream;
  yyparse();
 
  memset(table, 0, sizeof(table_entry_t) * (TABLE_MAX + 1));
 
  int i;
  for (i = 0; i < n_cmds; i++) {
    int comb = cmds[i]->combinators & 0xFF;
    int modifiers = cmds[i]->modifiers & 0xF;
 
    unsigned int idx = TABLE_IDX(comb, modifiers, cmds[i]->scancode);
    table[idx].flags = cmds[i]->set_modifiers;
    if (cmds[i]->unicode_point != 0) {
      table[idx].val = cmds[i]->unicode_point;
    } else if (cmds[i]->val != 0) {
      table[idx].flags |= SPECIAL;
      memcpy((char*)&(table[idx].val), cmds[i]->val, strlen(cmds[i]->val));
    }
  }
}
 
int sparse(int idx, int bisect_size) {
  int byte_offset = sparse_add();
  sparse_t* me = &sparse_buff[byte_offset / sizeof(*sparse_buff)];
 
  // Check the right child - is everything zero?
  if (all_clear(&table[idx - bisect_size], &table[idx]) > 0) {
    // All zero, don't do anything with this child.
    me->left = SPARSE_NULL;
  } else if ((all_set(&table[idx - bisect_size], &table[idx]) > 0) || (bisect_size % 2)) {
    //         printf("DATA: %x -> %x (L)\n", idx-bisect_size, idx);
    // All set, add to data section and set ptr.
    me->left = data_add(&table[idx - bisect_size], &table[idx]) |
               SPARSE_DATA_FLAG /* This is actual data, not another node. */;
  } else {
    uint16_t tmp = sparse(idx - bisect_size / 2, bisect_size / 2);
    // Buffer location may have changed with the me->left call.
    me = &sparse_buff[byte_offset / sizeof(*sparse_buff)];
    me->left = tmp;
  }
 
  // Check the right child - is everything zero?
  if (all_clear(&table[idx], &table[idx + bisect_size]) > 0) {
    // All zero, don't do anything with this child.
    me->right = SPARSE_NULL;
  } else if ((all_set(&table[idx], &table[idx + bisect_size]) > 0) || (bisect_size % 2)) {
    //         printf("DATA: %x -> %x (R)\n", idx, idx+bisect_size);
    // All set, add to data section and set ptr.
    me->right = data_add(&table[idx], &table[idx + bisect_size]) |
                SPARSE_DATA_FLAG /* This is actual data, not another node. */;
  } else {
    uint16_t tmp = sparse(idx + bisect_size / 2, bisect_size / 2);
    // Buffer location may have changed with the me->left call.
    me = &sparse_buff[byte_offset / sizeof(*sparse_buff)];
    me->right = tmp;
  }
 
  return byte_offset;
}
 
void compile(char* filename) {
  parse(filename);
 
  // Table created, now create the sparse tree.
  sparse((TABLE_MAX + 1) / 2, (TABLE_MAX + 1) / 2);
 
  // room for .kmc + null terminator
  char* fname = (char*)malloc(strlen(filename) + 5);
  strcpy(fname, filename);
  strcat(fname, ".kmc");
 
  // Write out.
  FILE* stream = fopen(fname, "w");
  if (!stream) {
    fprintf(stderr, "Unable to open output file `%s'\n", fname);
    exit(1);
  }
 
  int idx = 2 * sizeof(int);
  fwrite(&idx, sizeof(idx), 1, stream);
  idx = sparse_buffsz + 2 * sizeof(int);
 
  fwrite(&idx, sizeof(idx), 1, stream);
  fwrite(sparse_buff, 1, sparse_buffsz, stream);
  fwrite(data_buff, 1, data_buffsz, stream);
  fclose(stream);
 
  printf("Compiled keymap file written to `%s'.\n", fname);
 
  // clear fname for header part
  memset(fname, 0, strlen(filename) + 5);
  strcpy(fname, filename);
  strcat(fname, ".h");
 
  // Write out.
  stream = fopen(fname, "w");
  if (!stream) {
    fprintf(stderr, "Unable to open output file `%s'\n", fname);
    exit(1);
  }
 
  // Change the filename to uppercase and underscored for the header guard.
  char* header_guard = strdup(fname);
  int i;
  for (i = 0; i < (int)strlen(fname); i++) {
    if (fname[i] == '.' || fname[i] == '/')
      header_guard[i] = '_';
    else
      header_guard[i] = toupper(fname[i]);
  }
 
  fprintf(stream,
          "/*\n\
 * Copyright (c) 2010 James Molloy, Burtescu Eduard\n\
 *\n\
 * Permission to use, copy, modify, and distribute this software for any\n\
 * purpose with or without fee is hereby granted, provided that the above\n\
 * copyright notice and this permission notice appear in all copies.\n\
 *\n\
 * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n\
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n\
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n\
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n\
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n\
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n\
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\
 */\n\
\n\
#ifndef %s\n\
#define %s\n\
\n\
static char sparseBuff[%d] =\n\"",
          header_guard, header_guard, sparse_buffsz + 1);
 
  for (i = 0; i < sparse_buffsz; i++) {
    fprintf(stream, "\\x%02x", (unsigned char)((char*)sparse_buff)[i]);
    if ((i % 20) == 0 && i != 0)
      fprintf(stream, "\\\n");
  }
  fprintf(stream, "\";\n\nstatic char dataBuff[%d] =\n\"", data_buffsz + 1);
  for (i = 0; i < data_buffsz; i++) {
    fprintf(stream, "\\x%02x", (unsigned char)data_buff[i]);
    if ((i % 20) == 0 && i != 0)
      fprintf(stream, "\\\n");
  }
  fprintf(stream, "\";\n\n#endif\n");
 
  fclose(stream);
 
  free(header_guard);
 
  printf("Compiled keymap header file written to `%s'.\n", fname);
}
 
void install(char* filename) {
#ifdef NOT_PEDIGREE
  fprintf(stderr, "Unable to install a keymap on non-pedigree OS.\n");
  exit(1);
#else
 
  // Look for a '.kmc' extension.
  int len = strlen(filename);
  if (len < 4 || filename[len - 3] != 'k' || filename[len - 2] != 'm' || filename[len - 1] != 'c') {
    printf(
        "Warning: Filename does not end in '.kmc' - are you sure this "
        "is a compiled keymap file?\n");
    printf(
        "*** If you load an invalid keymap your system will be rendered "
        "unusable without a manual reboot. ***\n");
    printf("\nContinue? [no] ");
 
    char input[64];
    if ((scanf("%63s", input) != 1) || (strcmp(input, "yes") != 0)) {
      printf("Aborted, no change took place.\n");
      exit(0);
    }
  }
 
  // Load the file in to a buffer.
  FILE* stream = fopen(filename, "r");
  if (!stream) {
    fprintf(stderr, "Error opening file `%s'.\n", filename);
    return;
  }
  fseek(stream, 0, SEEK_END);
  len = ftell(stream);
  fseek(stream, 0, SEEK_SET);
 
  char* buffer = (char*)malloc(len);
  fread(buffer, 1, len, stream);
  fclose(stream);
 
  if (pedigree_load_keymap(buffer, len))
    fprintf(stderr, "Error loading keymap.\n");
  else
    printf("Keymap loaded.\n");
  exit(0);
#endif
}
 
int main(int argc, char** argv) {
  if (argc != 3) {
    usage();
    exit(0);
  }
 
  if (!strcmp(argv[1], "compile"))
    compile(argv[2]);
  else if (!strcmp(argv[1], "install"))
    install(argv[2]);
  else
    usage();
 
  exit(0);
}