static void player_filter_load_patterns (void) {
char *fn;
int fd;
GScanner *scanner;
int retval;
int i;
fn = file_in_dir (user_rcdir, PLAYERS_FILE);
fd = open (fn, O_RDONLY);
if (fd < 0) {
g_free (fn);
return;
}
scanner = g_scanner_new (&patterns_scanner_config);
for (i = TOKEN_STRING; i <= TOKEN_REGEXP; i++) {
g_scanner_add_symbol (scanner, mode_symbols[i - TOKEN_STRING],
GINT_TO_POINTER(i));
}
g_scanner_input_file (scanner, fd);
do {
retval = player_pattern_parse_statement (scanner, fn);
} while (retval);
g_scanner_destroy (scanner);
g_free (fn);
close (fd);
if (filters[FILTER_PLAYER].changed != FILTER_NOT_CHANGED)
filters[FILTER_PLAYER].last_changed = filter_time_inc();
}
/* Get the next token from the scanner and make sure it is a string. Do not free
the returned value. */
static gchar *
get_string_token(GScanner *tokenizer)
{
GTokenType token;
if(g_scanner_eof(tokenizer))
{
g_warning(_("Unexpected end of field instructions"));
g_scanner_destroy(tokenizer);
return NULL;
}
token = g_scanner_get_next_token(tokenizer);
if(token != G_TOKEN_STRING)
{
g_warning(_("Expected a string in field instructions"));
g_scanner_destroy(tokenizer);
return NULL;
}
return tokenizer->value.v_string;
}
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));
}
/**
* gtk_accel_map_load_fd:
* @fd: a valid readable file descriptor
*
* Filedescriptor variant of gtk_accel_map_load().
*
* Note that the file descriptor will not be closed by this function.
*/
void
gtk_accel_map_load_fd (gint fd)
{
GScanner *scanner;
g_return_if_fail (fd >= 0);
/* create and setup scanner */
scanner = g_scanner_new (NULL);
g_scanner_input_file (scanner, fd);
gtk_accel_map_load_scanner (scanner);
g_scanner_destroy (scanner);
}
/**
* gimp_scanner_destroy:
* @scanner:
*
* Since: GIMP 2.4
**/
void
gimp_scanner_destroy (GScanner *scanner)
{
GimpScannerData *data;
g_return_if_fail (scanner != NULL);
data = scanner->user_data;
if (data->file)
g_mapped_file_unref (data->file);
g_free (data->name);
g_slice_free (GimpScannerData, data);
g_scanner_destroy (scanner);
}
/*
Parses a given file with a GScanner and stores a word count in the given GHashTable
@param {char *} filename - path of the file to parse
@param {GHashTable *} table - hash table in which to store the word counts
*/
void parse_file(char* filename, GHashTable* table) {
GScanner* scanner = make_scanner(filename);
char *key;
int i = 0;
while (1) {
g_scanner_get_next_token(scanner);
if (scanner->token == G_TOKEN_EOF) break;
if (scanner->token == G_TOKEN_IDENTIFIER) {
if (scanner->value.v_string != NULL) {
//g_printf("string->%s\n", scanner->value.v_string);
insert_word(scanner->value.v_string, table);
i++;
}
}
}
//g_printf("Total Word Count: %i\n", i);
g_scanner_destroy(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() */
void test_parse_rcp(void)
{
GScanner *scan;
FILE *fp;
GTokenType tok;
fp = fopen("test.rcp", "r");
if (fp == NULL) {
err_printf("cannot open test.rcp\n");
return;
}
scan = init_scanner();
g_scanner_input_file(scan, fileno(fp));
do {
tok = g_scanner_get_next_token(scan);
print_token(scan, tok);
} while (tok != G_TOKEN_EOF);
g_scanner_destroy(scan);
}
/*----------------------- read conf (.guvcviewrc(-videoX)) file -----------------------*/
int
readConf(struct GLOBAL *global)
{
int ret=0;
// int signal=1; /*1=>+ or -1=>-*/
GScanner *scanner;
GTokenType ttype;
GScannerConfig config =
{
" \t\r\n", /* characters to skip */
G_CSET_a_2_z "_" G_CSET_A_2_Z, /* identifier start */
G_CSET_a_2_z "_." G_CSET_A_2_Z G_CSET_DIGITS,/* identifier cont. */
"#\n", /* single line comment */
FALSE, /* case_sensitive */
TRUE, /* skip multi-line comments */
TRUE, /* skip single line comments */
FALSE, /* scan multi-line comments */
TRUE, /* scan identifiers */
TRUE, /* scan 1-char identifiers */
FALSE, /* scan NULL identifiers */
FALSE, /* scan symbols */
FALSE, /* scan binary */
FALSE, /* scan octal */
TRUE, /* scan float */
TRUE, /* scan hex */
FALSE, /* scan hex dollar */
TRUE, /* scan single quote strings */
TRUE, /* scan double quote strings */
TRUE, /* numbers to int */
FALSE, /* int to float */
TRUE, /* identifier to string */
TRUE, /* char to token */
FALSE, /* symbol to token */
FALSE, /* scope 0 fallback */
TRUE /* store int64 */
};
int fd = g_open (global->confPath, O_RDONLY, 0);
if (fd < 0 )
{
printf("Could not open %s for read,\n will try to create it\n",global->confPath);
ret=writeConf(global, global->videodevice);
}
else
{
scanner = g_scanner_new (&config);
g_scanner_input_file (scanner, fd);
scanner->input_name = global->confPath;
for (ttype = g_scanner_get_next_token (scanner);
ttype != G_TOKEN_EOF;
ttype = g_scanner_get_next_token (scanner))
{
if (ttype == G_TOKEN_STRING)
{
//printf("reading %s...\n",scanner->value.v_string);
char *name = g_strdup (scanner->value.v_string);
ttype = g_scanner_get_next_token (scanner);
if (ttype != G_TOKEN_EQUAL_SIGN)
{
g_scanner_unexp_token (scanner,
G_TOKEN_EQUAL_SIGN,
NULL,
NULL,
NULL,
NULL,
FALSE);
}
else
{
ttype = g_scanner_get_next_token (scanner);
/*check for signed integers*/
if(ttype == '-')
{
//signal = -1;
ttype = g_scanner_get_next_token (scanner);
}
if (ttype == G_TOKEN_STRING)
{
//signal=1; /*reset signal*/
//if (g_strcmp0(name,"video_device")==0)
//{
// g_snprintf(global->videodevice,15,"%s",scanner->value.v_string);
//}
/*must check for defaults since ReadOpts runs before ReadConf*/
if (g_strcmp0(name,"resolution")==0)
{
if(global->flg_res < 1)
sscanf(scanner->value.v_string,"%ix%i",
&(global->width),
&(global->height));
}
else if (g_strcmp0(name,"windowsize")==0)
{
sscanf(scanner->value.v_string,"%ix%i",
&(global->winwidth), &(global->winheight));
}
else if (g_strcmp0(name,"mode")==0)
{
if(global->flg_mode < 1)
{
/*use fourcc but keep it compatible with luvcview*/
if(g_strcmp0(scanner->value.v_string,"yuv") == 0)
g_snprintf(global->mode,5,"yuyv");
else
g_snprintf(global->mode,5,"%s",scanner->value.v_string);
}
}
else if (g_strcmp0(name,"fps")==0)
{
sscanf(scanner->value.v_string,"%i/%i",
&(global->fps_num), &(global->fps));
}
#if 0
else if (g_strcmp0(name,"image_path")==0)
{
if(global->flg_imgFPath < 1)
{
global->imgFPath = splitPath(scanner->value.v_string,global->imgFPath);
/*get the file type*/
global->imgFormat = check_image_type(global->imgFPath[0]);
}
}
else if ((g_strcmp0(name,"video_path")==0) || (g_strcmp0(name,"avi_path")==0))
{
if(global->vidfile == NULL)
{
global->vidFPath=splitPath(scanner->value.v_string,global->vidFPath);
/*get the file type (0-avi 1-matroska)*/
global->VidFormat = check_video_type(global->vidFPath[0]);
}
}
else
{
printf("unexpected string value (%s) for %s\n",
scanner->value.v_string, name);
}
#endif
}
else if (ttype==G_TOKEN_INT)
{
if (g_strcmp0(name,"stack_size")==0)
{
global->stack_size = scanner->value.v_int;
}
else if (g_strcmp0(name,"vid_sleep")==0)
{
global->vid_sleep = scanner->value.v_int;
}
else if (g_strcmp0(name,"cap_meth")==0)
{
if(!(global->flg_cap_meth))
global->cap_meth = scanner->value.v_int;
}
else if (g_strcmp0(name,"vpane")==0)
{
global->boxvsize = scanner->value.v_int;
}
else if (g_strcmp0(name,"spinbehave")==0)
{
global->spinbehave = scanner->value.v_int;
}
else if (g_strcmp0(name,"fps")==0)
{
/*parse non-quoted fps values*/
int line = g_scanner_cur_line(scanner);
global->fps_num = scanner->value.v_int;
ttype = g_scanner_peek_next_token (scanner);
if(ttype=='/')
{
/*get '/'*/
ttype = g_scanner_get_next_token (scanner);
ttype = g_scanner_peek_next_token (scanner);
if(ttype==G_TOKEN_INT)
{
ttype = g_scanner_get_next_token (scanner);
global->fps = scanner->value.v_int;
}
else if (scanner->next_line>line)
{
/*start new loop*/
break;
}
else
{
ttype = g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner,
G_TOKEN_NONE,
NULL,
NULL,
NULL,
"bad value for fps",
FALSE);
}
}
}
else if (strcmp(name,"fps_display")==0)
{
if(global->flg_FpsCount < 1)
global->FpsCount = (short) scanner->value.v_int;
}
else if (g_strcmp0(name,"auto_focus")==0)
{
global->autofocus = scanner->value.v_int;
}
else if (g_strcmp0(name,"bpp")==0)
{
global->bpp = scanner->value.v_int;
}
else if (g_strcmp0(name,"hwaccel")==0)
{
if(global->flg_hwaccel < 1)
global->hwaccel = scanner->value.v_int;
}
else if (g_strcmp0(name,"vid_codec")==0 || (g_strcmp0(name,"avi_format")==0))
{
global->VidCodec = scanner->value.v_int;
}
else if ((g_strcmp0(name,"vid_inc")==0) || (g_strcmp0(name,"avi_inc")==0))
{
global->vid_inc = (DWORD) scanner->value.v_int;
g_snprintf(global->vidinc_str,20,_("File num:%d"),global->vid_inc);
}
else if (g_strcmp0(name,"frame_flags")==0)
{
global->Frame_Flags = scanner->value.v_int;
}
else if (g_strcmp0(name,"image_inc")==0)
{
if(global->image_timer <= 0)
{
global->image_inc = (DWORD) scanner->value.v_int;
g_snprintf(global->imageinc_str,20,_("File num:%d"),global->image_inc);
}
}
/*
else
{
printf("unexpected integer value (%lu) for %s\n",
scanner->value.v_int, name);
printf("Strings must be quoted\n");
}
*/
}
else if (ttype==G_TOKEN_FLOAT)
{
printf("unexpected float value (%f) for %s\n", scanner->value.v_float, name);
}
else if (ttype==G_TOKEN_CHAR)
{
printf("unexpected char value (%c) for %s\n", scanner->value.v_char, name);
}
else
{
g_scanner_unexp_token (scanner,
G_TOKEN_NONE,
NULL,
NULL,
NULL,
"string values must be quoted - skiping",
FALSE);
int line = g_scanner_cur_line (scanner);
int stp=0;
do
{
ttype = g_scanner_peek_next_token (scanner);
if(scanner->next_line > line)
{
//printf("next line reached\n");
stp=1;
break;
}
else
{
ttype = g_scanner_get_next_token (scanner);
}
}
while (!stp);
}
}
g_free(name);
}
}
g_scanner_destroy (scanner);
close (fd);
if (global->debug)
{
g_printf("video_device: %s\n",global->videodevice);
// g_printf("vid_sleep: %i\n",global->vid_sleep);
g_printf("cap_meth: %i\n",global->cap_meth);
g_printf("resolution: %i x %i\n",global->width,global->height);
// g_printf("windowsize: %i x %i\n",global->winwidth,global->winheight);
// g_printf("vert pane: %i\n",global->boxvsize);
// g_printf("spin behavior: %i\n",global->spinbehave);
// g_printf("mode: %s\n",global->mode);
g_printf("fps: %i/%i\n",global->fps_num,global->fps);
g_printf("Display Fps: %i\n",global->FpsCount);
g_printf("bpp: %i\n",global->bpp);
g_printf("hwaccel: %i\n",global->hwaccel);
// g_printf("avi_format: %i\n",global->VidCodec);
g_printf("Pan Step: %i degrees\n",global->PanStep);
g_printf("Tilt Step: %i degrees\n",global->TiltStep);
g_printf("Video Filter Flags: %i\n",global->Frame_Flags);
// g_printf("image inc: %d\n",global->image_inc);
}
}
return (ret);
}
static gchar*
parse_libtool_archive (const gchar* libtool_name)
{
const guint TOKEN_DLNAME = G_TOKEN_LAST + 1;
const guint TOKEN_INSTALLED = G_TOKEN_LAST + 2;
const guint TOKEN_LIBDIR = G_TOKEN_LAST + 3;
gchar *lt_dlname = NULL;
gboolean lt_installed = TRUE;
gchar *lt_libdir = NULL;
gchar *name;
GTokenType token;
GScanner *scanner;
int fd = g_open (libtool_name, O_RDONLY, 0);
if (fd < 0)
{
gchar *display_libtool_name = g_filename_display_name (libtool_name);
g_module_set_error_unduped (g_strdup_printf ("failed to open libtool archive \"%s\"", display_libtool_name));
g_free (display_libtool_name);
return NULL;
}
/* search libtool's dlname specification */
scanner = g_scanner_new (NULL);
g_scanner_input_file (scanner, fd);
scanner->config->symbol_2_token = TRUE;
g_scanner_scope_add_symbol (scanner, 0, "dlname",
GUINT_TO_POINTER (TOKEN_DLNAME));
g_scanner_scope_add_symbol (scanner, 0, "installed",
GUINT_TO_POINTER (TOKEN_INSTALLED));
g_scanner_scope_add_symbol (scanner, 0, "libdir",
GUINT_TO_POINTER (TOKEN_LIBDIR));
while (!g_scanner_eof (scanner))
{
token = g_scanner_get_next_token (scanner);
if (token == TOKEN_DLNAME || token == TOKEN_INSTALLED ||
token == TOKEN_LIBDIR)
{
if (g_scanner_get_next_token (scanner) != '=' ||
g_scanner_get_next_token (scanner) !=
(token == TOKEN_INSTALLED ?
G_TOKEN_IDENTIFIER : G_TOKEN_STRING))
{
gchar *display_libtool_name = g_filename_display_name (libtool_name);
g_module_set_error_unduped (g_strdup_printf ("unable to parse libtool archive \"%s\"", display_libtool_name));
g_free (display_libtool_name);
g_free (lt_dlname);
g_free (lt_libdir);
g_scanner_destroy (scanner);
close (fd);
return NULL;
}
else
{
if (token == TOKEN_DLNAME)
{
g_free (lt_dlname);
lt_dlname = g_strdup (scanner->value.v_string);
}
else if (token == TOKEN_INSTALLED)
lt_installed =
strcmp (scanner->value.v_identifier, "yes") == 0;
else /* token == TOKEN_LIBDIR */
{
g_free (lt_libdir);
lt_libdir = g_strdup (scanner->value.v_string);
}
}
}
}
if (!lt_installed)
{
gchar *dir = g_path_get_dirname (libtool_name);
g_free (lt_libdir);
lt_libdir = g_strconcat (dir, G_DIR_SEPARATOR_S ".libs", NULL);
g_free (dir);
}
name = g_strconcat (lt_libdir, G_DIR_SEPARATOR_S, lt_dlname, NULL);
g_free (lt_dlname);
g_free (lt_libdir);
g_scanner_destroy (scanner);
close (fd);
return name;
}
static gint Prefs_load(void)
{
GScanner *scanner;
gint fd;
guint i, expected_token;
gchar *file;
/* Here we load and set options from dillorc */
file = a_Misc_prepend_user_home(".dillo/dillorc");
fd = open(file, O_RDONLY);
g_free(file);
if (fd < 0 && (fd = open(DILLORC_SYS, O_RDONLY)) < 0)
return FILE_NOT_FOUND;
fcntl(fd, F_SETFD, FD_CLOEXEC | fcntl(fd, F_GETFD));
scanner = g_scanner_new(NULL);
/* Adjust lexing behaviour to suit our needs */
/* Specifies the chars which can be used in identifiers */
scanner->config->cset_identifier_nth = (
G_CSET_a_2_z
"~+-_:&%#/.0123456789"
G_CSET_A_2_Z
G_CSET_LATINS /*??? I don't know if we need these two */
G_CSET_LATINC /*??? */
);
/* Specifies the chars which can start identifiers */
scanner->config->cset_identifier_first = (
G_CSET_a_2_z
G_CSET_A_2_Z
"_0123456789"
);
/* Don't return G_TOKEN_SYMBOL, but the symbol's value */
scanner->config->symbol_2_token = TRUE;
/* Don't return G_TOKEN_IDENTIFIER, but convert it to string */
scanner->config->identifier_2_string = TRUE;
/* load symbols into the scanner */
g_scanner_freeze_symbol_table(scanner);
for (i = 0; i < n_symbols; i++)
g_scanner_add_symbol(scanner, symbols[i].name,
GINT_TO_POINTER (symbols[i].token));
g_scanner_thaw_symbol_table(scanner);
/* feed in the text */
g_scanner_input_file(scanner, fd);
/* give the error handler an idea on how the input is named */
scanner->input_name = "dillorc";
/*
* Scanning loop, we parse the input until it's end is reached,
* the scanner encountered a lexing error, or our sub routine came
* across invalid syntax
*/
do {
expected_token = Prefs_parser(scanner);
/* Give an error message upon syntax errors */
if (expected_token == G_TOKEN_SYMBOL)
g_scanner_unexp_token (scanner, expected_token, NULL, "symbol", NULL,
NULL, FALSE);
else if (expected_token == G_TOKEN_STRING)
g_scanner_unexp_token (scanner, expected_token, NULL, "string", NULL,
NULL, FALSE);
else if (expected_token == G_TOKEN_EQUAL_SIGN)
g_scanner_unexp_token (scanner, expected_token, NULL, "=", NULL,
NULL, FALSE);
g_scanner_peek_next_token (scanner);
} while ( /* expected_token == G_TOKEN_NONE && */
scanner->next_token != G_TOKEN_EOF &&
scanner->next_token != G_TOKEN_ERROR);
/* give an error message upon syntax errors */
if (expected_token != G_TOKEN_NONE)
g_scanner_unexp_token(scanner, expected_token, NULL, "symbol", NULL,
NULL, TRUE);
/* finish parsing */
g_scanner_destroy(scanner);
close(fd);
return PARSE_OK;
}
static GslWaveFileInfo*
gslwave_load_file_info (gpointer data,
const gchar *_file_name,
GslErrorType *error_p)
{
FileInfo *fi = NULL;
gboolean in_wave = FALSE, abort = FALSE;
GslRing *wave_names = NULL;
GScanner *scanner;
gchar *cwd, *file_name;
gint fd;
guint i;
if (g_path_is_absolute (_file_name))
{
gchar *p = strrchr (_file_name, G_DIR_SEPARATOR);
g_assert (p != NULL);
cwd = g_strndup (_file_name, p - _file_name + 1);
file_name = g_strdup (_file_name);
}
else
{
cwd = g_get_current_dir ();
file_name = g_strdup_printf ("%s%c%s", cwd, G_DIR_SEPARATOR, _file_name);
}
fd = open (file_name, O_RDONLY);
if (fd < 0)
{
*error_p = GSL_ERROR_OPEN_FAILED;
g_free (cwd);
g_free (file_name);
return NULL;
}
scanner = g_scanner_new (NULL);
scanner->config->symbol_2_token = TRUE;
g_scanner_scope_add_symbol (scanner, 0, "wave", GUINT_TO_POINTER (GSL_WAVE_TOKEN_WAVE));
g_scanner_scope_add_symbol (scanner, 0, "name", GUINT_TO_POINTER (GSL_WAVE_TOKEN_NAME));
g_scanner_input_file (scanner, fd);
while (!abort)
{
g_scanner_get_next_token (scanner);
switch (scanner->token)
{
case GSL_WAVE_TOKEN_WAVE:
if (g_scanner_peek_next_token (scanner) == '{')
{
g_scanner_get_next_token (scanner); /* eat '{' */
in_wave = TRUE;
}
break;
case '{':
if (gslwave_skip_rest_statement (scanner, 1) != G_TOKEN_NONE)
abort = TRUE;
break;
case GSL_WAVE_TOKEN_NAME:
if (in_wave && g_scanner_peek_next_token (scanner) == '=')
{
g_scanner_get_next_token (scanner); /* eat '=' */
if (g_scanner_peek_next_token (scanner) == G_TOKEN_STRING)
{
gchar *wave_name;
g_scanner_get_next_token (scanner); /* eat string */
wave_name = g_strdup (scanner->value.v_string);
if (gslwave_skip_rest_statement (scanner, 1) == G_TOKEN_NONE)
{
in_wave = FALSE;
wave_names = gsl_ring_append (wave_names, wave_name);
}
else
{
g_free (wave_name);
abort = TRUE;
}
}
}
break;
default:
if (scanner->token == G_TOKEN_EOF || scanner->token == G_TOKEN_ERROR)
abort = TRUE;
break;
}
}
g_scanner_destroy (scanner);
close (fd);
if (wave_names)
{
GslRing *ring;
fi = gsl_new_struct0 (FileInfo, 1);
fi->wfi.n_waves = gsl_ring_length (wave_names);
fi->wfi.waves = g_malloc0 (sizeof (fi->wfi.waves[0]) * fi->wfi.n_waves);
for (i = 0, ring = wave_names; i < fi->wfi.n_waves; i++, ring = ring->next)
fi->wfi.waves[i].name = ring->data;
gsl_ring_free (wave_names);
fi->cwd = cwd;
}
else
g_free (cwd);
g_free (file_name);
/* FIXME: empty wave error? */
return fi ? &fi->wfi : NULL;
}
void parse_config (GromitData *data)
{
GromitPaintContext *context=NULL;
GromitPaintContext *context_template=NULL;
GScanner *scanner;
GTokenType token;
gchar *filename;
int file;
gchar *name, *copy;
GromitPaintType type;
GdkRGBA *fg_color=NULL;
guint width, arrowsize, minwidth;
filename = g_strjoin (G_DIR_SEPARATOR_S,
g_get_user_config_dir(), "gromit-mpx.cfg", NULL);
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
/* try global config file */
g_free (filename);
filename = g_strdup ("/etc/gromit-mpx/gromit-mpx.cfg");
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
g_free (filename);
return;
}
}
scanner = g_scanner_new (NULL);
scanner->input_name = filename;
scanner->config->case_sensitive = 0;
scanner->config->scan_octal = 0;
scanner->config->identifier_2_string = 0;
scanner->config->char_2_token = 1;
scanner->config->numbers_2_int = 1;
scanner->config->int_2_float = 1;
g_scanner_scope_add_symbol (scanner, 0, "PEN", (gpointer) GROMIT_PEN);
g_scanner_scope_add_symbol (scanner, 0, "ERASER", (gpointer) GROMIT_ERASER);
g_scanner_scope_add_symbol (scanner, 0, "RECOLOR",(gpointer) GROMIT_RECOLOR);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON1", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON2", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON3", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON4", (gpointer) 4);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON5", (gpointer) 5);
g_scanner_scope_add_symbol (scanner, 1, "SHIFT", (gpointer) 11);
g_scanner_scope_add_symbol (scanner, 1, "CONTROL", (gpointer) 12);
g_scanner_scope_add_symbol (scanner, 1, "META", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 1, "ALT", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 2, "size", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 2, "color", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 2, "arrowsize", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 2, "minsize", (gpointer) 4);
g_scanner_set_scope (scanner, 0);
scanner->config->scope_0_fallback = 0;
g_scanner_input_file (scanner, file);
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_EOF)
{
/*
* New tool definition
*/
if (token == G_TOKEN_STRING)
{
name = parse_name (scanner);
token = g_scanner_cur_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN, NULL,
NULL, NULL, "aborting", TRUE);
exit (1);
}
token = g_scanner_get_next_token (scanner);
/* defaults */
type = GROMIT_PEN;
width = 7;
arrowsize = 0;
minwidth = 1;
fg_color = data->red;
if (token == G_TOKEN_SYMBOL)
{
type = (GromitPaintType) scanner->value.v_symbol;
token = g_scanner_get_next_token (scanner);
}
else if (token == G_TOKEN_STRING)
{
copy = parse_name (scanner);
token = g_scanner_cur_token(scanner);
context_template = g_hash_table_lookup (data->tool_config, copy);
if (context_template)
{
type = context_template->type;
width = context_template->width;
arrowsize = context_template->arrowsize;
minwidth = context_template->minwidth;
fg_color = context_template->paint_color;
}
else
{
g_printerr ("WARNING: Unable to copy \"%s\": "
"not yet defined!\n", copy);
}
}
else
{
g_printerr ("Expected Tool-definition "
"or name of template tool\n");
exit (1);
}
/* Are there any tool-options?
*/
if (token == G_TOKEN_LEFT_PAREN)
{
GdkRGBA *color = NULL;
g_scanner_set_scope (scanner, 2);
scanner->config->int_2_float = 1;
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_RIGHT_PAREN)
{
if (token == G_TOKEN_SYMBOL)
{
if ((intptr_t) scanner->value.v_symbol == 1)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Size (float)... aborting\n");
exit (1);
}
width = (guint) (scanner->value.v_float + 0.5);
}
else if ((intptr_t) scanner->value.v_symbol == 2)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
{
g_printerr ("Missing Color (string)... "
"aborting\n");
exit (1);
}
color = g_malloc (sizeof (GdkRGBA));
if (gdk_rgba_parse (color, scanner->value.v_string))
{
fg_color = color;
}
else
{
g_printerr ("Unable to parse color. "
"Keeping default.\n");
g_free (color);
}
color = NULL;
}
else if ((intptr_t) scanner->value.v_symbol == 3)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Arrowsize (float)... "
"aborting\n");
exit (1);
}
arrowsize = scanner->value.v_float;
}
else if ((intptr_t) scanner->value.v_symbol == 4)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Minsize (float)... "
"aborting\n");
exit (1);
}
minwidth = scanner->value.v_float;
}
else
{
g_printerr ("Unknown tool type?????\n");
}
}
else
{
g_printerr ("skipped token!!!\n");
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_set_scope (scanner, 0);
token = g_scanner_get_next_token (scanner);
}
/*
* Finally we expect a semicolon
*/
if (token != ';')
{
g_printerr ("Expected \";\"\n");
exit (1);
}
context = paint_context_new (data, type, fg_color, width, arrowsize, minwidth);
g_hash_table_insert (data->tool_config, name, context);
}
else
{
g_printerr ("Expected name of Tool to define\n");
exit(1);
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_destroy (scanner);
close (file);
g_free (filename);
}
/* read a star file frame (one s-expression) from the given file pointer,
and return the stf of the root node */
struct stf *stf_read_frame(FILE *fp)
{
GScanner *scan;
GTokenType tok;
int level = 0;
int minus = 0;
GList *sl;
struct stf *ret = NULL;
struct stf *lstf[STF_MAX_DEPTH];
struct stf *stf=NULL, *nstf = NULL;
lstf[0] = NULL;
scan = init_scanner();
g_scanner_input_file(scan, fileno(fp));
do {
tok = g_scanner_get_next_token(scan);
// d3_printf("level %d ", level);
// print_token(scan, tok);
if (level == 0 && tok != '(')
continue;
if (level == 1 && tok == ')') {
ret = lstf[0];
break;
}
if (minus)
minus --;
switch(tok) {
case '(':
if (level >= STF_MAX_DEPTH - 1)
break;
nstf = stf_new();
lstf[level] = nstf;
if (level > 0) {
stf->next = nstf;
STF_SET_LIST(nstf, stf_new());
stf = STF_LIST(nstf);
} else {
stf = nstf;
}
level ++;
break;
case ')':
stf = lstf[level-1];
level --;
break;
case G_TOKEN_SYMBOL:
if (!STF_IS_NIL(stf)) {
nstf = stf_new();
stf->next = nstf;
stf = nstf;
}
STF_SET_SYMBOL(stf, intval(scan));
if (intval(scan) == SYM_STARS) {
sl = read_star_list(scan);
if (sl == NULL)
break;
nstf = stf_new();
stf->next = nstf;
stf = nstf;
STF_SET_GLIST(stf, sl);
}
break;
case '-':
minus = 2;
break;
case G_TOKEN_FLOAT:
if (!STF_IS_NIL(stf)) {
nstf = stf_new();
stf->next = nstf;
stf = nstf;
}
STF_SET_DOUBLE(stf, minus?-floatval(scan):floatval(scan));
break;
case G_TOKEN_STRING:
if (!STF_IS_NIL(stf)) {
nstf = stf_new();
stf->next = nstf;
stf = nstf;
}
STF_SET_STRING(stf, strdup(stringval(scan)));
break;
case G_TOKEN_IDENTIFIER:
err_printf("unexpected identifier: %s\n", stringval(scan));
// if (!STF_IS_NIL(stf)) {
// nstf = stf_new();
// stf->next = nstf;
// stf = nstf;
// }
// STF_SET_IDENT(stf, strdup(stringval(scan)));
// break;
default:
err_printf("unexected token %d\n", tok);
break;
}
} while (tok != G_TOKEN_EOF);
g_scanner_sync_file_offset(scan);
g_scanner_destroy(scan);
return ret;
}
static GslWaveDsc*
gslwave_load_wave_dsc (gpointer data,
GslWaveFileInfo *file_info,
guint nth_wave,
GslErrorType *error_p)
{
GScanner *scanner;
WaveDsc *dsc;
guint token, i;
gint fd;
fd = open (file_info->file_name, O_RDONLY);
if (fd < 0)
{
*error_p = GSL_ERROR_OPEN_FAILED;
return NULL;
}
scanner = g_scanner_new (NULL);
scanner->config->symbol_2_token = TRUE;
scanner->input_name = file_info->file_name;
g_scanner_input_file (scanner, fd);
for (i = GSL_WAVE_TOKEN_WAVE; i < GSL_WAVE_TOKEN_LAST_FIELD; i++)
g_scanner_scope_add_symbol (scanner, 0, gsl_wave_token (i), GUINT_TO_POINTER (i));
for (i = GSL_WAVE_TOKEN_BIG_ENDIAN; i < GSL_WAVE_TOKEN_LAST_DATA; i++)
g_scanner_scope_add_symbol (scanner, 0, gsl_wave_token (i), GUINT_TO_POINTER (i));
continue_scanning:
dsc = gsl_new_struct0 (WaveDsc, 1);
dsc->wdsc.name = NULL;
dsc->wdsc.n_chunks = 0;
dsc->wdsc.chunks = NULL;
dsc->wdsc.n_channels = 1;
dsc->format = GSL_WAVE_FORMAT_SIGNED_16;
dsc->byte_order = G_LITTLE_ENDIAN;
dsc->dfl_mix_freq = 44100;
if (g_scanner_get_next_token (scanner) != GSL_WAVE_TOKEN_WAVE)
token = GSL_WAVE_TOKEN_WAVE;
else
token = gslwave_parse_wave_dsc (scanner, dsc, file_info->waves[nth_wave].name);
if (token != G_TOKEN_NONE || scanner->parse_errors)
{
gslwave_wave_dsc_free (dsc);
dsc = NULL;
if (!scanner->parse_errors)
g_scanner_unexp_token (scanner, token, "identifier", "keyword", NULL, "discarding wave", TRUE); /* FIXME */
}
else
{
if (dsc->wdsc.n_chunks && dsc->wdsc.name)
{
/* found the correctly named wave and parsed it */
}
else
{
/* got invalid/wrong wave */
gslwave_wave_dsc_free (dsc);
dsc = NULL;
goto continue_scanning; /* next attempt */
}
}
g_scanner_destroy (scanner);
close (fd);
return dsc ? &dsc->wdsc : NULL;
}
int
main (int argc,
char *argv[])
{
const gchar *gobject_marshallers[] = {
#include "gmarshal.strings"
};
GScanner *scanner;
GSList *slist, *files = NULL;
gint i;
/* parse args and do fast exits */
parse_args (&argc, &argv);
/* list input files */
for (i = 1; i < argc; i++)
files = g_slist_prepend (files, argv[i]);
if (files)
files = g_slist_reverse (files);
else
files = g_slist_prepend (files, "/dev/stdin");
/* setup auxiliary structs */
scanner = g_scanner_new (&scanner_config_template);
fout = stdout;
marshallers = g_hash_table_new (g_str_hash, g_str_equal);
/* add standard marshallers of the GObject library */
if (std_includes)
for (i = 0; i < G_N_ELEMENTS (gobject_marshallers); i++)
{
gchar *tmp = g_strdup (gobject_marshallers[i]);
g_hash_table_insert (marshallers, tmp, tmp);
}
/* put out initial heading */
g_fprintf (fout, "\n");
if (gen_cheader && std_includes)
{
g_fprintf (fout, "#ifndef __%s_MARSHAL_H__\n", marshaller_prefix);
g_fprintf (fout, "#define __%s_MARSHAL_H__\n\n", marshaller_prefix);
}
if ((gen_cheader || gen_cbody) && std_includes)
g_fprintf (fout, "#include\t<glib-object.h>\n\n");
if (gen_cheader)
g_fprintf (fout, "G_BEGIN_DECLS\n");
/* generate necessary preprocessor directives */
if (gen_cbody)
put_marshal_value_getters ();
/* process input files */
for (slist = files; slist; slist = slist->next)
{
gchar *file = slist->data;
gint fd;
if (strcmp (file, "/dev/stdin") == 0)
/* Mostly for Win32. This is equivalent to opening /dev/stdin */
fd = dup (0);
else
fd = g_open (file, O_RDONLY, 0);
if (fd < 0)
{
g_warning ("failed to open \"%s\": %s", file, g_strerror (errno));
exit_status |= 1;
continue;
}
/* set file name for error reports */
scanner->input_name = file;
/* parse & process file */
g_scanner_input_file (scanner, fd);
/* scanning loop, we parse the input until its end is reached,
* or our sub routine came across invalid syntax
*/
do
{
guint expected_token = G_TOKEN_NONE;
switch ((guint) g_scanner_peek_next_token (scanner))
{
case '\n':
/* eat newline and restart */
g_scanner_get_next_token (scanner);
continue;
case G_TOKEN_EOF:
/* done */
break;
default:
/* parse and process signatures */
{
Signature signature = { NULL, NULL, NULL };
GList *node;
expected_token = parse_line (scanner, &signature);
/* once we got a valid signature, process it */
if (expected_token == G_TOKEN_NONE)
process_signature (&signature);
/* clean up signature contents */
g_free (signature.ploc);
if (signature.rarg)
g_free (signature.rarg->keyword);
g_free (signature.rarg);
for (node = signature.args; node; node = node->next)
{
InArgument *iarg = node->data;
g_free (iarg->keyword);
g_free (iarg);
}
g_list_free (signature.args);
}
break;
}
/* bail out on errors */
if (expected_token != G_TOKEN_NONE)
{
g_scanner_unexp_token (scanner, expected_token, "type name", NULL, NULL, NULL, TRUE);
exit_status |= 1;
break;
}
g_scanner_peek_next_token (scanner);
}
while (scanner->next_token != G_TOKEN_EOF);
close (fd);
}
/* put out trailer */
if (gen_cheader)
{
g_fprintf (fout, "\nG_END_DECLS\n");
if (std_includes)
g_fprintf (fout, "\n#endif /* __%s_MARSHAL_H__ */\n", marshaller_prefix);
}
g_fprintf (fout, "\n");
/* clean up */
g_slist_free (files);
g_scanner_destroy (scanner);
g_hash_table_foreach_remove (marshallers, string_key_destroy, NULL);
g_hash_table_destroy (marshallers);
return exit_status;
}
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;
}
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);
}
/*----------------------- read conf (.config/guvcview/videoX) file -----------------------*/
int
readConf(struct GLOBAL *global)
{
int ret=0;
//int signal=1; /*1=>+ or -1=>-*/
GScanner *scanner;
GTokenType ttype;
GScannerConfig config =
{
" \t\r\n", /* characters to skip */
G_CSET_a_2_z "_" G_CSET_A_2_Z, /* identifier start */
G_CSET_a_2_z "_." G_CSET_A_2_Z G_CSET_DIGITS,/* identifier cont. */
"#\n", /* single line comment */
FALSE, /* case_sensitive */
TRUE, /* skip multi-line comments */
TRUE, /* skip single line comments */
FALSE, /* scan multi-line comments */
TRUE, /* scan identifiers */
TRUE, /* scan 1-char identifiers */
FALSE, /* scan NULL identifiers */
FALSE, /* scan symbols */
FALSE, /* scan binary */
FALSE, /* scan octal */
TRUE, /* scan float */
TRUE, /* scan hex */
FALSE, /* scan hex dollar */
TRUE, /* scan single quote strings */
TRUE, /* scan double quote strings */
TRUE, /* numbers to int */
FALSE, /* int to float */
TRUE, /* identifier to string */
TRUE, /* char to token */
FALSE, /* symbol to token */
FALSE, /* scope 0 fallback */
TRUE /* store int64 */
};
int fd = g_open (global->confPath, O_RDONLY, 0);
if (fd < 0 )
{
printf("Could not open %s for read,\n will try to create it\n",global->confPath);
ret=writeConf(global, global->videodevice);
}
else
{
scanner = g_scanner_new (&config);
g_scanner_input_file (scanner, fd);
scanner->input_name = global->confPath;
//temp codec values
int ac_bit_rate =-1, vc_bit_rate=-1, vc_fps=-1, vc_qmax=-1, vc_qmin=-1, vc_max_qdiff=-1, vc_dia=-1;
int vc_pre_dia=-1, vc_pre_me=-1, vc_me_pre_cmp=-1, vc_me_cmp=-1, vc_me_sub_cmp=-1, vc_last_pred=-1;
int vc_gop_size=-1, vc_subq=-1, vc_framerefs=-1, vc_mb_decision=-1, vc_trellis=-1, vc_me_method=-1;
int vc_mpeg_quant=-1, vc_max_b_frames=-1, vc_num_threads=-1, vc_flags=-1, vc_monotonic_pts=-1;
float vc_qcompress=-1, vc_qblur=-1;
int VMAJOR =-1, VMINOR=-1, VMICRO=-1;
for (ttype = g_scanner_get_next_token (scanner);
ttype != G_TOKEN_EOF;
ttype = g_scanner_get_next_token (scanner))
{
if (ttype == G_TOKEN_STRING)
{
//printf("reading %s...\n",scanner->value.v_string);
char *name = g_strdup (scanner->value.v_string);
ttype = g_scanner_get_next_token (scanner);
if (ttype != G_TOKEN_EQUAL_SIGN)
{
g_scanner_unexp_token (scanner,
G_TOKEN_EQUAL_SIGN,
NULL,
NULL,
NULL,
NULL,
FALSE);
}
else
{
ttype = g_scanner_get_next_token (scanner);
/*check for signed integers*/
if(ttype == '-')
{
//signal = -1;
ttype = g_scanner_get_next_token (scanner);
}
if (ttype == G_TOKEN_STRING)
{
if (g_strcmp0(name,"version")==0)
{
sscanf(scanner->value.v_string,"%i.%i.%i",
&(VMAJOR),
&(VMINOR),
&(VMICRO));
}
else if (g_strcmp0(name,"resolution")==0)
{
if(global->flg_res < 1) /*must check for defaults since ReadOpts runs before ReadConf*/
sscanf(scanner->value.v_string,"%ix%i",
&(global->width),
&(global->height));
}
else if (g_strcmp0(name,"windowsize")==0)
{
sscanf(scanner->value.v_string,"%ix%i",
&(global->winwidth), &(global->winheight));
}
else if (g_strcmp0(name,"mode")==0)
{
if(global->flg_mode < 1)
{
/*use fourcc but keep it compatible with luvcview*/
if(g_strcmp0(scanner->value.v_string,"yuv") == 0)
g_snprintf(global->mode,5,"yuyv");
else
g_snprintf(global->mode,5,"%s",scanner->value.v_string);
}
}
else if (g_strcmp0(name,"fps")==0)
{
sscanf(scanner->value.v_string,"%i/%i",
&(global->fps_num), &(global->fps));
}
else if (g_strcmp0(name,"image_path")==0)
{
if(global->flg_imgFPath < 1)
{
global->imgFPath = splitPath(scanner->value.v_string,global->imgFPath);
/*get the file type*/
global->imgFormat = check_image_type(global->imgFPath[0]);
}
else
{
/* check if new file != old file */
gchar * newPath = g_strjoin ("/", global->imgFPath[1], global->imgFPath[0], NULL);
//printf("image path: %s\n old path: %s\n", newPath, scanner->value.v_string);
if(g_strcmp0(scanner->value.v_string, newPath) !=0)
{
/* reset counter */
//printf("reset counter from: %i\n", global->image_inc);
if(global->image_inc > 0)
{
global->image_inc = 1;
//g_snprintf(global->imageinc_str,20,_("File num:%d"),global->image_inc);
}
}
g_free(newPath);
}
}
else if ((g_strcmp0(name,"video_path")==0) || (g_strcmp0(name,"avi_path")==0))
{
if(global->vidfile == NULL)
{
global->vidFPath=splitPath(scanner->value.v_string,global->vidFPath);
}
}
else if (g_strcmp0(name,"profile_path")==0)
{
if(global->lprofile < 1)
global->profile_FPath=splitPath(scanner->value.v_string,
global->profile_FPath);
}
else
{
printf("unexpected string value (%s) for %s\n",
scanner->value.v_string, name);
}
}
else if (ttype==G_TOKEN_INT)
{
if (g_strcmp0(name,"stack_size")==0)
{
global->stack_size = scanner->value.v_int;
}
else if (g_strcmp0(name,"vid_sleep")==0)
{
global->vid_sleep = scanner->value.v_int;
}
else if (g_strcmp0(name,"cap_meth")==0)
{
if(!(global->flg_cap_meth))
global->cap_meth = scanner->value.v_int;
}
else if (g_strcmp0(name,"spinbehave")==0)
{
global->spinbehave = scanner->value.v_int;
}
else if (g_strcmp0(name,"default_action")==0)
{
global->default_action = scanner->value.v_int;
}
else if (g_strcmp0(name,"fps")==0)
{
/*parse non-quoted fps values*/
int line = g_scanner_cur_line(scanner);
global->fps_num = scanner->value.v_int;
ttype = g_scanner_peek_next_token (scanner);
if(ttype=='/')
{
/*get '/'*/
ttype = g_scanner_get_next_token (scanner);
ttype = g_scanner_peek_next_token (scanner);
if(ttype==G_TOKEN_INT)
{
ttype = g_scanner_get_next_token (scanner);
global->fps = scanner->value.v_int;
}
else if (scanner->next_line>line)
{
/*start new loop*/
break;
}
else
{
ttype = g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner,
G_TOKEN_NONE,
NULL,
NULL,
NULL,
"bad value for fps",
FALSE);
}
}
}
else if (strcmp(name,"fps_display")==0)
{
if(global->flg_FpsCount < 1)
global->FpsCount = (short) scanner->value.v_int;
}
else if (g_strcmp0(name,"auto_focus")==0)
{
global->autofocus = scanner->value.v_int;
}
else if (g_strcmp0(name,"bpp")==0)
{
global->bpp = scanner->value.v_int;
}
else if (g_strcmp0(name,"hwaccel")==0)
{
if(global->flg_hwaccel < 1)
global->hwaccel = scanner->value.v_int;
}
else if (g_strcmp0(name,"vid_codec")==0 || (g_strcmp0(name,"avi_format")==0))
{
global->VidCodec = scanner->value.v_int;
}
else if (g_strcmp0(name,"vid_format")==0)
{
global->VidFormat = scanner->value.v_int;
}
else if ((g_strcmp0(name,"vid_inc")==0) || (g_strcmp0(name,"avi_inc")==0))
{
global->vid_inc = (DWORD) scanner->value.v_int;
}
else if (g_strcmp0(name,"sound")==0)
{
global->Sound_enable = (short) scanner->value.v_int;
}
else if (g_strcmp0(name,"snd_api")==0)
{
global->Sound_API = scanner->value.v_int;
}
else if (g_strcmp0(name,"snd_device")==0)
{
global->Sound_UseDev = scanner->value.v_int;
}
else if (g_strcmp0(name,"snd_samprate")==0)
{
global->Sound_SampRateInd = scanner->value.v_int;
}
else if (g_strcmp0(name,"snd_numchan")==0)
{
global->Sound_NumChanInd = scanner->value.v_int;
}
else if (g_strcmp0(name,"snd_delay")==0)
{
global->Sound_delay = scanner->value.v_int64;
}
else if (g_strcmp0(name,"aud_codec")==0)
{
global->AudCodec = scanner->value.v_int;
global->Sound_Format = get_aud4cc(global->AudCodec);
}
else if (g_strcmp0(name,"frame_flags")==0)
{
global->Frame_Flags = scanner->value.v_int;
}
else if (g_strcmp0(name,"osd_flags")==0)
{
global->osdFlags = scanner->value.v_int;
}
else if (g_strcmp0(name,"image_inc")==0)
{
global->image_inc = (DWORD) scanner->value.v_int;
}
else if (g_strcmp0(name,"acodec_bit_rate")==0)
{
ac_bit_rate = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_bit_rate")==0)
{
vc_bit_rate = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_fps")==0)
{
vc_fps = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_monotonic_pts")==0)
{
vc_monotonic_pts = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_qmax")==0)
{
vc_qmax = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_qmin")==0)
{
vc_qmin = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_max_qdiff")==0)
{
vc_max_qdiff = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_dia")==0)
{
vc_dia = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_pre_dia")==0)
{
vc_pre_dia = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_pre_me")==0)
{
vc_pre_me= scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_me_pre_cmp")==0)
{
vc_me_pre_cmp = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_me_cmp")==0)
{
vc_me_cmp = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_me_sub_cmp")==0)
{
vc_me_sub_cmp = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_last_pred")==0)
{
vc_last_pred = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_gop_size")==0)
{
vc_gop_size = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_subq")==0)
{
vc_subq = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_framerefs")==0)
{
vc_framerefs = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_mb_decision")==0)
{
vc_mb_decision = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_trellis")==0)
{
vc_trellis = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_me_method")==0)
{
vc_me_method = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_mpeg_quant")==0)
{
vc_mpeg_quant = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_max_b_frames")==0)
{
vc_max_b_frames = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_flags")==0)
{
vc_flags = scanner->value.v_int;
}
else if (g_strcmp0(name,"vcodec_num_threads")==0)
{
vc_num_threads = scanner->value.v_int;
}
else
{
printf("unexpected integer value (%lu) for %s\n",
scanner->value.v_int, name);
printf("Strings must be quoted\n");
}
}
else if (ttype==G_TOKEN_FLOAT)
{
if (g_strcmp0(name,"vcodec_qcompress")==0)
{
vc_qcompress = scanner->value.v_float;
}
else if (g_strcmp0(name,"vcodec_qblur")==0)
{
vc_qblur = scanner->value.v_float;
}
else
printf("unexpected float value (%f) for %s\n", scanner->value.v_float, name);
}
else if (ttype==G_TOKEN_CHAR)
{
printf("unexpected char value (%c) for %s\n", scanner->value.v_char, name);
}
else
{
g_scanner_unexp_token (scanner,
G_TOKEN_NONE,
NULL,
NULL,
NULL,
"string values must be quoted - skiping",
FALSE);
int line = g_scanner_cur_line (scanner);
int stp=0;
do
{
ttype = g_scanner_peek_next_token (scanner);
if(scanner->next_line > line)
{
//printf("next line reached\n");
stp=1;
break;
}
else
{
ttype = g_scanner_get_next_token (scanner);
}
}
while (!stp);
}
}
g_free(name);
}
}
g_scanner_destroy (scanner);
close (fd);
//get pointers to codec properties
vcodecs_data *vcodec_defaults = get_codec_defaults(global->VidCodec);
acodecs_data *acodec_defaults = get_aud_codec_defaults(get_ind_by4cc(global->Sound_Format));
if (ac_bit_rate >= 0) acodec_defaults->bit_rate = ac_bit_rate;
if (vc_bit_rate >= 0) vcodec_defaults->bit_rate = vc_bit_rate;
if (vc_fps >= 0) vcodec_defaults->fps = vc_fps;
//from 1.5.3 onwards we set version on conf file and monotonic is set by default for all codecs
if ((vc_monotonic_pts >= 0) && (VMAJOR > 0)) vcodec_defaults->monotonic_pts = vc_monotonic_pts;
if (vc_qmax >= 0) vcodec_defaults->qmax = vc_qmax;
if (vc_qmin >= 0) vcodec_defaults->qmin = vc_qmin;
if (vc_max_qdiff >=0) vcodec_defaults->max_qdiff = vc_max_qdiff;
if (vc_dia >=0) vcodec_defaults->dia = vc_dia;
if (vc_pre_dia >=0) vcodec_defaults->pre_dia = vc_pre_dia;
if (vc_pre_me >=0) vcodec_defaults->pre_me = vc_pre_me;
if (vc_me_pre_cmp >=0) vcodec_defaults->me_pre_cmp = vc_me_pre_cmp;
if (vc_me_cmp >=0) vcodec_defaults->me_cmp = vc_me_cmp;
if (vc_me_sub_cmp >=0) vcodec_defaults->me_sub_cmp = vc_me_sub_cmp;
if (vc_last_pred >= 0) vcodec_defaults->last_pred = vc_last_pred;
if (vc_gop_size >= 0) vcodec_defaults->gop_size = vc_gop_size;
if (vc_subq >=0) vcodec_defaults->subq = vc_subq;
if (vc_framerefs >=0) vcodec_defaults->framerefs = vc_framerefs;
if (vc_mb_decision >=0) vcodec_defaults->mb_decision = vc_mb_decision;
if (vc_trellis >=0) vcodec_defaults->trellis = vc_trellis;
if (vc_me_method >=0) vcodec_defaults->me_method = vc_me_method;
if (vc_mpeg_quant >=0) vcodec_defaults->mpeg_quant = vc_mpeg_quant;
if (vc_max_b_frames >=0) vcodec_defaults->max_b_frames = vc_max_b_frames;
if (vc_num_threads >=0) vcodec_defaults->num_threads = vc_num_threads;
if (vc_flags >=0) vcodec_defaults->flags = vc_flags;
if (vc_qcompress >= 0) vcodec_defaults->qcompress = vc_qcompress;
if (vc_qblur >=0) vcodec_defaults->qblur = vc_qblur;
if(global->vid_inc>0)
{
uint64_t suffix = get_file_suffix(global->vidFPath[1], global->vidFPath[0]);
fprintf(stderr, "Video file suffix detected: %" PRIu64 "\n", suffix);
if(suffix >= G_MAXUINT64)
{
global->vidFPath[0] = add_file_suffix(global->vidFPath[0], suffix);
suffix = 0;
}
if(suffix > 0)
global->vid_inc = suffix + 1;
}
if(global->image_inc>0)
{
uint64_t suffix = get_file_suffix(global->imgFPath[1], global->imgFPath[0]);
fprintf(stderr, "Image file suffix detected: %" PRIu64 "\n", suffix);
if(suffix >= G_MAXUINT64)
{
global->imgFPath[0] = add_file_suffix(global->imgFPath[0], suffix);
suffix = 0;
}
if(suffix > 0)
global->image_inc = suffix + 1;
}
if (global->debug)
{
g_print("video_device: %s\n",global->videodevice);
g_print("vid_sleep: %i\n",global->vid_sleep);
g_print("cap_meth: %i\n",global->cap_meth);
g_print("resolution: %i x %i\n",global->width,global->height);
g_print("windowsize: %i x %i\n",global->winwidth,global->winheight);
g_print("spin behavior: %i\n",global->spinbehave);
g_print("default action: %i\n",global->default_action);
g_print("mode: %s\n",global->mode);
g_print("fps: %i/%i\n",global->fps_num,global->fps);
g_print("Display Fps: %i\n",global->FpsCount);
g_print("bpp: %i\n",global->bpp);
g_print("hwaccel: %i\n",global->hwaccel);
g_print("avi_format: %i\n",global->VidCodec);
g_print("sound: %i\n",global->Sound_enable);
g_print("sound Device: %i\n",global->Sound_UseDev);
g_print("sound samp rate: %i\n",global->Sound_SampRateInd);
g_print("sound Channels: %i\n",global->Sound_NumChanInd);
g_print("Sound delay: %llu nanosec\n",(unsigned long long) global->Sound_delay);
g_print("Sound Format: %i \n",global->Sound_Format);
g_print("Pan Step: %i degrees\n",global->PanStep);
g_print("Tilt Step: %i degrees\n",global->TiltStep);
g_print("Video Filter Flags: %i\n",global->Frame_Flags);
g_print("image inc: %" PRIu64 "\n",global->image_inc);
g_print("profile(default):%s/%s\n",global->profile_FPath[1],global->profile_FPath[0]);
}
}
return (ret);
}