/*----------------------------------------------------------------------------*/
static double scanner_get_length (scanner_t * s, double resolution)
{
double val = scanner_get_double (s);
if (!s || s->err)
return (0);
if (s->eof) {
scanner_error (s, "length expected");
return (0);
}
if (s->c - ';') {
if (resolution <= 0.0) {
scanner_error (s, "resolution not set");
return (0);
}
s->resolution_used = 1;
if (scanner_get_id (s))
return (0);
if (!strcmp (s->id, "INCH"))
val *= resolution;
else if (!strcmp (s->id, "CM"))
val *= (resolution / 2.54);
else if (!strcmp (s->id, "MM"))
val *= (resolution / 25.4);
else {
scanner_error (s, "unknown length unit");
return (0);
}
}
return val;
} /* scanner_get_length */
static int
tokenize(mvc * c, int cur)
{
struct scanner *lc = &c->scanner;
while (1) {
if (cur == 0xFEFF) {
/* on Linux at least, iswpunct returns TRUE
* for U+FEFF, but we don't want that, we just
* want to go to the scanner_error case
* below */
;
} else if (iswspace(cur)) {
if ((cur = skip_white_space(lc)) == EOF)
return cur;
continue; /* try again */
} else if (iswdigit(cur)) {
return number(c, cur);
} else if (iswalpha(cur) || cur == '_') {
return keyword_or_ident(c, cur);
} else if (iswpunct(cur)) {
return scanner_symbol(c, cur);
}
if (cur == EOF) {
if (lc->mode == LINE_1 || !lc->started )
return cur;
return scanner_error(c, cur);
}
/* none of the above: error */
return scanner_error(c, cur);
}
}
/*----------------------------------------------------------------------------*/
static int scanner_nextchar (scanner_t * s, int expect)
{
if (!s || s->err || s->eof)
return (0);
while (s->pos + 1 >= s->txtlen) {
int mes_stat = mes_ability (0);
int err = mes_realloc ((void**)&(s->txt), sizeof(*(s->txt))*(s->txtlen + 256));
mes_ability (mes_stat);
if (err) {
scanner_error (s, "line too long");
return (-1);
}
else
s->txtlen += 256;
}
s->txt[s->pos] = s->c;
if (s->c == '\n') {
s->pos = 0;
s->line++;
}
else
s->pos++;
s->txt[s->pos] = 0;
scanner_fgetc (s);
if (s->eof && expect) {
scanner_error (s, "unexpected end of file");
return (-1);
}
return (0);
} /* scanner_nextchar */
int matrix_i_read (scanner_t * s, int **matrix, int max_zeile, int max_spalte)
{
#define CUR_PROC "matrix_i_read"
int len = 0, zeile = 0;
scanner_consume (s, '{');
if (s->err)
return (-1);
while (!s->eof && !s->err && s->c - '}') {
if (zeile >= max_zeile) {
scanner_error (s, "too many rows in matrix");
return (-1);
}
/* Memory allocation takes place in scanner_get_int_array */
matrix[zeile] = scanner_get_int_array (s, &len);
if (len != max_spalte) {
scanner_error (s, "wrong number of elements in matrix");
return (-1);
}
scanner_consume (s, ';');
if (s->err) {
scanner_error (s, "missing ';' or wrong number of columns");
return (-1);
}
zeile++;
}
scanner_consume (s, '}');
if (s->err)
return (-1);
if (zeile < max_zeile) {
scanner_error (s, "rows missing in matrix");
return (-1);
}
return (0);
#undef CUR_PROC
} /* matrix_i_read */
/*----------------------------------------------------------------------------*/
static int scanner_digit (int *val, scanner_t * s, int radix, int expect)
{
switch (radix) {
case 10:
if ('0' <= s->c && s->c <= '9')
*val = *val * 10 + s->c - '0';
else if (expect) {
scanner_error (s, "decimal digit expected");
return (-1);
}
else
return (1);
break;
case 16:
if (s->c >= '0' && s->c <= '9')
*val = *val * 16 + s->c - '0';
else if ('A' <= s->c && s->c <= 'F')
*val = *val * 16 + s->c - 'A' + 10;
else if ('a' <= s->c && s->c <= 'f')
*val = *val * 16 + s->c - 'a' + 10;
else if (expect) {
scanner_error (s, "decimal digit expected");
return (-1);
}
else
return (1);
break;
case 2:
if (s->c >= '0' && s->c <= '1')
*val = *val * 2 + s->c - '0';
else if (expect) {
scanner_error (s, "binary digit expected");
return (-1);
}
else
return (1);
break;
case 8:
if (s->c >= '0' && s->c <= '7')
*val = *val * 8 + s->c - '0';
else if (expect) {
scanner_error (s, "octal digit expected");
return (-1);
}
else
return (1);
break;
default:
return (1);
}
return (0);
} /* scanner_digit */
static int randvar_read_PHI ()
{
# define CUR_PROC "randvar_read_PHI"
int res = -1;
char filename = "ghmm/PHI_001_20.dat";
scanner_t *s = NULL;
//#warning "PHI_DATA_FILE deprecated!"
s = scanner_alloc (filename);
if (!s) {
mes_proc ();
goto STOP;
}
scanner_get_name (s);
scanner_consume (s, '=');
if (s->err)
goto STOP;
if (!strcmp (s->id, "PHI")) {
scanner_consume (s, '{');
if (s->err)
goto STOP;
PHI = scanner_get_double_earray (s, &PHI_len);
if (s->err)
goto STOP;
scanner_consume (s, ';');
if (s->err)
goto STOP;
scanner_consume (s, '}');
if (s->err)
goto STOP;
scanner_consume (s, ';');
if (s->err)
goto STOP;
}
else {
scanner_error (s, "unknown identifier");
goto STOP;
}
// printf("%.4f\n", PHI[PHI_len-1]);
res = 0;;
STOP:
scanner_free (&s);
return res;
# undef CUR_PROC
}
int
_xkbcommon_lex(YYSTYPE *yylval, struct scanner *s)
{
int tok;
skip_more_whitespace_and_comments:
/* Skip spaces. */
while (is_space(peek(s))) next(s);
/* Skip comments. */
if (lit(s, "//") || chr(s, '#')) {
while (!eof(s) && !eol(s)) next(s);
goto skip_more_whitespace_and_comments;
}
/* See if we're done. */
if (eof(s)) return END_OF_FILE;
/* New token. */
s->token_line = s->line;
s->token_column = s->column;
s->buf_pos = 0;
/* String literal. */
if (chr(s, '\"')) {
while (!eof(s) && !eol(s) && peek(s) != '\"') {
if (chr(s, '\\')) {
uint8_t o;
if (chr(s, '\\')) buf_append(s, '\\');
else if (chr(s, 'n')) buf_append(s, '\n');
else if (chr(s, 't')) buf_append(s, '\t');
else if (chr(s, 'r')) buf_append(s, '\r');
else if (chr(s, 'b')) buf_append(s, '\b');
else if (chr(s, 'f')) buf_append(s, '\f');
else if (chr(s, 'v')) buf_append(s, '\v');
else if (chr(s, 'e')) buf_append(s, '\033');
else if (oct(s, &o)) buf_append(s, (char) o);
else {
scanner_warn(s, "unknown escape sequence in string literal");
/* Ignore. */
}
} else {
buf_append(s, next(s));
}
}
if (!buf_append(s, '\0') || !chr(s, '\"'))
return scanner_error(s, "unterminated string literal");
yylval->str = strdup(s->buf);
if (!yylval->str)
return scanner_error(s, "scanner out of memory");
return STRING;
}
/* Key name literal. */
if (chr(s, '<')) {
while (is_graph(peek(s)) && peek(s) != '>')
buf_append(s, next(s));
if (!buf_append(s, '\0') || !chr(s, '>'))
return scanner_error(s, "unterminated key name literal");
/* Empty key name literals are allowed. */
yylval->sval = xkb_atom_intern(s->ctx, s->buf, s->buf_pos - 1);
return KEYNAME;
}
/* Operators and punctuation. */
if (chr(s, ';')) return SEMI;
if (chr(s, '{')) return OBRACE;
if (chr(s, '}')) return CBRACE;
if (chr(s, '=')) return EQUALS;
if (chr(s, '[')) return OBRACKET;
if (chr(s, ']')) return CBRACKET;
if (chr(s, '(')) return OPAREN;
if (chr(s, ')')) return CPAREN;
if (chr(s, '.')) return DOT;
if (chr(s, ',')) return COMMA;
if (chr(s, '+')) return PLUS;
if (chr(s, '-')) return MINUS;
if (chr(s, '*')) return TIMES;
if (chr(s, '/')) return DIVIDE;
if (chr(s, '!')) return EXCLAM;
if (chr(s, '~')) return INVERT;
/* Identifier. */
if (is_alpha(peek(s)) || peek(s) == '_') {
s->buf_pos = 0;
while (is_alnum(peek(s)) || peek(s) == '_')
buf_append(s, next(s));
if (!buf_append(s, '\0'))
return scanner_error(s, "identifier too long");
/* Keyword. */
tok = keyword_to_token(s->buf);
if (tok != -1) return tok;
yylval->str = strdup(s->buf);
if (!yylval->str)
return scanner_error(s, "scanner out of memory");
return IDENT;
}
/* Number literal (hexadecimal / decimal / float). */
if (number(s, &yylval->num, &tok)) {
if (tok == ERROR_TOK)
return scanner_error(s, "malformed number literal");
return tok;
}
return scanner_error(s, "unrecognized token");
}
