#ifdef HAVE_CONFIG_H

#ifndef __SYMBIAN32__

#include "config.h"

#else

#include "config.h"

#endif

#endif

/* A Bison parser, made by GNU Bison 2.3.  */

/* Skeleton implementation for Bison's Yacc-like parsers in C

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006

   Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor,

   Boston, MA 02110-1301, USA.  */

/* As a special exception, you may create a larger work that contains

   part or all of the Bison parser skeleton and distribute that work

   under terms of your choice, so long as that work isn't itself a

   parser generator using the skeleton or a modified version thereof

   as a parser skeleton.  Alternatively, if you modify or redistribute

   the parser skeleton itself, you may (at your option) remove this

   special exception, which will cause the skeleton and the resulting

   Bison output files to be licensed under the GNU General Public

   License without this special exception.

   This special exception was added by the Free Software Foundation in

   version 2.2 of Bison.  */

/* C LALR(1) parser skeleton written by Richard Stallman, by

   simplifying the original so-called "semantic" parser.  */

/* All symbols defined below should begin with yy or YY, to avoid

   infringing on user name space.  This should be done even for local

   variables, as they might otherwise be expanded by user macros.

   There are some unavoidable exceptions within include files to

   define necessary library symbols; they are noted "INFRINGES ON

   USER NAME SPACE" below.  */

/* Identify Bison output.  */

#define YYBISON 1

/* Bison version.  */

#define YYBISON_VERSION "2.3"

/* Skeleton name.  */

#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */

#define YYPURE 1

/* Using locations.  */

#define YYLSP_NEEDED 0

/* Substitute the variable and function names.  */

#define yyparse _gst_parse_yyparse

#define yylex   _gst_parse_yylex

#define yyerror _gst_parse_yyerror

#define yylval  _gst_parse_yylval

#define yychar  _gst_parse_yychar

#define yydebug _gst_parse_yydebug

#define yynerrs _gst_parse_yynerrs

/* Tokens.  */

#ifndef YYTOKENTYPE

# define YYTOKENTYPE

   /* Put the tokens into the symbol table, so that GDB and other debuggers

      know about them.  */

enum yytokentype

{

  PARSE_URL = 258,

  IDENTIFIER = 259,

  BINREF = 260,

  PADREF = 261,

  REF = 262,

  ASSIGNMENT = 263,

  LINK = 264

};

#endif

/* Tokens.  */

#define PARSE_URL 258

#define IDENTIFIER 259

#define BINREF 260

#define PADREF 261

#define REF 262

#define ASSIGNMENT 263

#define LINK 264

/* Copy the first part of user declarations.  */

#line 1 "./grammar.y"

#include <glib-object.h>

#include <glib.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "../gst_private.h"

#include "../gst-i18n-lib.h"

#include "../gstconfig.h"

#include "../gstparse.h"

#include "../gstinfo.h"

#include "../gsterror.h"

#include "../gsturi.h"

#include "../gstutils.h"

#include "../gstvalue.h"

#include "../gstchildproxy.h"

#include "types.h"

/* All error messages in this file are user-visible and need to be translated.

 * Don't start the message with a capital, and don't end them with a period,

 * as they will be presented inside a sentence/error.

 */

#ifdef __SYMBIAN32__

#include <glib_global.h>

#endif

#define YYERROR_VERBOSE 1

#define YYLEX_PARAM scanner

typedef void *yyscan_t;

int _gst_parse_yylex (void *yylval_param, yyscan_t yyscanner);

int _gst_parse_yylex_init (yyscan_t scanner);

int _gst_parse_yylex_destroy (yyscan_t scanner);

struct yy_buffer_state *_gst_parse_yy_scan_string (char *, yyscan_t);

void _gst_parse_yypush_buffer_state (void *new_buffer, yyscan_t yyscanner);

void _gst_parse_yypop_buffer_state (yyscan_t yyscanner);

#ifdef __GST_PARSE_TRACE

static guint __strings;

static guint __links;

static guint __chains;

gchar *

__gst_parse_strdup (gchar * org)

{

  gchar *ret;

  __strings++;

  ret = g_strdup (org);

  /* g_print ("ALLOCATED STR   (%3u): %p %s\n", __strings, ret, ret); */

  return ret;

}

void

__gst_parse_strfree (gchar * str)

{

  if (str) {

    /* g_print ("FREEING STR     (%3u): %p %s\n", __strings - 1, str, str); */

    g_free (str);

    g_return_if_fail (__strings > 0);

    __strings--;

  }

}

link_t *

__gst_parse_link_new ()

{

  link_t *ret;

  __links++;

  ret = g_new0 (link_t, 1);

  /* g_print ("ALLOCATED LINK  (%3u): %p\n", __links, ret); */

  return ret;

}

void

__gst_parse_link_free (link_t * data)

{

  if (data) {

    /* g_print ("FREEING LINK    (%3u): %p\n", __links - 1, data); */

    g_free (data);

    g_return_if_fail (__links > 0);

    __links--;

  }

}

chain_t *

__gst_parse_chain_new ()

{

  chain_t *ret;

  __chains++;

  ret = g_new0 (chain_t, 1);

  /* g_print ("ALLOCATED CHAIN (%3u): %p\n", __chains, ret); */

  return ret;

}

void

__gst_parse_chain_free (chain_t * data)

{

  /* g_print ("FREEING CHAIN   (%3u): %p\n", __chains - 1, data); */

  g_free (data);

  g_return_if_fail (__chains > 0);

  __chains--;

}

#endif /* __GST_PARSE_TRACE */

typedef struct

{

  gchar *src_pad;

  gchar *sink_pad;

  GstElement *sink;

  GstCaps *caps;

  gulong signal_id;

  /* FIXME: need to connect to "disposed" signal to clean up,

   * but there is no such signal */

} DelayedLink;

typedef struct

{

  GstElement *parent;

  gchar *name;

  gchar *value_str;

  gulong signal_id;

} DelayedSet;

/*** define SET_ERROR and ERROR macros/functions */

#ifdef G_HAVE_ISO_VARARGS

#  define SET_ERROR(error, type, ...) \

G_STMT_START { \

  GST_CAT_ERROR (GST_CAT_PIPELINE, __VA_ARGS__); \

  if ((error) && !*(error)) { \

    g_set_error ((error), GST_PARSE_ERROR, (type), __VA_ARGS__); \

  } \

} G_STMT_END

#  define ERROR(type, ...) \

  SET_ERROR (((graph_t *) graph)->error, (type), __VA_ARGS__ )

#elif defined(G_HAVE_GNUC_VARARGS)

#  define SET_ERROR(error, type, args...) \

G_STMT_START { \

  GST_CAT_ERROR (GST_CAT_PIPELINE, args ); \

  if ((error) && !*(error)) { \

    g_set_error ((error), GST_PARSE_ERROR, (type), args ); \

  } \

} G_STMT_END

#  define ERROR(type, args...) \

  SET_ERROR (((graph_t *) graph)->error,(type) , args )

#else

static inline void

SET_ERROR (GError ** error, gint type, const char *format, ...)

{

  if (error) {

    if (*error) {

      g_warning ("error while parsing");

    } else {

      va_list varargs;

      char *string;

      va_start (varargs, format);

      string = g_strdup_vprintf (format, varargs);

      va_end (varargs);

      g_set_error (error, GST_PARSE_ERROR, type, string);

      g_free (string);

    }

  }

}

#endif /* G_HAVE_ISO_VARARGS */

/*** define YYPRINTF macro/function if we're debugging */

/* bison 1.35 calls this macro with side effects, we need to make sure the

   side effects work - crappy bison */

#ifndef GST_DISABLE_GST_DEBUG

#  define YYDEBUG 1

#  ifdef G_HAVE_ISO_VARARGS

/* #  define YYFPRINTF(a, ...) GST_CAT_DEBUG (GST_CAT_PIPELINE, __VA_ARGS__) */

#    define YYFPRINTF(a, ...) \

G_STMT_START { \

     gchar *temp = g_strdup_printf (__VA_ARGS__); \

     GST_CAT_LOG (GST_CAT_PIPELINE, temp); \

     g_free (temp); \

} G_STMT_END

#  elif defined(G_HAVE_GNUC_VARARGS)

#    define YYFPRINTF(a, args...) \

G_STMT_START { \

     gchar *temp = g_strdup_printf ( args ); \

     GST_CAT_LOG (GST_CAT_PIPELINE, temp); \

     g_free (temp); \

} G_STMT_END

#  else

static inline void

YYPRINTF (const char *format, ...)

{

  va_list varargs;

  gchar *temp;

  va_start (varargs, format);

  temp = g_strdup_vprintf (format, varargs);

  GST_CAT_LOG (GST_CAT_PIPELINE, "%s", temp);

  g_free (temp);

  va_end (varargs);

}

#  endif /* G_HAVE_ISO_VARARGS */

#endif /* GST_DISABLE_GST_DEBUG */

#define GST_BIN_MAKE(res, type, chainval, assign, free_string) \

G_STMT_START { \

  chain_t *chain = chainval; \

  GSList *walk; \

  GstBin *bin = (GstBin *) gst_element_factory_make (type, NULL); \

  if (!chain) { \

    SET_ERROR (((graph_t *) graph)->error, GST_PARSE_ERROR_EMPTY_BIN, \

        _("specified empty bin \"%s\", not allowed"), type); \

    g_slist_foreach (assign, (GFunc) gst_parse_strfree, NULL); \

    g_slist_free (assign); \

    gst_object_unref (bin); \

    if (free_string) \

      gst_parse_strfree (type); /* Need to clean up the string */ \

    YYERROR; \

  } else if (!bin) { \

    SET_ERROR (((graph_t *) graph)->error, GST_PARSE_ERROR_NO_SUCH_ELEMENT, \

        _("no bin \"%s\", skipping"), type); \

    g_slist_foreach (assign, (GFunc) gst_parse_strfree, NULL); \

    g_slist_free (assign); \

    res = chain; \

  } else { \

    for (walk = chain->elements; walk; walk = walk->next ) \

      gst_bin_add (bin, GST_ELEMENT (walk->data)); \

    g_slist_free (chain->elements); \

    chain->elements = g_slist_prepend (NULL, bin); \

    res = chain; \

    /* set the properties now */ \

    for (walk = assign; walk; walk = walk->next) \

      gst_parse_element_set ((gchar *) walk->data, GST_ELEMENT (bin), graph); \

    g_slist_free (assign); \

  } \

} G_STMT_END

#define MAKE_LINK(link, _src, _src_name, _src_pads, _sink, _sink_name, _sink_pads) \

G_STMT_START { \

  link = gst_parse_link_new (); \

  link->src = _src; \

  link->sink = _sink; \

  link->src_name = _src_name; \

  link->sink_name = _sink_name; \

  link->src_pads = _src_pads; \

  link->sink_pads = _sink_pads; \

  link->caps = NULL; \

} G_STMT_END

#define MAKE_REF(link, _src, _pads) \

G_STMT_START { \

  gchar *padname = _src; \

  GSList *pads = _pads; \

  if (padname) { \

    while (*padname != '.') padname++; \

    *padname = '\0'; \

    padname++; \

    if (*padname != '\0') \

      pads = g_slist_prepend (pads, gst_parse_strdup (padname)); \

  } \

  MAKE_LINK (link, NULL, _src, pads, NULL, NULL, NULL); \

} G_STMT_END

static void

gst_parse_new_child (GstChildProxy * child_proxy, GObject * object,

    gpointer data)

{

  DelayedSet *set = (DelayedSet *) data;

  GParamSpec *pspec;

  GValue v = { 0, };

  GstObject *target = NULL;

  GType value_type;

  if (gst_child_proxy_lookup (GST_OBJECT (set->parent), set->name, &target,

          &pspec)) {

    value_type = G_PARAM_SPEC_VALUE_TYPE (pspec);

    GST_CAT_LOG (GST_CAT_PIPELINE,

        "parsing delayed property %s as a %s from %s", pspec->name,

        g_type_name (value_type), set->value_str);

    g_value_init (&v, value_type);

    if (gst_value_deserialize (&v, set->value_str)) {

      g_object_set_property (G_OBJECT (target), pspec->name, &v);

    }

    g_signal_handler_disconnect (child_proxy, set->signal_id);

    g_free (set->name);

    g_free (set->value_str);

    g_free (set);

  }

  if (G_IS_VALUE (&v))

    g_value_unset (&v);

  if (target)

    gst_object_unref (target);

  return;

}

static void

gst_parse_element_set (gchar * value, GstElement * element, graph_t * graph)

{

  GParamSpec *pspec;

  gchar *pos = value;

  GValue v = { 0, };

  GstObject *target = NULL;

  GType value_type;

  /* parse the string, so the property name is null-terminated an pos points

     to the beginning of the value */

  while (!g_ascii_isspace (*pos) && (*pos != '='))

    pos++;

  if (*pos == '=') {

    *pos = '\0';

  } else {

    *pos = '\0';

    pos++;

    while (g_ascii_isspace (*pos))

      pos++;

  }

  pos++;

  while (g_ascii_isspace (*pos))

    pos++;

  if (*pos == '"') {

    pos++;

    pos[strlen (pos) - 1] = '\0';

  }

  gst_parse_unescape (pos);

  if (gst_child_proxy_lookup (GST_OBJECT (element), value, &target, &pspec)) {

    value_type = G_PARAM_SPEC_VALUE_TYPE (pspec);

    GST_CAT_LOG (GST_CAT_PIPELINE, "parsing property %s as a %s", pspec->name,

        g_type_name (value_type));

    g_value_init (&v, value_type);

    if (!gst_value_deserialize (&v, pos))

      goto error;

    g_object_set_property (G_OBJECT (target), pspec->name, &v);

  } else {

    /* do a delayed set */

    if (GST_IS_CHILD_PROXY (element)) {

      DelayedSet *data = g_new (DelayedSet, 1);

      data->parent = element;

      data->name = g_strdup (value);

      data->value_str = g_strdup (pos);

      data->signal_id =

          g_signal_connect (GST_OBJECT (element), "child-added",

          G_CALLBACK (gst_parse_new_child), data);

    } else {

      SET_ERROR (((graph_t *) graph)->error, GST_PARSE_ERROR_NO_SUCH_PROPERTY,

          _("no property \"%s\" in element \"%s\""), value,

          GST_ELEMENT_NAME (element));

    }

  }

out:

  gst_parse_strfree (value);

  if (G_IS_VALUE (&v))

    g_value_unset (&v);

  if (target)

    gst_object_unref (target);

  return;

error:

  SET_ERROR (((graph_t *) graph)->error, GST_PARSE_ERROR_COULD_NOT_SET_PROPERTY,

      _("could not set property \"%s\" in element \"%s\" to \"%s\""),

      value, GST_ELEMENT_NAME (element), pos);

  goto out;

}

static inline void

gst_parse_free_link (link_t * link)

{

  gst_parse_strfree (link->src_name);

  gst_parse_strfree (link->sink_name);

  g_slist_foreach (link->src_pads, (GFunc) gst_parse_strfree, NULL);

  g_slist_foreach (link->sink_pads, (GFunc) gst_parse_strfree, NULL);

  g_slist_free (link->src_pads);

  g_slist_free (link->sink_pads);

  if (link->caps)

    gst_caps_unref (link->caps);

  gst_parse_link_free (link);

}

static void

gst_parse_found_pad (GstElement * src, GstPad * pad, gpointer data)

{

  DelayedLink *link = (DelayedLink *) data;

  GST_CAT_INFO (GST_CAT_PIPELINE, "trying delayed linking %s:%s to %s:%s",

      GST_STR_NULL (GST_ELEMENT_NAME (src)), GST_STR_NULL (link->src_pad),

      GST_STR_NULL (GST_ELEMENT_NAME (link->sink)),

      GST_STR_NULL (link->sink_pad));

  if (gst_element_link_pads_filtered (src, link->src_pad, link->sink,

          link->sink_pad, link->caps)) {

    /* do this here, we don't want to get any problems later on when

     * unlocking states */

    GST_CAT_DEBUG (GST_CAT_PIPELINE, "delayed linking %s:%s to %s:%s worked",

        GST_STR_NULL (GST_ELEMENT_NAME (src)), GST_STR_NULL (link->src_pad),

        GST_STR_NULL (GST_ELEMENT_NAME (link->sink)),

        GST_STR_NULL (link->sink_pad));