/**
* gimp_scanner_new_file:
* @filename:
* @error:
*
* Return value:
*
* Since: GIMP 2.4
**/
GScanner *
gimp_scanner_new_file (const gchar *filename,
GError **error)
{
GScanner *scanner;
GMappedFile *file;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_mapped_file_new (filename, FALSE, error);
if (! file)
{
if (error)
{
(*error)->domain = GIMP_CONFIG_ERROR;
(*error)->code = ((*error)->code == G_FILE_ERROR_NOENT ?
GIMP_CONFIG_ERROR_OPEN_ENOENT :
GIMP_CONFIG_ERROR_OPEN);
}
return NULL;
}
/* gimp_scanner_new() takes a "name" for the scanner, not a filename */
scanner = gimp_scanner_new (gimp_filename_to_utf8 (filename), file, error);
g_scanner_input_text (scanner,
g_mapped_file_get_contents (file),
g_mapped_file_get_length (file));
return scanner;
}
XfdashboardCssSelector* xfdashboard_css_selector_new_from_string_with_priority(const gchar *inSelector, gint inPriority)
{
GObject *selector;
GScanner *scanner;
g_return_val_if_fail(inSelector || *inSelector, NULL);
/* Create selector instance */
selector=g_object_new(XFDASHBOARD_TYPE_CSS_SELECTOR,
"priority", inPriority,
NULL);
if(!selector)
{
g_warning(_("Could not create seleector."));
return(NULL);
}
/* Create scanner for requested string */
scanner=g_scanner_new(NULL);
g_scanner_input_text(scanner, inSelector, strlen(inSelector));
/* Parse string with created scanner */
if(!_xfdashboard_css_selector_parse(XFDASHBOARD_CSS_SELECTOR(selector), scanner))
{
g_object_unref(selector);
selector=NULL;
}
/* If scanner does not point to EOF after parsing, it is an error and selector
* needs to be destroyed.
*/
if(selector &&
!g_scanner_eof(scanner))
{
/* It is not the end of string so print parser error message */
g_scanner_unexp_token(scanner,
G_TOKEN_EOF,
NULL,
NULL,
NULL,
_("Parser did not reach end of stream"),
TRUE);
g_object_unref(selector);
selector=NULL;
}
/* Destroy allocated resources */
g_scanner_destroy(scanner);
/* Return created selector which may be NULL in case of error */
return(XFDASHBOARD_CSS_SELECTOR(selector));
}
/**
* gimp_scanner_new_string:
* @text:
* @text_len:
* @error:
*
* Return value:
*
* Since: 2.4
**/
GScanner *
gimp_scanner_new_string (const gchar *text,
gint text_len,
GError **error)
{
GScanner *scanner;
g_return_val_if_fail (text != NULL || text_len == 0, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (text_len < 0)
text_len = strlen (text);
scanner = gimp_scanner_new (NULL, NULL, NULL, error);
g_scanner_input_text (scanner, text, text_len);
return scanner;
}
/*
* static JConfig *j_config_parse_any(JConfigCtxt *cfc,
* const gchar *input_name,
* gint input_fd,
* const gchar *input_string,
* gint input_len)
*
* The real initial parsing routine.
* Creates the JConfig and structures and then
* calls j_config_parse_base();
*
* some of this is ripped from gtkrc.c
*/
static JConfig *j_config_parse_any(JConfigCtxt *cfc,
const gchar *input_name,
gint input_fd,
const gchar *input_string,
gint input_len)
{
GScanner *scanner;
scanner = g_scanner_new((GScannerConfig *)&test_config);
if (input_fd >= 0)
{
g_assert(input_string == NULL);
g_scanner_input_file(scanner, input_fd);
}
else
{
g_assert(input_string != NULL);
g_assert(input_len >= 0);
g_scanner_input_text(scanner, input_string, input_len);
}
scanner->input_name = input_name;
cfc->cf = j_config_config_new();
if (cfc->cf == NULL)
{
if (cfc->verbose)
{
g_warning("Unable to create a JConfig structure: %s\n",
g_strerror(errno));
}
cfc->error = TRUE;
return(NULL);
}
cfc->cf->filename = g_strdup(input_name);
j_config_parse_base(scanner, cfc);
g_scanner_destroy(scanner);
return(cfc->cf);
} /* j_config_parse_any() */
static void field_instruction_end(ParserContext *ctx)
{
FieldInstructionState *state = get_state(ctx);
gchar *field_type, *buffer;
GSList *switches = NULL, *formatswitches = NULL, *iter;
const FieldInfo *field_info = fields;
GScanner *tokenizer = g_scanner_new(&field_parser);
g_scanner_input_text(tokenizer, state->scanbuffer->str, strlen(state->scanbuffer->str));
/* Get field type */
if(!(field_type = get_string_token(tokenizer)))
return;
/* Determine if field type is supported and get switches and arguments */
while(field_info->name != NULL)
{
if(g_ascii_strcasecmp(field_type, field_info->name) == 0)
{
state->type = field_info->type;
switches = get_switches(tokenizer, switches, field_info->switches, field_info->argswitches, field_info->wideswitches, field_info->wideargswitches);
if(field_info->has_argument)
{
if(!(buffer = get_string_token(tokenizer)))
return;
state->argument = g_strdup(buffer);
switches = get_switches(tokenizer, switches, field_info->switches, field_info->argswitches, field_info->wideswitches, field_info->wideargswitches);
}
break;
}
field_info++;
}
if(field_info->name == NULL) /* Field name wasn't found in list */
{
g_warning(_("'%s' field not supported"), field_type);
g_scanner_destroy(tokenizer);
return;
}
formatswitches = get_switches(tokenizer, formatswitches, "", "@#*", "", "");
for(iter = formatswitches; iter; iter = g_slist_next(iter))
{
SwitchInfo *info = (SwitchInfo *)iter->data;
/* Parse a date format consisting of \@ and a string */
if(strcmp(info->switchname, "@") == 0)
state->date_format = g_strdup(info->switcharg);
/* Parse a numeric format consisting of \# and a string */
else if(strcmp(info->switchname, "#") == 0)
state->numeric_format = g_strdup(info->switcharg);
/* Parse a general format consisting of \* and a keyword */
else if(strcmp(info->switchname, "*") == 0)
{
if(strcmp(info->switcharg, "ALPHABETIC") == 0)
state->general_number_format = NUMBER_ALPHABETIC;
else if(strcmp(info->switcharg, "alphabetic") == 0)
state->general_number_format = NUMBER_alphabetic;
else if(strcmp(info->switcharg, "Arabic") == 0)
state->general_number_format = NUMBER_ARABIC;
else if(strcmp(info->switcharg, "ArabicDash") == 0)
state->general_number_format = NUMBER_ARABIC_DASH;
else if(strcmp(info->switcharg, "CIRCLENUM") == 0)
state->general_number_format = NUMBER_CIRCLENUM;
else if(strcmp(info->switcharg, "GB1") == 0)
state->general_number_format = NUMBER_DECIMAL_ENCLOSED_PERIOD;
else if(strcmp(info->switcharg, "GB2") == 0)
state->general_number_format = NUMBER_DECIMAL_ENCLOSED_PARENTHESES;
else if(strcmp(info->switcharg, "Hex") == 0)
state->general_number_format = NUMBER_HEX;
else if(strcmp(info->switcharg, "MERGEFORMATINET") == 0)
; /* ignore */
else if(strcmp(info->switcharg, "Ordinal") == 0)
state->general_number_format = NUMBER_ORDINAL;
else if(strcmp(info->switcharg, "Roman") == 0)
state->general_number_format = NUMBER_ROMAN;
else if(strcmp(info->switcharg, "roman") == 0)
state->general_number_format = NUMBER_roman;
else
g_warning(_("Format '%s' not supported"), info->switcharg);
/* Just continue */
}
}
Destination *fielddest = g_queue_peek_nth(ctx->destination_stack, 1);
FieldState *fieldstate = g_queue_peek_tail(fielddest->state_stack);
switch(state->type)
{
case FIELD_TYPE_HYPERLINK:
/* Actually inserting hyperlinks into the text buffer is a whole
security can of worms I don't want to open! Just use field result */
fieldstate->ignore_field_result = FALSE;
break;
case FIELD_TYPE_INCLUDEPICTURE:
{
GError *error = NULL;
gchar **pathcomponents = g_strsplit(state->argument, "\\", 0);
gchar *realfilename = g_build_filenamev(pathcomponents);
g_strfreev(pathcomponents);
GdkPixbuf *picture = gdk_pixbuf_new_from_file(realfilename, &error);
if(!picture)
g_warning(_("Error loading picture from file '%s': %s"), realfilename, error->message);
else
{
/* Insert picture into text buffer */
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark(ctx->textbuffer, &iter, ctx->endmark);
gtk_text_buffer_insert_pixbuf(ctx->textbuffer, &iter, picture);
g_object_unref(picture);
}
g_free(realfilename);
}
/* Don't use calculated field result */
fieldstate->ignore_field_result = TRUE;
break;
case FIELD_TYPE_PAGE:
{
gchar *output = format_integer(1, state->general_number_format);
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark(ctx->textbuffer, &iter, ctx->endmark);
gtk_text_buffer_insert(ctx->textbuffer, &iter, output, -1);
g_free(output);
}
/* Don't use calculated field result */
fieldstate->ignore_field_result = TRUE;
break;
default:
g_assert_not_reached();
}
g_free(state->argument);
g_free(state->date_format);
g_free(state->numeric_format);
g_slist_foreach(switches, (GFunc)free_switch_info, NULL);
g_slist_foreach(formatswitches, (GFunc)free_switch_info, NULL);
g_scanner_destroy(tokenizer);
}
/**
* gimp_scanner_new_stream:
* @input: a #GInputStream
* @error: return location for #GError, or %NULL
*
* Return value: The new #GScanner.
*
* Since: 2.10
**/
GScanner *
gimp_scanner_new_stream (GInputStream *input,
GError **error)
{
GScanner *scanner;
GFile *file;
const gchar *path;
GString *string;
gchar buffer[4096];
gsize bytes_read;
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_object_get_data (G_OBJECT (input), "gimp-file");
if (file)
path = gimp_file_get_utf8_name (file);
else
path = "stream";
string = g_string_new (NULL);
do
{
GError *my_error = NULL;
gboolean success;
success = g_input_stream_read_all (input, buffer, sizeof (buffer),
&bytes_read, NULL, &my_error);
if (bytes_read > 0)
g_string_append_len (string, buffer, bytes_read);
if (! success)
{
if (string->len > 0)
{
g_printerr ("%s: read error in '%s', trying to scan "
"partial content: %s",
G_STRFUNC, path, my_error->message);
g_clear_error (&my_error);
break;
}
g_string_free (string, TRUE);
g_propagate_error (error, my_error);
return NULL;
}
}
while (bytes_read == sizeof (buffer));
/* gimp_scanner_new() takes a "name" for the scanner, not a filename */
scanner = gimp_scanner_new (path, NULL, string->str, error);
bytes_read = string->len;
g_scanner_input_text (scanner, g_string_free (string, FALSE), bytes_read);
return scanner;
}
/**
* gimp_scanner_new_gfile:
* @file: a #GFile
* @error: return location for #GError, or %NULL
*
* Return value: The new #GScanner.
*
* Since: 2.10
**/
GScanner *
gimp_scanner_new_gfile (GFile *file,
GError **error)
{
GScanner *scanner;
gchar *path;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
path = g_file_get_path (file);
if (path)
{
GMappedFile *mapped;
mapped = g_mapped_file_new (path, FALSE, error);
g_free (path);
if (! mapped)
{
if (error)
{
(*error)->domain = GIMP_CONFIG_ERROR;
(*error)->code = ((*error)->code == G_FILE_ERROR_NOENT ?
GIMP_CONFIG_ERROR_OPEN_ENOENT :
GIMP_CONFIG_ERROR_OPEN);
}
return NULL;
}
/* gimp_scanner_new() takes a "name" for the scanner, not a filename */
scanner = gimp_scanner_new (gimp_file_get_utf8_name (file),
mapped, NULL, error);
g_scanner_input_text (scanner,
g_mapped_file_get_contents (mapped),
g_mapped_file_get_length (mapped));
}
else
{
GInputStream *input;
input = G_INPUT_STREAM (g_file_read (file, NULL, error));
if (! input)
{
if (error)
{
(*error)->domain = GIMP_CONFIG_ERROR;
(*error)->code = ((*error)->code == G_IO_ERROR_NOT_FOUND ?
GIMP_CONFIG_ERROR_OPEN_ENOENT :
GIMP_CONFIG_ERROR_OPEN);
}
return NULL;
}
g_object_set_data (G_OBJECT (input), "gimp-data", file);
scanner = gimp_scanner_new_stream (input, error);
g_object_unref (input);
}
return scanner;
}
static GstFlowReturn
gst_pnmdec_parse_ascii (GstPnmdec * s, const guint8 * b, guint bs)
{
GScanner *scanner;
guint i = 0;
guint target;
GstMapInfo map;
guint8 *outdata;
target = s->size - s->current_size;
gst_buffer_map (s->buf, &map, GST_MAP_WRITE);
/* leave the number of bytes already parsed */
outdata = map.data + s->current_size;
if (!bs) {
goto drop_ok;
}
if (s->last_byte) {
while (*b >= '0' && *b <= '9') {
s->last_byte = 10 * s->last_byte + *b - '0';
b++;
if (!--bs) {
goto drop_error;
}
}
if (s->last_byte > 255) {
GST_DEBUG_OBJECT (s, "Corrupt ASCII encoded PNM file.");
goto drop_error;
}
}
if (s->last_byte) {
outdata[i++] = s->last_byte;
s->last_byte = 0;
}
scanner = g_scanner_new (NULL);
g_scanner_input_text (scanner, (gchar *) b, bs);
while (!g_scanner_eof (scanner)) {
switch (g_scanner_get_next_token (scanner)) {
case G_TOKEN_INT:
if (i == target) {
GST_DEBUG_OBJECT (s, "PNM file contains too much data.");
g_scanner_destroy (scanner);
goto drop_error;
}
outdata[i++] = scanner->value.v_int;
break;
default:
/* Should we care? */ ;
}
}
g_scanner_destroy (scanner);
/* If we didn't get the whole image, handle the last byte with care. */
if (i && i < target && b[bs - 1] > '0' && b[bs - 1] <= '9') {
s->last_byte = outdata[--i];
}
/* Update the number of bytes parsed in this scan */
s->current_size += i;
gst_buffer_unmap (s->buf, &map);
return GST_FLOW_OK;
drop_ok:
gst_buffer_unmap (s->buf, &map);
return GST_FLOW_OK;
drop_error:
gst_buffer_unmap (s->buf, &map);
return GST_FLOW_ERROR;
}
