forked from AuroraMiddleware/gtk
1488 lines
39 KiB
C
1488 lines
39 KiB
C
/* GSK - The GIMP Toolkit
|
|
* Copyright (C) 2011 Benjamin Otte <otte@gnome.org>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gtkcsstokenizerprivate.h"
|
|
|
|
#include "gtkcssenums.h"
|
|
#include "gtkcsserror.h"
|
|
#include "gtkcsslocationprivate.h"
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
|
|
struct _GtkCssTokenizer
|
|
{
|
|
int ref_count;
|
|
GBytes *bytes;
|
|
GString *name_buffer;
|
|
|
|
const char *data;
|
|
const char *end;
|
|
|
|
GtkCssLocation position;
|
|
};
|
|
|
|
void
|
|
gtk_css_token_clear (GtkCssToken *token)
|
|
{
|
|
switch (token->type)
|
|
{
|
|
case GTK_CSS_TOKEN_STRING:
|
|
case GTK_CSS_TOKEN_IDENT:
|
|
case GTK_CSS_TOKEN_FUNCTION:
|
|
case GTK_CSS_TOKEN_AT_KEYWORD:
|
|
case GTK_CSS_TOKEN_HASH_UNRESTRICTED:
|
|
case GTK_CSS_TOKEN_HASH_ID:
|
|
case GTK_CSS_TOKEN_URL:
|
|
g_free (token->string.string);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNED_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_DIMENSION:
|
|
g_free (token->dimension.dimension);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
case GTK_CSS_TOKEN_EOF:
|
|
case GTK_CSS_TOKEN_WHITESPACE:
|
|
case GTK_CSS_TOKEN_OPEN_PARENS:
|
|
case GTK_CSS_TOKEN_CLOSE_PARENS:
|
|
case GTK_CSS_TOKEN_OPEN_SQUARE:
|
|
case GTK_CSS_TOKEN_CLOSE_SQUARE:
|
|
case GTK_CSS_TOKEN_OPEN_CURLY:
|
|
case GTK_CSS_TOKEN_CLOSE_CURLY:
|
|
case GTK_CSS_TOKEN_COMMA:
|
|
case GTK_CSS_TOKEN_COLON:
|
|
case GTK_CSS_TOKEN_SEMICOLON:
|
|
case GTK_CSS_TOKEN_CDC:
|
|
case GTK_CSS_TOKEN_CDO:
|
|
case GTK_CSS_TOKEN_DELIM:
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNED_NUMBER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_NUMBER:
|
|
case GTK_CSS_TOKEN_PERCENTAGE:
|
|
case GTK_CSS_TOKEN_INCLUDE_MATCH:
|
|
case GTK_CSS_TOKEN_DASH_MATCH:
|
|
case GTK_CSS_TOKEN_PREFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUFFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUBSTRING_MATCH:
|
|
case GTK_CSS_TOKEN_COLUMN:
|
|
case GTK_CSS_TOKEN_BAD_STRING:
|
|
case GTK_CSS_TOKEN_BAD_URL:
|
|
case GTK_CSS_TOKEN_COMMENT:
|
|
break;
|
|
}
|
|
|
|
token->type = GTK_CSS_TOKEN_EOF;
|
|
}
|
|
|
|
static void
|
|
gtk_css_token_init (GtkCssToken *token,
|
|
GtkCssTokenType type)
|
|
{
|
|
token->type = type;
|
|
|
|
switch ((guint)type)
|
|
{
|
|
case GTK_CSS_TOKEN_EOF:
|
|
case GTK_CSS_TOKEN_WHITESPACE:
|
|
case GTK_CSS_TOKEN_OPEN_PARENS:
|
|
case GTK_CSS_TOKEN_CLOSE_PARENS:
|
|
case GTK_CSS_TOKEN_OPEN_SQUARE:
|
|
case GTK_CSS_TOKEN_CLOSE_SQUARE:
|
|
case GTK_CSS_TOKEN_OPEN_CURLY:
|
|
case GTK_CSS_TOKEN_CLOSE_CURLY:
|
|
case GTK_CSS_TOKEN_COMMA:
|
|
case GTK_CSS_TOKEN_COLON:
|
|
case GTK_CSS_TOKEN_SEMICOLON:
|
|
case GTK_CSS_TOKEN_CDC:
|
|
case GTK_CSS_TOKEN_CDO:
|
|
case GTK_CSS_TOKEN_INCLUDE_MATCH:
|
|
case GTK_CSS_TOKEN_DASH_MATCH:
|
|
case GTK_CSS_TOKEN_PREFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUFFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUBSTRING_MATCH:
|
|
case GTK_CSS_TOKEN_COLUMN:
|
|
case GTK_CSS_TOKEN_BAD_STRING:
|
|
case GTK_CSS_TOKEN_BAD_URL:
|
|
case GTK_CSS_TOKEN_COMMENT:
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
append_ident (GString *string,
|
|
const char *ident)
|
|
{
|
|
/* XXX */
|
|
g_string_append (string, ident);
|
|
}
|
|
|
|
static void
|
|
append_string (GString *string,
|
|
const char *s)
|
|
{
|
|
g_string_append_c (string, '"');
|
|
/* XXX */
|
|
g_string_append (string, s);
|
|
g_string_append_c (string, '"');
|
|
}
|
|
|
|
/*
|
|
* gtk_css_token_is_finite:
|
|
* @token: a `GtkCssToken`
|
|
*
|
|
* A token is considered finite when it would stay the same no matter
|
|
* what bytes follow it in the data stream.
|
|
*
|
|
* An obvious example for this is the ';' token.
|
|
*
|
|
* Returns: %TRUE if the token is considered finite.
|
|
**/
|
|
gboolean
|
|
gtk_css_token_is_finite (const GtkCssToken *token)
|
|
{
|
|
switch (token->type)
|
|
{
|
|
case GTK_CSS_TOKEN_EOF:
|
|
case GTK_CSS_TOKEN_STRING:
|
|
case GTK_CSS_TOKEN_FUNCTION:
|
|
case GTK_CSS_TOKEN_URL:
|
|
case GTK_CSS_TOKEN_PERCENTAGE:
|
|
case GTK_CSS_TOKEN_OPEN_PARENS:
|
|
case GTK_CSS_TOKEN_CLOSE_PARENS:
|
|
case GTK_CSS_TOKEN_OPEN_SQUARE:
|
|
case GTK_CSS_TOKEN_CLOSE_SQUARE:
|
|
case GTK_CSS_TOKEN_OPEN_CURLY:
|
|
case GTK_CSS_TOKEN_CLOSE_CURLY:
|
|
case GTK_CSS_TOKEN_COMMA:
|
|
case GTK_CSS_TOKEN_COLON:
|
|
case GTK_CSS_TOKEN_SEMICOLON:
|
|
case GTK_CSS_TOKEN_CDC:
|
|
case GTK_CSS_TOKEN_CDO:
|
|
case GTK_CSS_TOKEN_INCLUDE_MATCH:
|
|
case GTK_CSS_TOKEN_DASH_MATCH:
|
|
case GTK_CSS_TOKEN_PREFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUFFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUBSTRING_MATCH:
|
|
case GTK_CSS_TOKEN_COLUMN:
|
|
case GTK_CSS_TOKEN_COMMENT:
|
|
return TRUE;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
case GTK_CSS_TOKEN_WHITESPACE:
|
|
case GTK_CSS_TOKEN_IDENT:
|
|
case GTK_CSS_TOKEN_AT_KEYWORD:
|
|
case GTK_CSS_TOKEN_HASH_UNRESTRICTED:
|
|
case GTK_CSS_TOKEN_HASH_ID:
|
|
case GTK_CSS_TOKEN_DELIM:
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNED_NUMBER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_NUMBER:
|
|
case GTK_CSS_TOKEN_BAD_STRING:
|
|
case GTK_CSS_TOKEN_BAD_URL:
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNED_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_DIMENSION:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* gtk_css_token_is_preserved:
|
|
* @token: a `GtkCssToken`
|
|
* @out_closing: (nullable): Type of the token that closes a block
|
|
* started with this token
|
|
*
|
|
* A token is considered preserved when it does not start a block.
|
|
*
|
|
* Tokens that start a block require different error recovery when parsing,
|
|
* so CSS parsers want to look at this function
|
|
*
|
|
* Returns: %TRUE if the token is considered preserved.
|
|
*/
|
|
gboolean
|
|
gtk_css_token_is_preserved (const GtkCssToken *token,
|
|
GtkCssTokenType *out_closing)
|
|
{
|
|
switch (token->type)
|
|
{
|
|
case GTK_CSS_TOKEN_FUNCTION:
|
|
case GTK_CSS_TOKEN_OPEN_PARENS:
|
|
if (out_closing)
|
|
*out_closing = GTK_CSS_TOKEN_CLOSE_PARENS;
|
|
return FALSE;
|
|
|
|
case GTK_CSS_TOKEN_OPEN_SQUARE:
|
|
if (out_closing)
|
|
*out_closing = GTK_CSS_TOKEN_CLOSE_SQUARE;
|
|
return FALSE;
|
|
|
|
case GTK_CSS_TOKEN_OPEN_CURLY:
|
|
if (out_closing)
|
|
*out_closing = GTK_CSS_TOKEN_CLOSE_CURLY;
|
|
return FALSE;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
case GTK_CSS_TOKEN_EOF:
|
|
case GTK_CSS_TOKEN_WHITESPACE:
|
|
case GTK_CSS_TOKEN_STRING:
|
|
case GTK_CSS_TOKEN_URL:
|
|
case GTK_CSS_TOKEN_PERCENTAGE:
|
|
case GTK_CSS_TOKEN_CLOSE_PARENS:
|
|
case GTK_CSS_TOKEN_CLOSE_SQUARE:
|
|
case GTK_CSS_TOKEN_CLOSE_CURLY:
|
|
case GTK_CSS_TOKEN_COMMA:
|
|
case GTK_CSS_TOKEN_COLON:
|
|
case GTK_CSS_TOKEN_SEMICOLON:
|
|
case GTK_CSS_TOKEN_CDC:
|
|
case GTK_CSS_TOKEN_CDO:
|
|
case GTK_CSS_TOKEN_INCLUDE_MATCH:
|
|
case GTK_CSS_TOKEN_DASH_MATCH:
|
|
case GTK_CSS_TOKEN_PREFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUFFIX_MATCH:
|
|
case GTK_CSS_TOKEN_SUBSTRING_MATCH:
|
|
case GTK_CSS_TOKEN_COLUMN:
|
|
case GTK_CSS_TOKEN_COMMENT:
|
|
case GTK_CSS_TOKEN_IDENT:
|
|
case GTK_CSS_TOKEN_AT_KEYWORD:
|
|
case GTK_CSS_TOKEN_HASH_UNRESTRICTED:
|
|
case GTK_CSS_TOKEN_HASH_ID:
|
|
case GTK_CSS_TOKEN_DELIM:
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNED_NUMBER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_NUMBER:
|
|
case GTK_CSS_TOKEN_BAD_STRING:
|
|
case GTK_CSS_TOKEN_BAD_URL:
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNED_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_DIMENSION:
|
|
if (out_closing)
|
|
*out_closing = GTK_CSS_TOKEN_EOF;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gtk_css_token_is_ident (const GtkCssToken *token,
|
|
const char *ident)
|
|
{
|
|
return gtk_css_token_is (token, GTK_CSS_TOKEN_IDENT)
|
|
&& (g_ascii_strcasecmp (token->string.string, ident) == 0);
|
|
}
|
|
|
|
gboolean
|
|
gtk_css_token_is_function (const GtkCssToken *token,
|
|
const char *ident)
|
|
{
|
|
return gtk_css_token_is (token, GTK_CSS_TOKEN_FUNCTION)
|
|
&& (g_ascii_strcasecmp (token->string.string, ident) == 0);
|
|
}
|
|
|
|
gboolean
|
|
gtk_css_token_is_delim (const GtkCssToken *token,
|
|
gunichar delim)
|
|
{
|
|
return gtk_css_token_is (token, GTK_CSS_TOKEN_DELIM)
|
|
&& token->delim.delim == delim;
|
|
}
|
|
|
|
void
|
|
gtk_css_token_print (const GtkCssToken *token,
|
|
GString *string)
|
|
{
|
|
char buf[G_ASCII_DTOSTR_BUF_SIZE];
|
|
|
|
switch (token->type)
|
|
{
|
|
case GTK_CSS_TOKEN_STRING:
|
|
append_string (string, token->string.string);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_IDENT:
|
|
append_ident (string, token->string.string);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_URL:
|
|
g_string_append (string, "url(");
|
|
append_ident (string, token->string.string);
|
|
g_string_append (string, ")");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_FUNCTION:
|
|
append_ident (string, token->string.string);
|
|
g_string_append_c (string, '(');
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_AT_KEYWORD:
|
|
g_string_append_c (string, '@');
|
|
append_ident (string, token->string.string);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_HASH_UNRESTRICTED:
|
|
case GTK_CSS_TOKEN_HASH_ID:
|
|
g_string_append_c (string, '#');
|
|
append_ident (string, token->string.string);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_DELIM:
|
|
g_string_append_unichar (string, token->delim.delim);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNED_NUMBER:
|
|
if (token->number.number >= 0)
|
|
g_string_append_c (string, '+');
|
|
G_GNUC_FALLTHROUGH;
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_NUMBER:
|
|
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, token->number.number);
|
|
g_string_append (string, buf);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_PERCENTAGE:
|
|
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, token->number.number);
|
|
g_string_append (string, buf);
|
|
g_string_append_c (string, '%');
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNED_DIMENSION:
|
|
if (token->dimension.value >= 0)
|
|
g_string_append_c (string, '+');
|
|
G_GNUC_FALLTHROUGH;
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_DIMENSION:
|
|
g_ascii_dtostr (buf, G_ASCII_DTOSTR_BUF_SIZE, token->dimension.value);
|
|
g_string_append (string, buf);
|
|
append_ident (string, token->dimension.dimension);
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_EOF:
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_WHITESPACE:
|
|
g_string_append (string, " ");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_OPEN_PARENS:
|
|
g_string_append (string, "(");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_CLOSE_PARENS:
|
|
g_string_append (string, ")");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_OPEN_SQUARE:
|
|
g_string_append (string, "[");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_CLOSE_SQUARE:
|
|
g_string_append (string, "]");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_OPEN_CURLY:
|
|
g_string_append (string, "{");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_CLOSE_CURLY:
|
|
g_string_append (string, "}");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_COMMA:
|
|
g_string_append (string, ",");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_COLON:
|
|
g_string_append (string, ":");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SEMICOLON:
|
|
g_string_append (string, ";");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_CDO:
|
|
g_string_append (string, "<!--");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_CDC:
|
|
g_string_append (string, "-->");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_INCLUDE_MATCH:
|
|
g_string_append (string, "~=");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_DASH_MATCH:
|
|
g_string_append (string, "|=");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_PREFIX_MATCH:
|
|
g_string_append (string, "^=");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SUFFIX_MATCH:
|
|
g_string_append (string, "$=");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_SUBSTRING_MATCH:
|
|
g_string_append (string, "*=");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_COLUMN:
|
|
g_string_append (string, "||");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_BAD_STRING:
|
|
g_string_append (string, "\"\n");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_BAD_URL:
|
|
g_string_append (string, "url(bad url)");
|
|
break;
|
|
|
|
case GTK_CSS_TOKEN_COMMENT:
|
|
g_string_append (string, "/* comment */");
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
char *
|
|
gtk_css_token_to_string (const GtkCssToken *token)
|
|
{
|
|
GString *string;
|
|
|
|
string = g_string_new (NULL);
|
|
gtk_css_token_print (token, string);
|
|
return g_string_free (string, FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_css_token_init_string (GtkCssToken *token,
|
|
GtkCssTokenType type,
|
|
char *string)
|
|
{
|
|
token->type = type;
|
|
|
|
switch ((guint)type)
|
|
{
|
|
case GTK_CSS_TOKEN_STRING:
|
|
case GTK_CSS_TOKEN_IDENT:
|
|
case GTK_CSS_TOKEN_FUNCTION:
|
|
case GTK_CSS_TOKEN_AT_KEYWORD:
|
|
case GTK_CSS_TOKEN_HASH_UNRESTRICTED:
|
|
case GTK_CSS_TOKEN_HASH_ID:
|
|
case GTK_CSS_TOKEN_URL:
|
|
token->string.string = string;
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_css_token_init_delim (GtkCssToken *token,
|
|
gunichar delim)
|
|
{
|
|
token->type = GTK_CSS_TOKEN_DELIM;
|
|
token->delim.delim = delim;
|
|
}
|
|
|
|
static void
|
|
gtk_css_token_init_number (GtkCssToken *token,
|
|
GtkCssTokenType type,
|
|
double value)
|
|
{
|
|
token->type = type;
|
|
|
|
switch ((guint)type)
|
|
{
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER:
|
|
case GTK_CSS_TOKEN_SIGNED_NUMBER:
|
|
case GTK_CSS_TOKEN_SIGNLESS_NUMBER:
|
|
case GTK_CSS_TOKEN_PERCENTAGE:
|
|
token->number.number = value;
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_css_token_init_dimension (GtkCssToken *token,
|
|
GtkCssTokenType type,
|
|
double value,
|
|
char *dimension)
|
|
{
|
|
token->type = type;
|
|
|
|
switch ((guint)type)
|
|
{
|
|
case GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNED_DIMENSION:
|
|
case GTK_CSS_TOKEN_SIGNLESS_DIMENSION:
|
|
token->dimension.value = value;
|
|
token->dimension.dimension = dimension;
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
GtkCssTokenizer *
|
|
gtk_css_tokenizer_new (GBytes *bytes)
|
|
{
|
|
GtkCssTokenizer *tokenizer;
|
|
|
|
tokenizer = g_slice_new0 (GtkCssTokenizer);
|
|
tokenizer->ref_count = 1;
|
|
tokenizer->bytes = g_bytes_ref (bytes);
|
|
tokenizer->name_buffer = g_string_new (NULL);
|
|
|
|
tokenizer->data = g_bytes_get_data (bytes, NULL);
|
|
tokenizer->end = tokenizer->data + g_bytes_get_size (bytes);
|
|
|
|
gtk_css_location_init (&tokenizer->position);
|
|
|
|
return tokenizer;
|
|
}
|
|
|
|
GtkCssTokenizer *
|
|
gtk_css_tokenizer_ref (GtkCssTokenizer *tokenizer)
|
|
{
|
|
tokenizer->ref_count++;
|
|
|
|
return tokenizer;
|
|
}
|
|
|
|
void
|
|
gtk_css_tokenizer_unref (GtkCssTokenizer *tokenizer)
|
|
{
|
|
tokenizer->ref_count--;
|
|
if (tokenizer->ref_count > 0)
|
|
return;
|
|
|
|
g_string_free (tokenizer->name_buffer, TRUE);
|
|
g_bytes_unref (tokenizer->bytes);
|
|
g_slice_free (GtkCssTokenizer, tokenizer);
|
|
}
|
|
|
|
const GtkCssLocation *
|
|
gtk_css_tokenizer_get_location (GtkCssTokenizer *tokenizer)
|
|
{
|
|
return &tokenizer->position;
|
|
}
|
|
|
|
static void G_GNUC_PRINTF(2, 3)
|
|
gtk_css_tokenizer_parse_error (GError **error,
|
|
const char *format,
|
|
...)
|
|
{
|
|
va_list args;
|
|
|
|
va_start (args, format);
|
|
if (error)
|
|
{
|
|
*error = g_error_new_valist (GTK_CSS_PARSER_ERROR,
|
|
GTK_CSS_PARSER_ERROR_SYNTAX,
|
|
format, args);
|
|
}
|
|
else
|
|
{
|
|
char *s = g_strdup_vprintf (format, args);
|
|
g_print ("error: %s\n", s);
|
|
g_free (s);
|
|
}
|
|
va_end (args);
|
|
}
|
|
|
|
static gboolean
|
|
is_newline (char c)
|
|
{
|
|
return c == '\n'
|
|
|| c == '\r'
|
|
|| c == '\f';
|
|
}
|
|
|
|
static gboolean
|
|
is_whitespace (char c)
|
|
{
|
|
return is_newline (c)
|
|
|| c == '\t'
|
|
|| c == ' ';
|
|
}
|
|
|
|
static gboolean
|
|
is_multibyte (char c)
|
|
{
|
|
return c & 0x80;
|
|
}
|
|
|
|
static gboolean
|
|
is_name_start (char c)
|
|
{
|
|
return is_multibyte (c)
|
|
|| g_ascii_isalpha (c)
|
|
|| c == '_';
|
|
}
|
|
|
|
static gboolean
|
|
is_name (char c)
|
|
{
|
|
return is_name_start (c)
|
|
|| g_ascii_isdigit (c)
|
|
|| c == '-';
|
|
}
|
|
|
|
static gboolean
|
|
is_non_printable (char c)
|
|
{
|
|
return (c >= 0 && c <= 0x08)
|
|
|| c == 0x0B
|
|
|| c == 0x0E
|
|
|| c == 0x1F
|
|
|| c == 0x7F;
|
|
}
|
|
|
|
static gboolean
|
|
is_valid_escape (const char *data,
|
|
const char *end)
|
|
{
|
|
switch (end - data)
|
|
{
|
|
default:
|
|
if (is_newline (data[1]))
|
|
return FALSE;
|
|
G_GNUC_FALLTHROUGH;
|
|
|
|
case 1:
|
|
return data[0] == '\\';
|
|
|
|
case 0:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static inline gsize
|
|
gtk_css_tokenizer_remaining (GtkCssTokenizer *tokenizer)
|
|
{
|
|
return tokenizer->end - tokenizer->data;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_has_valid_escape (GtkCssTokenizer *tokenizer)
|
|
{
|
|
return is_valid_escape (tokenizer->data, tokenizer->end);
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_has_identifier (GtkCssTokenizer *tokenizer)
|
|
{
|
|
const char *data = tokenizer->data;
|
|
|
|
if (data == tokenizer->end)
|
|
return FALSE;
|
|
|
|
if (*data == '-')
|
|
{
|
|
data++;
|
|
if (data == tokenizer->end)
|
|
return FALSE;
|
|
if (*data == '-')
|
|
return TRUE;
|
|
}
|
|
|
|
if (is_name_start (*data))
|
|
return TRUE;
|
|
|
|
if (*data == '\\')
|
|
{
|
|
data++;
|
|
if (data == tokenizer->end)
|
|
return TRUE; /* really? */
|
|
if (is_newline (*data))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_has_number (GtkCssTokenizer *tokenizer)
|
|
{
|
|
const char *data = tokenizer->data;
|
|
|
|
if (data == tokenizer->end)
|
|
return FALSE;
|
|
|
|
if (*data == '-' || *data == '+')
|
|
{
|
|
data++;
|
|
if (data == tokenizer->end)
|
|
return FALSE;
|
|
}
|
|
|
|
if (*data == '.')
|
|
{
|
|
data++;
|
|
if (data == tokenizer->end)
|
|
return FALSE;
|
|
}
|
|
|
|
return g_ascii_isdigit (*data);
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_consume_newline (GtkCssTokenizer *tokenizer)
|
|
{
|
|
gsize n;
|
|
|
|
if (gtk_css_tokenizer_remaining (tokenizer) > 1 &&
|
|
tokenizer->data[0] == '\r' && tokenizer->data[1] == '\n')
|
|
n = 2;
|
|
else
|
|
n = 1;
|
|
|
|
tokenizer->data += n;
|
|
gtk_css_location_advance_newline (&tokenizer->position, n == 2 ? TRUE : FALSE);
|
|
}
|
|
|
|
static inline void
|
|
gtk_css_tokenizer_consume (GtkCssTokenizer *tokenizer,
|
|
gsize n_bytes,
|
|
gsize n_characters)
|
|
{
|
|
/* NB: must not contain newlines! */
|
|
tokenizer->data += n_bytes;
|
|
|
|
gtk_css_location_advance (&tokenizer->position, n_bytes, n_characters);
|
|
}
|
|
|
|
static inline void
|
|
gtk_css_tokenizer_consume_ascii (GtkCssTokenizer *tokenizer)
|
|
{
|
|
/* NB: must not contain newlines! */
|
|
gtk_css_tokenizer_consume (tokenizer, 1, 1);
|
|
}
|
|
|
|
static inline void
|
|
gtk_css_tokenizer_consume_whitespace (GtkCssTokenizer *tokenizer)
|
|
{
|
|
if (is_newline (*tokenizer->data))
|
|
gtk_css_tokenizer_consume_newline (tokenizer);
|
|
else
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
}
|
|
|
|
static inline void
|
|
gtk_css_tokenizer_consume_char (GtkCssTokenizer *tokenizer,
|
|
GString *string)
|
|
{
|
|
if (is_newline (*tokenizer->data))
|
|
gtk_css_tokenizer_consume_newline (tokenizer);
|
|
else
|
|
{
|
|
gsize char_size = g_utf8_next_char (tokenizer->data) - tokenizer->data;
|
|
|
|
if (string)
|
|
g_string_append_len (string, tokenizer->data, char_size);
|
|
gtk_css_tokenizer_consume (tokenizer, char_size, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_read_whitespace (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token)
|
|
{
|
|
do {
|
|
gtk_css_tokenizer_consume_whitespace (tokenizer);
|
|
} while (tokenizer->data != tokenizer->end &&
|
|
is_whitespace (*tokenizer->data));
|
|
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_WHITESPACE);
|
|
}
|
|
|
|
static gunichar
|
|
gtk_css_tokenizer_read_escape (GtkCssTokenizer *tokenizer)
|
|
{
|
|
gunichar value = 0;
|
|
guint i;
|
|
|
|
gtk_css_tokenizer_consume (tokenizer, 1, 1);
|
|
|
|
for (i = 0; i < 6 && tokenizer->data < tokenizer->end && g_ascii_isxdigit (*tokenizer->data); i++)
|
|
{
|
|
value = value * 16 + g_ascii_xdigit_value (*tokenizer->data);
|
|
gtk_css_tokenizer_consume (tokenizer, 1, 1);
|
|
}
|
|
|
|
if (i == 0)
|
|
{
|
|
gsize remaining = gtk_css_tokenizer_remaining (tokenizer);
|
|
if (remaining == 0)
|
|
return 0xFFFD;
|
|
|
|
value = g_utf8_get_char_validated (tokenizer->data, remaining);
|
|
if (value == (gunichar) -1 || value == (gunichar) -2)
|
|
value = 0;
|
|
|
|
gtk_css_tokenizer_consume_char (tokenizer, NULL);
|
|
}
|
|
else
|
|
{
|
|
if (is_whitespace (*tokenizer->data))
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
}
|
|
|
|
if (!g_unichar_validate (value) || g_unichar_type (value) == G_UNICODE_SURROGATE)
|
|
return 0xFFFD;
|
|
|
|
return value;
|
|
}
|
|
|
|
static char *
|
|
gtk_css_tokenizer_read_name (GtkCssTokenizer *tokenizer)
|
|
{
|
|
g_string_set_size (tokenizer->name_buffer, 0);
|
|
|
|
do {
|
|
if (*tokenizer->data == '\\')
|
|
{
|
|
if (gtk_css_tokenizer_has_valid_escape (tokenizer))
|
|
{
|
|
gunichar value = gtk_css_tokenizer_read_escape (tokenizer);
|
|
g_string_append_unichar (tokenizer->name_buffer, value);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
|
|
if (tokenizer->data == tokenizer->end)
|
|
{
|
|
g_string_append_unichar (tokenizer->name_buffer, 0xFFFD);
|
|
break;
|
|
}
|
|
|
|
gtk_css_tokenizer_consume_char (tokenizer, tokenizer->name_buffer);
|
|
}
|
|
}
|
|
else if (is_name (*tokenizer->data))
|
|
{
|
|
gtk_css_tokenizer_consume_char (tokenizer, tokenizer->name_buffer);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
while (tokenizer->data != tokenizer->end);
|
|
|
|
return g_strndup (tokenizer->name_buffer->str, tokenizer->name_buffer->len);
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_read_bad_url (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token)
|
|
{
|
|
while (tokenizer->data < tokenizer->end && *tokenizer->data != ')')
|
|
{
|
|
if (gtk_css_tokenizer_has_valid_escape (tokenizer))
|
|
gtk_css_tokenizer_read_escape (tokenizer);
|
|
else
|
|
gtk_css_tokenizer_consume_char (tokenizer, NULL);
|
|
}
|
|
|
|
if (tokenizer->data < tokenizer->end)
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_BAD_URL);
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_read_url (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
GString *url = g_string_new (NULL);
|
|
|
|
while (tokenizer->data < tokenizer->end && is_whitespace (*tokenizer->data))
|
|
gtk_css_tokenizer_consume_whitespace (tokenizer);
|
|
|
|
while (tokenizer->data < tokenizer->end)
|
|
{
|
|
if (*tokenizer->data == ')')
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
break;
|
|
}
|
|
else if (is_whitespace (*tokenizer->data))
|
|
{
|
|
do
|
|
gtk_css_tokenizer_consume_whitespace (tokenizer);
|
|
while (tokenizer->data < tokenizer->end && is_whitespace (*tokenizer->data));
|
|
|
|
if (*tokenizer->data == ')')
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
break;
|
|
}
|
|
else if (tokenizer->data >= tokenizer->end)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_bad_url (tokenizer, token);
|
|
gtk_css_tokenizer_parse_error (error, "Whitespace only allowed at start and end of url");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (is_non_printable (*tokenizer->data))
|
|
{
|
|
gtk_css_tokenizer_read_bad_url (tokenizer, token);
|
|
g_string_free (url, TRUE);
|
|
gtk_css_tokenizer_parse_error (error, "Nonprintable character 0x%02X in url", *tokenizer->data);
|
|
return FALSE;
|
|
}
|
|
else if (*tokenizer->data == '"' ||
|
|
*tokenizer->data == '\'' ||
|
|
*tokenizer->data == '(')
|
|
{
|
|
gtk_css_tokenizer_read_bad_url (tokenizer, token);
|
|
gtk_css_tokenizer_parse_error (error, "Invalid character %c in url", *tokenizer->data);
|
|
g_string_free (url, TRUE);
|
|
return FALSE;
|
|
}
|
|
else if (gtk_css_tokenizer_has_valid_escape (tokenizer))
|
|
{
|
|
g_string_append_unichar (url, gtk_css_tokenizer_read_escape (tokenizer));
|
|
}
|
|
else if (*tokenizer->data == '\\')
|
|
{
|
|
gtk_css_tokenizer_read_bad_url (tokenizer, token);
|
|
gtk_css_tokenizer_parse_error (error, "Newline may not follow '\' escape character");
|
|
g_string_free (url, TRUE);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_consume_char (tokenizer, url);
|
|
}
|
|
}
|
|
|
|
gtk_css_token_init_string (token, GTK_CSS_TOKEN_URL, g_string_free (url, FALSE));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_read_ident_like (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
char *name = gtk_css_tokenizer_read_name (tokenizer);
|
|
|
|
if (*tokenizer->data == '(')
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
if (g_ascii_strcasecmp (name, "url") == 0)
|
|
{
|
|
const char *data = tokenizer->data;
|
|
|
|
while (is_whitespace (*data))
|
|
data++;
|
|
|
|
if (*data != '"' && *data != '\'')
|
|
{
|
|
g_free (name);
|
|
return gtk_css_tokenizer_read_url (tokenizer, token, error);
|
|
}
|
|
}
|
|
|
|
gtk_css_token_init_string (token, GTK_CSS_TOKEN_FUNCTION, name);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
gtk_css_token_init_string (token, GTK_CSS_TOKEN_IDENT, name);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_read_numeric (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token)
|
|
{
|
|
int sign = 1, exponent_sign = 1;
|
|
gint64 integer, fractional = 0, fractional_length = 1, exponent = 0;
|
|
gboolean is_int = TRUE, has_sign = FALSE;
|
|
const char *data = tokenizer->data;
|
|
double value;
|
|
|
|
if (*data == '-')
|
|
{
|
|
has_sign = TRUE;
|
|
sign = -1;
|
|
data++;
|
|
}
|
|
else if (*data == '+')
|
|
{
|
|
has_sign = TRUE;
|
|
data++;
|
|
}
|
|
|
|
for (integer = 0; data < tokenizer->end && g_ascii_isdigit (*data); data++)
|
|
{
|
|
/* check for overflow here? */
|
|
integer = 10 * integer + g_ascii_digit_value (*data);
|
|
}
|
|
|
|
if (data + 1 < tokenizer->end && *data == '.' && g_ascii_isdigit (data[1]))
|
|
{
|
|
is_int = FALSE;
|
|
data++;
|
|
|
|
fractional = g_ascii_digit_value (*data);
|
|
fractional_length = 10;
|
|
data++;
|
|
|
|
while (data < tokenizer->end && g_ascii_isdigit (*data))
|
|
{
|
|
if (fractional_length < G_MAXINT64 / 10)
|
|
{
|
|
fractional = 10 * fractional + g_ascii_digit_value (*data);
|
|
fractional_length *= 10;
|
|
}
|
|
data++;
|
|
}
|
|
}
|
|
|
|
if (data + 1 < tokenizer->end && (*data == 'e' || *data == 'E') &&
|
|
(g_ascii_isdigit (data[1]) ||
|
|
(data + 2 < tokenizer->end && (data[1] == '+' || data[1] == '-') && g_ascii_isdigit (data[2]))))
|
|
{
|
|
is_int = FALSE;
|
|
data++;
|
|
|
|
if (*data == '-')
|
|
{
|
|
exponent_sign = -1;
|
|
data++;
|
|
}
|
|
else if (*data == '+')
|
|
{
|
|
data++;
|
|
}
|
|
|
|
while (data < tokenizer->end && g_ascii_isdigit (*data))
|
|
{
|
|
exponent = 10 * exponent + g_ascii_digit_value (*data);
|
|
data++;
|
|
}
|
|
}
|
|
|
|
gtk_css_tokenizer_consume (tokenizer, data - tokenizer->data, data - tokenizer->data);
|
|
|
|
value = sign * (integer + ((double) fractional / fractional_length)) * pow (10, exponent_sign * exponent);
|
|
|
|
if (gtk_css_tokenizer_has_identifier (tokenizer))
|
|
{
|
|
GtkCssTokenType type;
|
|
|
|
if (is_int)
|
|
type = has_sign ? GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION : GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION;
|
|
else
|
|
type = has_sign ? GTK_CSS_TOKEN_SIGNED_DIMENSION : GTK_CSS_TOKEN_SIGNLESS_DIMENSION;
|
|
|
|
gtk_css_token_init_dimension (token, type, value, gtk_css_tokenizer_read_name (tokenizer));
|
|
}
|
|
else if (gtk_css_tokenizer_remaining (tokenizer) > 0 && *tokenizer->data == '%')
|
|
{
|
|
gtk_css_token_init_number (token, GTK_CSS_TOKEN_PERCENTAGE, value);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
}
|
|
else
|
|
{
|
|
GtkCssTokenType type;
|
|
|
|
if (is_int)
|
|
type = has_sign ? GTK_CSS_TOKEN_SIGNED_INTEGER : GTK_CSS_TOKEN_SIGNLESS_INTEGER;
|
|
else
|
|
type = has_sign ? GTK_CSS_TOKEN_SIGNED_NUMBER : GTK_CSS_TOKEN_SIGNLESS_NUMBER;
|
|
|
|
gtk_css_token_init_number (token, type,value);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_read_delim (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token)
|
|
{
|
|
gtk_css_token_init_delim (token, g_utf8_get_char (tokenizer->data));
|
|
gtk_css_tokenizer_consume_char (tokenizer, NULL);
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_read_dash (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
if (gtk_css_tokenizer_remaining (tokenizer) == 1)
|
|
{
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
return TRUE;
|
|
}
|
|
else if (gtk_css_tokenizer_has_number (tokenizer))
|
|
{
|
|
gtk_css_tokenizer_read_numeric (tokenizer, token);
|
|
return TRUE;
|
|
}
|
|
else if (gtk_css_tokenizer_remaining (tokenizer) >= 3 &&
|
|
tokenizer->data[1] == '-' &&
|
|
tokenizer->data[2] == '>')
|
|
{
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_CDC);
|
|
gtk_css_tokenizer_consume (tokenizer, 3, 3);
|
|
return TRUE;
|
|
}
|
|
else if (gtk_css_tokenizer_has_identifier (tokenizer))
|
|
{
|
|
return gtk_css_tokenizer_read_ident_like (tokenizer, token, error);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_read_string (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
GString *string = g_string_new (NULL);
|
|
char end = *tokenizer->data;
|
|
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
|
|
while (tokenizer->data < tokenizer->end)
|
|
{
|
|
if (*tokenizer->data == end)
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
break;
|
|
}
|
|
else if (*tokenizer->data == '\\')
|
|
{
|
|
if (gtk_css_tokenizer_remaining (tokenizer) == 1)
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
break;
|
|
}
|
|
else if (is_newline (tokenizer->data[1]))
|
|
{
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
gtk_css_tokenizer_consume_newline (tokenizer);
|
|
}
|
|
else
|
|
{
|
|
g_string_append_unichar (string, gtk_css_tokenizer_read_escape (tokenizer));
|
|
}
|
|
}
|
|
else if (is_newline (*tokenizer->data))
|
|
{
|
|
g_string_free (string, TRUE);
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_BAD_STRING);
|
|
gtk_css_tokenizer_parse_error (error, "Newlines inside strings must be escaped");
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_consume_char (tokenizer, string);
|
|
}
|
|
}
|
|
|
|
gtk_css_token_init_string (token, GTK_CSS_TOKEN_STRING, g_string_free (string, FALSE));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_css_tokenizer_read_comment (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
gtk_css_tokenizer_consume (tokenizer, 2, 2);
|
|
|
|
while (tokenizer->data < tokenizer->end)
|
|
{
|
|
if (gtk_css_tokenizer_remaining (tokenizer) > 1 &&
|
|
tokenizer->data[0] == '*' && tokenizer->data[1] == '/')
|
|
{
|
|
gtk_css_tokenizer_consume (tokenizer, 2, 2);
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_COMMENT);
|
|
return TRUE;
|
|
}
|
|
gtk_css_tokenizer_consume_char (tokenizer, NULL);
|
|
}
|
|
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_COMMENT);
|
|
gtk_css_tokenizer_parse_error (error, "Comment not terminated at end of document.");
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_css_tokenizer_read_match (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GtkCssTokenType type)
|
|
{
|
|
if (gtk_css_tokenizer_remaining (tokenizer) > 1 && tokenizer->data[1] == '=')
|
|
{
|
|
gtk_css_token_init (token, type);
|
|
gtk_css_tokenizer_consume (tokenizer, 2, 2);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gtk_css_tokenizer_read_token (GtkCssTokenizer *tokenizer,
|
|
GtkCssToken *token,
|
|
GError **error)
|
|
{
|
|
if (tokenizer->data == tokenizer->end)
|
|
{
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_EOF);
|
|
return TRUE;
|
|
}
|
|
|
|
if (tokenizer->data[0] == '/' && gtk_css_tokenizer_remaining (tokenizer) > 1 &&
|
|
tokenizer->data[1] == '*')
|
|
return gtk_css_tokenizer_read_comment (tokenizer, token, error);
|
|
|
|
switch (*tokenizer->data)
|
|
{
|
|
case '\n':
|
|
case '\r':
|
|
case '\t':
|
|
case '\f':
|
|
case ' ':
|
|
gtk_css_tokenizer_read_whitespace (tokenizer, token);
|
|
return TRUE;
|
|
|
|
case '"':
|
|
return gtk_css_tokenizer_read_string (tokenizer, token, error);
|
|
|
|
case '#':
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
if (is_name (*tokenizer->data) || gtk_css_tokenizer_has_valid_escape (tokenizer))
|
|
{
|
|
GtkCssTokenType type;
|
|
|
|
if (gtk_css_tokenizer_has_identifier (tokenizer))
|
|
type = GTK_CSS_TOKEN_HASH_ID;
|
|
else
|
|
type = GTK_CSS_TOKEN_HASH_UNRESTRICTED;
|
|
|
|
gtk_css_token_init_string (token,
|
|
type,
|
|
gtk_css_tokenizer_read_name (tokenizer));
|
|
}
|
|
else
|
|
{
|
|
gtk_css_token_init_delim (token, '#');
|
|
}
|
|
return TRUE;
|
|
|
|
case '$':
|
|
gtk_css_tokenizer_read_match (tokenizer, token, GTK_CSS_TOKEN_SUFFIX_MATCH);
|
|
return TRUE;
|
|
|
|
case '\'':
|
|
return gtk_css_tokenizer_read_string (tokenizer, token, error);
|
|
|
|
case '(':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_OPEN_PARENS);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case ')':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_CLOSE_PARENS);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '*':
|
|
gtk_css_tokenizer_read_match (tokenizer, token, GTK_CSS_TOKEN_SUBSTRING_MATCH);
|
|
return TRUE;
|
|
|
|
case '+':
|
|
if (gtk_css_tokenizer_has_number (tokenizer))
|
|
gtk_css_tokenizer_read_numeric (tokenizer, token);
|
|
else
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
return TRUE;
|
|
|
|
case ',':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_COMMA);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '-':
|
|
return gtk_css_tokenizer_read_dash (tokenizer, token, error);
|
|
|
|
case '.':
|
|
if (gtk_css_tokenizer_has_number (tokenizer))
|
|
gtk_css_tokenizer_read_numeric (tokenizer, token);
|
|
else
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
return TRUE;
|
|
|
|
case ':':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_COLON);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case ';':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_SEMICOLON);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '<':
|
|
if (gtk_css_tokenizer_remaining (tokenizer) >= 4 &&
|
|
tokenizer->data[1] == '!' &&
|
|
tokenizer->data[2] == '-' &&
|
|
tokenizer->data[3] == '-')
|
|
{
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_CDO);
|
|
gtk_css_tokenizer_consume (tokenizer, 4, 4);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
}
|
|
return TRUE;
|
|
|
|
case '@':
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
if (gtk_css_tokenizer_has_identifier (tokenizer))
|
|
{
|
|
gtk_css_token_init_string (token,
|
|
GTK_CSS_TOKEN_AT_KEYWORD,
|
|
gtk_css_tokenizer_read_name (tokenizer));
|
|
}
|
|
else
|
|
{
|
|
gtk_css_token_init_delim (token, '@');
|
|
}
|
|
return TRUE;
|
|
|
|
case '[':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_OPEN_SQUARE);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '\\':
|
|
if (gtk_css_tokenizer_has_valid_escape (tokenizer))
|
|
{
|
|
return gtk_css_tokenizer_read_ident_like (tokenizer, token, error);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_token_init_delim (token, '\\');
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
gtk_css_tokenizer_parse_error (error, "Newline may not follow '\' escape character");
|
|
return FALSE;
|
|
}
|
|
|
|
case ']':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_CLOSE_SQUARE);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '^':
|
|
gtk_css_tokenizer_read_match (tokenizer, token, GTK_CSS_TOKEN_PREFIX_MATCH);
|
|
return TRUE;
|
|
|
|
case '{':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_OPEN_CURLY);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '}':
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_CLOSE_CURLY);
|
|
gtk_css_tokenizer_consume_ascii (tokenizer);
|
|
return TRUE;
|
|
|
|
case '|':
|
|
if (gtk_css_tokenizer_remaining (tokenizer) > 1 && tokenizer->data[1] == '|')
|
|
{
|
|
gtk_css_token_init (token, GTK_CSS_TOKEN_COLUMN);
|
|
gtk_css_tokenizer_consume (tokenizer, 2, 2);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_match (tokenizer, token, GTK_CSS_TOKEN_DASH_MATCH);
|
|
}
|
|
return TRUE;
|
|
|
|
case '~':
|
|
gtk_css_tokenizer_read_match (tokenizer, token, GTK_CSS_TOKEN_INCLUDE_MATCH);
|
|
return TRUE;
|
|
|
|
default:
|
|
if (g_ascii_isdigit (*tokenizer->data))
|
|
{
|
|
gtk_css_tokenizer_read_numeric (tokenizer, token);
|
|
return TRUE;
|
|
}
|
|
else if (is_name_start (*tokenizer->data))
|
|
{
|
|
return gtk_css_tokenizer_read_ident_like (tokenizer, token, error);
|
|
}
|
|
else
|
|
{
|
|
gtk_css_tokenizer_read_delim (tokenizer, token);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|