tools/kcm/kcm.cpp - platform/build - Git at Google

 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <ui/KeycodeLabels.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <map>
 #include <string>
 #include <utils/ByteOrder.h>

 using namespace std;

 enum {
     LENDIAN,
     BENDIAN
 };

 /*
  * 1: KeyEvent name
  * 2: display_label
  * 3: number
  * 4..7: base, shift, alt, shift-alt
  */
 #define COLUMNS (3+4)

 struct KeyRecord
 {
     int lineno;
     int values[COLUMNS];
 };

 struct PropValue
 {
     PropValue() { lineno = -1; }
     PropValue(const PropValue& that) { lineno=that.lineno; value=that.value; }
     PropValue(int l, const string& v) { lineno = l; value = v; }

     int lineno;
     string value;
 };

 static int usage();

 //  0 -- ok
 // >0 -- error
 static int parse_key_line(const char* filename, int lineno, char* line,
         KeyRecord* out);
 static int write_kr(int fd, const KeyRecord& kr);

 int g_endian;

 int
 main(int argc, char** argv)
 {
     int err;
     if (argc != 3) {
         return usage();
     }

     const char* filename = argv[1];
     const char* outfilename = argv[2];

     int in = open(filename, O_RDONLY);
     if (in == -1) {
         fprintf(stderr, "kcm: error opening file for read: %s\n", filename);
         return 1;
     }

     off_t size = lseek(in, 0, SEEK_END);
     lseek(in, 0, SEEK_SET);

     char* input = (char*)malloc(size+1);
     read(in, input, size);
     input[size] = '\0';

     close(in);
     in = -1;

     map<string,PropValue> properties;
     map<int,KeyRecord> keys;
     int errorcount = 0;
     int lineno = 1;
     char *thisline = input;
     while (*thisline) {
         KeyRecord kr;
         char *nextline = thisline;

         while (*nextline != '\0' && *nextline != '\n' && *nextline != '\r') {
             nextline++;
         }

         // eat whitespace, but not newlines
         while (*thisline != '\0' && (*thisline == ' ' || *thisline == '\t')) {
             thisline++;
         }

         // find the end of the line
         char lineend = *nextline;
         *nextline = '\0';
         if (lineend == '\r' && nextline[1] == '\n') {
             nextline++;
         }

         if (*thisline == '\0' || *thisline == '\r' || *thisline == '\n'
                  || *thisline == '#') {
             // comment or blank line
         }
         else if (*thisline == '[') {
             // property - syntax [name=value]
             // look for =
             char* prop = thisline+1;
             char* end = prop;
             while (*end != '\0' && *end != '=') {
                 end++;
             }
             if (*end != '=') {
                 fprintf(stderr, "%s:%d: invalid property line: %s\n",
                         filename, lineno, thisline);
                 errorcount++;
             } else {
                 *end = '\0';
                 char* value = end+1;
                 end = nextline;
                 while (end > prop && *end != ']') {
                     end--;
                 }
                 if (*end != ']') {
                     fprintf(stderr, "%s:%d: property missing closing ]: %s\n",
                             filename, lineno, thisline);
                     errorcount++;
                 } else {
                     *end = '\0';
                     properties[prop] = PropValue(lineno, value);
                 }
             }
         }
         else {
             // key
             err = parse_key_line(filename, lineno, thisline, &kr);
             if (err == 0) {
                 kr.lineno = lineno;

                 map<int,KeyRecord>::iterator old = keys.find(kr.values[0]);
                 if (old != keys.end()) {
                     fprintf(stderr, "%s:%d: keycode %d already defined\n",
                             filename, lineno, kr.values[0]);
                     fprintf(stderr, "%s:%d: previously defined here\n",
                             filename, old->second.lineno);
                     errorcount++;
                 }

                 keys[kr.values[0]] = kr;
             }
             else if (err > 0) {
                 errorcount += err;
             }
         }
         lineno++;

         nextline++;
         thisline = nextline;

         if (errorcount > 20) {
             fprintf(stderr, "%s:%d: too many errors.  stopping.\n", filename,
                     lineno);
             return 1;
         }
     }

     free(input);

     map<string,PropValue>::iterator sit = properties.find("type");
     if (sit == properties.end()) {
         fprintf(stderr, "%s: key character map must contain type property.\n",
 		argv[0]);
         errorcount++;
     }
     PropValue pv = sit->second;
     unsigned char kbdtype = 0;
     if (pv.value == "NUMERIC") {
         kbdtype = 1;
     }
     else if (pv.value == "Q14") {
         kbdtype = 2;
     }
     else if (pv.value == "QWERTY") {
         kbdtype = 3;
     }
     else {
         fprintf(stderr, "%s:%d: keyboard type must be one of NUMERIC, Q14 "
                 " or QWERTY, not %s\n", filename, pv.lineno, pv.value.c_str());
     }

     if (errorcount != 0) {
         return 1;
     }

     int out = open(outfilename, O_RDWR|O_CREAT|O_TRUNC, 0664);
     if (out == -1) {
         fprintf(stderr, "kcm: error opening file for write: %s\n", outfilename);
         return 1;
     }

     int count = keys.size();

     map<int,KeyRecord>::iterator it;
     int n;

     /**
      * File Format:
      *    Offset    Description     Value
      *    0         magic string    "keychar"
      *    8         endian marker   0x12345678
      *    12        version         0x00000002
      *    16        key count       number of key entries
      *    20        keyboard type   NUMERIC, Q14, QWERTY, etc.
      *    21        padding         0
      *    32        the keys
      */
     err = write(out, "keychar", 8);
     if (err == -1) goto bad_write;

     n = htodl(0x12345678);
     err = write(out, &n, 4);
     if (err == -1) goto bad_write;

     n = htodl(0x00000002);
     err = write(out, &n, 4);
     if (err == -1) goto bad_write;

     n = htodl(count);
     err = write(out, &n, 4);
     if (err == -1) goto bad_write;

     err = write(out, &kbdtype, 1);
     if (err == -1) goto bad_write;

     char zero[11];
     memset(zero, 0, 11);
     err = write(out, zero, 11);
     if (err == -1) goto bad_write;

     for (it = keys.begin(); it != keys.end(); it++) {
         const KeyRecord& kr = it->second;
         /*
         printf("%2d/ [%d] [%d] [%d] [%d] [%d] [%d] [%d]\n", kr.lineno,
                 kr.values[0], kr.values[1], kr.values[2], kr.values[3],
                 kr.values[4], kr.values[5], kr.values[6]);
         */
         err = write_kr(out, kr);
         if (err == -1) goto bad_write;
     }

     close(out);
     return 0;

 bad_write:
     fprintf(stderr, "kcm: fatal error writing to file: %s\n", outfilename);
     close(out);
     unlink(outfilename);
     return 1;
 }

 static int usage()
 {
     fprintf(stderr,
             "usage: kcm INPUT OUTPUT\n"
             "\n"
             "INPUT   keycharmap file\n"
             "OUTPUT  compiled keycharmap file\n"
         );
     return 1;
 }

 static int
 is_whitespace(const char* p)
 {
     while (*p) {
         if (!isspace(*p)) {
             return 0;
         }
         p++;
     }
     return 1;
 }


 static int
 parse_keycode(const char* filename, int lineno, char* str, int* value)
 {
     const KeycodeLabel *list = KEYCODES;
     while (list->literal) {
         if (0 == strcmp(str, list->literal)) {
             *value = list->value;
             return 0;
         }
         list++;
     }

     char* endptr;
     *value = strtol(str, &endptr, 0);
     if (*endptr != '\0') {
         fprintf(stderr, "%s:%d: expected keycode label or number near: "
                 "%s\n", filename, lineno, str);
         return 1;
     }

     if (*value == 0) {
         fprintf(stderr, "%s:%d: 0 is not a valid keycode.\n",
                 filename, lineno);
         return 1;
     }

     return 0;
 }

 static int
 parse_number(const char* filename, int lineno, char* str, int* value)
 {
     int len = strlen(str);

     if (len == 3 && str[0] == '\'' && str[2] == '\'') {
         if (str[1] > 0 && str[1] < 127) {
             *value = (int)str[1];
             return 0;
         } else {
             fprintf(stderr, "%s:%d: only low ascii characters are allowed in"
                     " quotes near: %s\n", filename, lineno, str);
             return 1;
         }
     }

     char* endptr;
     *value = strtol(str, &endptr, 0);
     if (*endptr != '\0') {
         fprintf(stderr, "%s:%d: expected number or quoted ascii but got: %s\n",
                 filename, lineno, str);
         return 1;
     }

     if (*value >= 0xfffe || *value < 0) {
         fprintf(stderr, "%s:%d: unicode char out of range (no negatives, "
                 "nothing larger than 0xfffe): %s\n", filename, lineno, str);
         return 1;
     }

     return 0;
 }

 static int
 parse_key_line(const char* filename, int lineno, char* line, KeyRecord* out)
 {
     char* p = line;

     int len = strlen(line);
     char* s[COLUMNS];
     for (int i=0; i<COLUMNS; i++) {
         s[i] = (char*)malloc(len+1);
     }

     for (int i = 0; i < COLUMNS; i++) {
         while (*p != '\0' && isspace(*p)) {
             p++;
         }

         if (*p == '\0') {
             fprintf(stderr, "%s:%d: not enough on this line: %s\n", filename,
                     lineno, line);
             return 1;
         }

         char *p1 = p;
         while (*p != '\0' && !isspace(*p)) {
             p++;
         }

         memcpy(s[i], p1, p - p1);
         s[i][p - p1] = '\0';
     }

     while (*p != '\0' && isspace(*p)) {
         *p++;
     }
     if (*p != '\0') {
         fprintf(stderr, "%s:%d: too much on one line near: %s\n", filename,
                 lineno, p);
         fprintf(stderr, "%s:%d: -->%s<--\n", filename, lineno, line);
         return 1;
     }

     int errorcount = parse_keycode(filename, lineno, s[0], &out->values[0]);
     for (int i=1; i<COLUMNS && errorcount == 0; i++) {
         errorcount += parse_number(filename, lineno, s[i], &out->values[i]);
     }

     return errorcount;
 }

 struct WrittenRecord
 {
     unsigned int keycode;       // 4 bytes
     unsigned short values[COLUMNS - 1];   // 6*2 bytes = 12
                                 // 16 bytes total
 };

 static int
 write_kr(int fd, const KeyRecord& kr)
 {
     WrittenRecord wr;

     wr.keycode = htodl(kr.values[0]);
     for (int i=0; i<COLUMNS - 1; i++) {
         wr.values[i] = htods(kr.values[i+1]);
     }

     return write(fd, &wr, sizeof(WrittenRecord));
 }
	#include <stdio.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <ui/KeycodeLabels.h>
	#include <stdlib.h>
	#include <ctype.h>
	#include <map>
	#include <string>
	#include <utils/ByteOrder.h>

	using namespace std;

	enum {
	LENDIAN,
	BENDIAN
	};

	/*
	* 1: KeyEvent name
	* 2: display_label
	* 3: number
	* 4..7: base, shift, alt, shift-alt
	*/
	#define COLUMNS (3+4)

	struct KeyRecord
	{
	int lineno;
	int values[COLUMNS];
	};

	struct PropValue
	{
	PropValue() { lineno = -1; }
	PropValue(const PropValue& that) { lineno=that.lineno; value=that.value; }
	PropValue(int l, const string& v) { lineno = l; value = v; }

	int lineno;
	string value;
	};

	static int usage();

	// 0 -- ok
	// >0 -- error
	static int parse_key_line(const char* filename, int lineno, char* line,
	KeyRecord* out);
	static int write_kr(int fd, const KeyRecord& kr);

	int g_endian;

	int
	main(int argc, char** argv)
	{
	int err;
	if (argc != 3) {
	return usage();
	}

	const char* filename = argv[1];
	const char* outfilename = argv[2];

	int in = open(filename, O_RDONLY);
	if (in == -1) {
	fprintf(stderr, "kcm: error opening file for read: %s\n", filename);
	return 1;
	}

	off_t size = lseek(in, 0, SEEK_END);
	lseek(in, 0, SEEK_SET);

	char* input = (char*)malloc(size+1);
	read(in, input, size);
	input[size] = '\0';

	close(in);
	in = -1;

	map<string,PropValue> properties;
	map<int,KeyRecord> keys;
	int errorcount = 0;
	int lineno = 1;
	char *thisline = input;
	while (*thisline) {
	KeyRecord kr;
	char *nextline = thisline;

	while (nextline != '\0' && nextline != '\n' && *nextline != '\r') {
	nextline++;
	}

	// eat whitespace, but not newlines
	while (thisline != '\0' && (thisline == ' ' \|\| *thisline == '\t')) {
	thisline++;
	}

	// find the end of the line
	char lineend = *nextline;
	*nextline = '\0';
	if (lineend == '\r' && nextline[1] == '\n') {
	nextline++;
	}

	if (thisline == '\0' \|\| thisline == '\r' \|\| *thisline == '\n'
	\|\| *thisline == '#') {
	// comment or blank line
	}
	else if (*thisline == '[') {
	// property - syntax [name=value]
	// look for =
	char* prop = thisline+1;
	char* end = prop;
	while (end != '\0' && end != '=') {
	end++;
	}
	if (*end != '=') {
	fprintf(stderr, "%s:%d: invalid property line: %s\n",
	filename, lineno, thisline);
	errorcount++;
	} else {
	*end = '\0';
	char* value = end+1;
	end = nextline;
	while (end > prop && *end != ']') {
	end--;
	}
	if (*end != ']') {
	fprintf(stderr, "%s:%d: property missing closing ]: %s\n",
	filename, lineno, thisline);
	errorcount++;
	} else {
	*end = '\0';
	properties[prop] = PropValue(lineno, value);
	}
	}
	}
	else {
	// key
	err = parse_key_line(filename, lineno, thisline, &kr);
	if (err == 0) {
	kr.lineno = lineno;

	map<int,KeyRecord>::iterator old = keys.find(kr.values[0]);
	if (old != keys.end()) {
	fprintf(stderr, "%s:%d: keycode %d already defined\n",
	filename, lineno, kr.values[0]);
	fprintf(stderr, "%s:%d: previously defined here\n",
	filename, old->second.lineno);
	errorcount++;
	}

	keys[kr.values[0]] = kr;
	}
	else if (err > 0) {
	errorcount += err;
	}
	}
	lineno++;

	nextline++;
	thisline = nextline;

	if (errorcount > 20) {
	fprintf(stderr, "%s:%d: too many errors. stopping.\n", filename,
	lineno);
	return 1;
	}
	}

	free(input);

	map<string,PropValue>::iterator sit = properties.find("type");
	if (sit == properties.end()) {
	fprintf(stderr, "%s: key character map must contain type property.\n",
	argv[0]);
	errorcount++;
	}
	PropValue pv = sit->second;
	unsigned char kbdtype = 0;
	if (pv.value == "NUMERIC") {
	kbdtype = 1;
	}
	else if (pv.value == "Q14") {
	kbdtype = 2;
	}
	else if (pv.value == "QWERTY") {
	kbdtype = 3;
	}
	else {
	fprintf(stderr, "%s:%d: keyboard type must be one of NUMERIC, Q14 "
	" or QWERTY, not %s\n", filename, pv.lineno, pv.value.c_str());
	}

	if (errorcount != 0) {
	return 1;
	}

	int out = open(outfilename, O_RDWR\|O_CREAT\|O_TRUNC, 0664);
	if (out == -1) {
	fprintf(stderr, "kcm: error opening file for write: %s\n", outfilename);
	return 1;
	}

	int count = keys.size();

	map<int,KeyRecord>::iterator it;
	int n;

	/**
	* File Format:
	* Offset Description Value
	* 0 magic string "keychar"
	* 8 endian marker 0x12345678
	* 12 version 0x00000002
	* 16 key count number of key entries
	* 20 keyboard type NUMERIC, Q14, QWERTY, etc.
	* 21 padding 0
	* 32 the keys
	*/
	err = write(out, "keychar", 8);
	if (err == -1) goto bad_write;

	n = htodl(0x12345678);
	err = write(out, &n, 4);
	if (err == -1) goto bad_write;

	n = htodl(0x00000002);
	err = write(out, &n, 4);
	if (err == -1) goto bad_write;

	n = htodl(count);
	err = write(out, &n, 4);
	if (err == -1) goto bad_write;

	err = write(out, &kbdtype, 1);
	if (err == -1) goto bad_write;

	char zero[11];
	memset(zero, 0, 11);
	err = write(out, zero, 11);
	if (err == -1) goto bad_write;

	for (it = keys.begin(); it != keys.end(); it++) {
	const KeyRecord& kr = it->second;
	/*
	printf("%2d/ [%d] [%d] [%d] [%d] [%d] [%d] [%d]\n", kr.lineno,
	kr.values[0], kr.values[1], kr.values[2], kr.values[3],
	kr.values[4], kr.values[5], kr.values[6]);
	*/
	err = write_kr(out, kr);
	if (err == -1) goto bad_write;
	}

	close(out);
	return 0;

	bad_write:
	fprintf(stderr, "kcm: fatal error writing to file: %s\n", outfilename);
	close(out);
	unlink(outfilename);
	return 1;
	}

	static int usage()
	{
	fprintf(stderr,
	"usage: kcm INPUT OUTPUT\n"
	"\n"
	"INPUT keycharmap file\n"
	"OUTPUT compiled keycharmap file\n"
	);
	return 1;
	}

	static int
	is_whitespace(const char* p)
	{
	while (*p) {
	if (!isspace(*p)) {
	return 0;
	}
	p++;
	}
	return 1;
	}


	static int
	parse_keycode(const char* filename, int lineno, char* str, int* value)
	{
	const KeycodeLabel *list = KEYCODES;
	while (list->literal) {
	if (0 == strcmp(str, list->literal)) {
	*value = list->value;
	return 0;
	}
	list++;
	}

	char* endptr;
	*value = strtol(str, &endptr, 0);
	if (*endptr != '\0') {
	fprintf(stderr, "%s:%d: expected keycode label or number near: "
	"%s\n", filename, lineno, str);
	return 1;
	}

	if (*value == 0) {
	fprintf(stderr, "%s:%d: 0 is not a valid keycode.\n",
	filename, lineno);
	return 1;
	}

	return 0;
	}

	static int
	parse_number(const char* filename, int lineno, char* str, int* value)
	{
	int len = strlen(str);

	if (len == 3 && str[0] == '\'' && str[2] == '\'') {
	if (str[1] > 0 && str[1] < 127) {
	*value = (int)str[1];
	return 0;
	} else {
	fprintf(stderr, "%s:%d: only low ascii characters are allowed in"
	" quotes near: %s\n", filename, lineno, str);
	return 1;
	}
	}

	char* endptr;
	*value = strtol(str, &endptr, 0);
	if (*endptr != '\0') {
	fprintf(stderr, "%s:%d: expected number or quoted ascii but got: %s\n",
	filename, lineno, str);
	return 1;
	}

	if (value >= 0xfffe \|\| value < 0) {
	fprintf(stderr, "%s:%d: unicode char out of range (no negatives, "
	"nothing larger than 0xfffe): %s\n", filename, lineno, str);
	return 1;
	}

	return 0;
	}

	static int
	parse_key_line(const char* filename, int lineno, char* line, KeyRecord* out)
	{
	char* p = line;

	int len = strlen(line);
	char* s[COLUMNS];
	for (int i=0; i<COLUMNS; i++) {
	s[i] = (char*)malloc(len+1);
	}

	for (int i = 0; i < COLUMNS; i++) {
	while (p != '\0' && isspace(p)) {
	p++;
	}

	if (*p == '\0') {
	fprintf(stderr, "%s:%d: not enough on this line: %s\n", filename,
	lineno, line);
	return 1;
	}

	char *p1 = p;
	while (p != '\0' && !isspace(p)) {
	p++;
	}

	memcpy(s[i], p1, p - p1);
	s[i][p - p1] = '\0';
	}

	while (p != '\0' && isspace(p)) {
	*p++;
	}
	if (*p != '\0') {
	fprintf(stderr, "%s:%d: too much on one line near: %s\n", filename,
	lineno, p);
	fprintf(stderr, "%s:%d: -->%s<--\n", filename, lineno, line);
	return 1;
	}

	int errorcount = parse_keycode(filename, lineno, s[0], &out->values[0]);
	for (int i=1; i<COLUMNS && errorcount == 0; i++) {
	errorcount += parse_number(filename, lineno, s[i], &out->values[i]);
	}

	return errorcount;
	}

	struct WrittenRecord
	{
	unsigned int keycode; // 4 bytes
	unsigned short values[COLUMNS - 1]; // 6*2 bytes = 12
	// 16 bytes total
	};

	static int
	write_kr(int fd, const KeyRecord& kr)
	{
	WrittenRecord wr;

	wr.keycode = htodl(kr.values[0]);
	for (int i=0; i<COLUMNS - 1; i++) {
	wr.values[i] = htods(kr.values[i+1]);
	}

	return write(fd, &wr, sizeof(WrittenRecord));
	}