cascadefileparser.cc

tracciatore di mani con webcam

{
       0,   209,   209,   210,   214,   219,   224,   231,   244,   261,
     286,   294,   295,   299,   300,   304,   307,   321,   340,   347,
     348,   352,   366,   390,   391,   395,   403,   415,   416,   420,
     422,   428,   434,   440,   447,   453,   459,   465,   471,   479,
     487,   493,   499,   510,   523,   529,   530
};
#endif

#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "CLASSIFIER_CASCADE", "TYPE_SEQUENTIAL",
  "TYPE_FAN", "TYPE_TREE", "RATIO", "FPR", "DR", "SUCCESSFUL", "EXHAUSTED",
  "STRONG", "CLASSIFIER", "CLASSIFIERS", "UPCASE_STRONG", "WEAK",
  "NULL_ID", "THRESHOLD", "LEFT_RIGHT", "UP_DOWN", "LEFT_CENTER_RIGHT",
  "SEVEN_COLUMNS", "DIAG", "LEFT_RIGHT_SAME", "UP_DOWN_SAME",
  "LEFT_CENTER_RIGHT_SAME", "SEVEN_COLUMNS_SAME", "SEVEN_COLUMNS_SIMILAR",
  "DIAG_SAME", "DIAG_SIMILAR", "FOUR_BOXES", "FOUR_BOXES_SAME",
  "DOUBLEQUOTE", "COMMA", "X_BY", "SLASH", "DOT", "COLON", "OPEN_PAREN",
  "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", "ASTERIX", "LT", "GTEQ",
  "MINUS", "BRANCH", "BRANCHES", "COMMON", "INT_NUMBER", "FP_NUMBER",
  "NAME", "$accept", "ROOT", "cascade", "cascade_header_p1",
  "cascade_header_p2_sequential", "cascade_header_p2_fan",
  "cascade_header_p2_tree", "trainset_exhausted", "branch_seq",
  "branch_header", "strong_classifier_package",
  "strong_classifier_package_header", "strong_classifier_seq",
  "strong_classifier", "strong_classifier_header",
  "weighted_weak_classifier_seq", "weighted_weak_classifier",
  "weak_classifier", "comparison_lt", "integral_feature", "quadruple",
  "fp_number", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const unsigned short yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
     305,   306,   307
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const unsigned char yyr1[] =
{
       0,    53,    54,    54,    55,    55,    55,    56,    57,    58,
      59,    60,    60,    61,    61,    62,    62,    63,    64,    65,
      65,    66,    67,    68,    68,    69,    70,    71,    71,    72,
      72,    72,    72,    72,    72,    72,    72,    72,    72,    72,
      72,    72,    72,    72,    73,    74,    74
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const unsigned char yyr2[] =
{
       0,     2,     1,     1,     3,     3,     2,     5,    19,    22,
       1,     1,     1,     2,     3,     2,    14,     2,     4,     2,
       1,     2,    20,     2,     1,     3,     8,     1,     1,     1,
      10,    10,    12,    20,    12,    10,    10,    12,    20,    20,
      12,    12,     8,     8,     9,     1,     1
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const unsigned char yydefact[] =
{
       0,     0,     0,     0,     2,     0,     3,     0,    29,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     1,     0,     0,    10,     0,     0,
       6,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     4,     0,     0,     0,     5,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    27,    28,     0,     0,     0,     0,     0,
      17,    20,     0,     0,    15,     0,    13,     7,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    46,    45,     0,     0,     0,     0,     0,
      19,    21,    24,     0,     0,    14,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,    18,     0,    23,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,    25,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,    26,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    42,    43,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,    30,    31,     0,     0,
       0,    35,    36,     0,     0,     0,     0,     0,    44,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,    32,     0,    34,    37,     0,
       0,    40,    41,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,    16,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    11,    12,     0,     0,     0,     0,     0,
       0,     8,     0,     0,    33,    38,    39,     0,     0,     0,
       0,     9,    22
};

/* YYDEFGOTO[NTERM-NUM]. */
static const short yydefgoto[] =
{
      -1,     3,     4,     5,    28,    29,    30,   295,    55,    56,
      51,    52,    80,    81,    82,   111,   112,     6,    75,    23,
      45,   113
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -208
static const short yypact[] =
{
      -1,   -28,   -13,    24,  -208,    16,  -208,   -19,  -208,   -16,
     -15,   -14,   -12,   -11,    -9,    -8,    -7,    -6,    -5,    -4,
      -3,    -2,    -2,     6,  -208,    15,    18,  -208,     3,   -24,
    -208,    21,    23,    25,    26,    27,    28,    29,    30,    31,
      32,    33,    34,    35,     5,    36,    37,   -18,     8,    22,
      61,  -208,    59,    38,    39,   -24,     3,    41,    40,    42,
      43,    44,    45,    46,    47,    48,    49,    50,    53,    54,
      51,    -2,    -2,  -208,  -208,   -22,    52,    56,    62,    64,
      59,  -208,   -22,    72,  -208,     3,  -208,  -208,    71,    55,
      75,    76,    73,    77,    79,    80,    81,    82,    84,    85,
      70,    87,    89,  -208,  -208,    86,    74,    78,    90,    83,
    -208,   -22,  -208,    88,    91,  -208,    92,    94,    95,    96,
      97,    98,    99,   100,   101,   104,   105,   106,   102,    -2,
      -2,   -22,   103,   107,  -208,    93,  -208,   116,   125,   126,
     124,   127,   128,   129,   131,   133,   135,   136,   137,   138,
     139,   113,   141,   142,   132,   119,   122,   130,  -208,   140,
     134,   143,   144,   145,   146,   147,   148,   151,   152,   153,
     154,   155,   149,    -2,    -2,  -208,   -22,   -22,   168,   169,
     156,   157,   150,   158,   173,   174,   175,   176,   177,   179,
     180,   181,   160,  -208,  -208,   178,   182,   -22,   184,   166,
     170,   185,   186,   187,   188,   189,   190,   191,   192,   193,
     194,   183,   210,   211,   195,   -22,  -208,  -208,   196,   197,
     198,  -208,  -208,   200,   212,   213,   214,   215,  -208,   207,
     216,    69,   217,   202,   203,   205,   206,   208,   209,   218,
     219,   -22,   -22,   222,   121,  -208,   223,  -208,  -208,   227,
     228,  -208,  -208,   229,   230,   -22,   232,   221,   224,   225,
     172,   241,   226,   -22,   231,   233,   238,   235,   239,   240,
     236,   234,   237,   242,   -22,   -22,   243,  -208,   245,   246,
     247,   248,   249,    63,   244,   250,   251,    20,    20,    66,
     252,   254,   255,  -208,  -208,   256,   257,   261,   253,   258,
     259,  -208,   260,    65,  -208,  -208,  -208,   263,   -22,   262,
     264,  -208,  -208
};

/* YYPGOTO[NTERM-NUM].  */
static const short yypgoto[] =
{
    -208,  -208,  -208,  -208,  -208,  -208,  -208,  -207,  -208,   123,
     -53,  -208,  -208,     2,  -208,  -208,   -27,   -23,  -208,  -208,
     -21,   -75
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -1
static const unsigned short yytable[] =
{
     105,    46,     1,    86,     8,     7,     9,    10,    11,    12,
      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
      25,    26,    27,    53,    24,    54,    73,    74,   103,   104,
     293,   294,   115,    31,    32,    33,    34,    44,    35,    36,
       2,    37,    38,    39,    40,    41,    42,    43,    47,    48,
     101,   102,    49,    50,    57,    70,   154,    58,    76,    59,
      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
      71,    72,    77,    78,    79,    87,   108,   109,   243,   289,
     297,   296,   110,   308,   136,   100,    84,   106,    83,   117,
      88,   107,    89,    90,    91,    92,    93,    94,    95,    96,
      97,   195,   196,    98,    99,   114,   116,   120,   152,   153,
     118,   119,   121,   122,   158,   123,   124,   125,   126,   127,
     128,   129,   214,   130,   132,   131,   176,   134,   133,   177,
     256,   137,   157,   135,     0,     0,   151,   155,   178,     0,
     232,   156,   139,   138,   140,   141,   142,   143,   144,   145,
     146,   147,   193,   194,   148,   149,   150,     2,   159,   161,
     160,   162,   163,   172,   164,   165,   253,   254,   166,   167,
     168,   169,   175,   170,   171,   173,   174,   198,    85,   179,
     262,   267,     0,   192,   180,     0,   201,     0,   270,     0,
     199,   200,   202,   181,   182,   183,   184,   185,   186,   281,
     282,   187,   188,   189,   190,   191,   197,   203,   204,   205,
     211,   207,   206,   208,   209,   210,   216,   212,   229,   230,
     217,   213,   215,   228,     0,     0,     0,     0,     0,   231,
     233,   234,   235,   310,   236,   218,   219,   220,   221,   222,
     223,   224,   225,   226,   227,   241,   237,   238,   239,   240,
     268,   244,   245,   246,   242,   247,   248,   257,   249,   250,
     255,   258,   259,   260,   261,   271,   269,   272,   251,   252,
     263,   264,   273,   274,   265,   266,   277,   275,   276,   284,
     285,   286,   287,   288,   278,     0,   298,   279,   299,   300,
       0,     0,   280,   283,   290,   303,   301,   302,     0,   311,
     291,   292,   312,   304,     0,     0,     0,     0,   305,   306,
     307,   309
};

static const short yycheck[] =
{
      75,    22,     3,    56,    17,    33,    19,    20,    21,    22,
      23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
       4,     5,     6,    47,     0,    49,    44,    45,    50,    51,
      10,    11,    85,    52,    50,    50,    50,    39,    50,    50,
      41,    50,    50,    50,    50,    50,    50,    50,    42,    34,
      71,    72,    34,    50,    33,    50,   131,    34,    50,    34,
      34,    34,    34,    34,    34,    34,    34,    34,    34,    34,
      34,    34,    50,    12,    15,    34,    14,    13,     9,    16,
      14,   288,    80,    18,   111,    34,    47,    35,    50,    34,
      50,    35,    50,    50,    50,    50,    50,    50,    50,    50,
      50,   176,   177,    50,    50,    33,    35,    34,   129,   130,
      35,    35,    35,    34,   137,    35,    35,    35,    34,    34,
      50,    34,   197,    34,    50,    39,     7,    37,    50,     7,
       9,    43,    39,    50,    -1,    -1,    34,    34,     8,    -1,
     215,    34,    50,    52,    50,    50,    50,    50,    50,    50,
      50,    50,   173,   174,    50,    50,    50,    41,    33,    35,
      34,    34,    34,    50,    35,    34,   241,   242,    35,    34,
      34,    34,    40,    35,    35,    34,    34,     8,    55,    39,
     255,     9,    -1,    34,    50,    -1,    36,    -1,   263,    -1,
      34,    34,    34,    50,    50,    50,    50,    50,    50,   274,
     275,    50,    50,    50,    50,    50,    38,    34,    34,    34,
      50,    34,    36,    34,    34,    34,    50,    39,     8,     8,
      50,    39,    38,    40,    -1,    -1,    -1,    -1,    -1,    34,
      34,    34,    34,   308,    34,    50,    50,    50,    50,    50,
      50,    50,    50,    50,    50,    38,    34,    34,    34,    34,
       9,    34,    50,    50,    38,    50,    50,    34,    50,    50,
      38,    34,    34,    34,    34,    34,    40,    34,    50,    50,
      38,    50,    34,    38,    50,    50,    40,    38,    38,    34,
      34,    34,    34,    34,    50,    -1,    34,    50,    34,    34,
      -1,    -1,    50,    50,    50,    34,    40,    40,    -1,    37,
      50,    50,    38,    50,    -1,    -1,    -1,    -1,    50,    50,
      50,    48
};

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
   symbol of state STATE-NUM.  */
static const unsigned char yystos[] =
{
       0,     3,    41,    54,    55,    56,    70,    33,    17,    19,
      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
      30,    31,    32,    72,     0,     4,     5,     6,    57,    58,
      59,    52,    50,    50,    50,    50,    50,    50,    50,    50,
      50,    50,    50,    50,    39,    73,    73,    42,    34,    34,
      50,    63,    64,    47,    49,    61,    62,    33,    34,    34,
      34,    34,    34,    34,    34,    34,    34,    34,    34,    34,
      50,    34,    34,    44,    45,    71,    50,    50,    12,    15,
      65,    66,    67,    50,    47,    62,    63,    34,    50,    50,
      50,    50,    50,    50,    50,    50,    50,    50,    50,    50,
      34,    73,    73,    50,    51,    74,    35,    35,    14,    13,
      66,    68,    69,    74,    33,    63,    35,    34,    35,    35,
      34,    35,    34,    35,    35,    35,    34,    34,    50,    34,
      34,    39,    50,    50,    37,    50,    69,    43,    52,    50,
      50,    50,    50,    50,    50,    50,    50,    50,    50,    50,
      50,    34,    73,    73,    74,    34,    34,    39,    70,    33,
      34,    35,    34,    34,    35,    34,    35,    34,    34,    34,
      35,    35,    50,    34,    34,    40,     7,     7,     8,    39,
      50,    50,    50,    50,    50,    50,    50,    50,    50,    50,
      50,    50,    34,    73,    73,    74,    74,    38,     8,    34,
      34,    36,    34,    34,    34,    34,    36,    34,    34,    34,
      34,    50,    39,    39,    74,    38,    50,    50,    50,    50,
      50,    50,    50,    50,    50,    50,    50,    50,    40,     8,
       8,    34,    74,    34,    34,    34,    34,    34,    34,    34,
      34,    38,    38,     9,    34,    50,    50,    50,    50,    50,
      50,    50,    50,    74,    74,    38,     9,    34,    34,    34,
      34,    34,    74,    38,    50,    50,    50,     9,     9,    40,
      74,    34,    34,    34,    38,    38,    38,    40,    50,    50,
      50,    74,    74,    50,    34,    34,    34,    34,    34,    16,
      50,    50,    50,    10,    11,    60,    60,    14,    34,    34,
      34,    40,    40,    34,    50,    50,    50,    50,    18,    48,
      74,    37,    38
};

#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif

#define yyerrok		(yyerrstatus = 0)
#define yyclearin	(yychar = YYEMPTY)
#define YYEMPTY		(-2)
#define YYEOF		0

#define YYACCEPT	goto yyacceptlab
#define YYABORT		goto yyabortlab
#define YYERROR		goto yyerrorlab


/* Like YYERROR except do call yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */

#define YYFAIL		goto yyerrlab

#define YYRECOVERING()  (!!yyerrstatus)

#define YYBACKUP(Token, Value)					\
do								\
  if (yychar == YYEMPTY && yylen == 1)				\
    {								\
      yychar = (Token);						\
      yylval = (Value);						\
      yytoken = YYTRANSLATE (yychar);				\
      YYPOPSTACK;						\
      goto yybackup;						\
    }								\
  else								\
    { 								\
      yyerror ("syntax error: cannot back up");\
      YYERROR;							\
    }								\
while (0)

#define YYTERROR	1
#define YYERRCODE	256

/* YYLLOC_DEFAULT -- Compute the default location (before the actions
   are run).  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)		\
   ((Current).first_line   = (Rhs)[1].first_line,	\
    (Current).first_column = (Rhs)[1].first_column,	\
    (Current).last_line    = (Rhs)[N].last_line,	\
    (Current).last_column  = (Rhs)[N].last_column)
#endif

/* YYLEX -- calling `yylex' with the right arguments.  */

#ifdef YYLEX_PARAM
# define YYLEX yylex (YYLEX_PARAM)
#else
# define YYLEX yylex ()
#endif

/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)			\
do {						\
  if (yydebug)					\
    YYFPRINTF Args;				\
} while (0)

# define YYDSYMPRINT(Args)			\
do {						\
  if (yydebug)					\
    yysymprint Args;				\
} while (0)

# define YYDSYMPRINTF(Title, Token, Value, Location)		\
do {								\
  if (yydebug)							\
    {								\
      YYFPRINTF (stderr, "%s ", Title);				\
      yysymprint (stderr, 					\
                  Token, Value);	\
      YYFPRINTF (stderr, "\n");					\
    }								\
} while (0)

/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yy_stack_print (short *bottom, short *top)
#else
static void
yy_stack_print (bottom, top)
    short *bottom;
    short *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (/* Nothing. */; bottom <= top; ++bottom)
    YYFPRINTF (stderr, " %d", *bottom);
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)				\
do {								\
  if (yydebug)							\
    yy_stack_print ((Bottom), (Top));				\
} while (0)


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

#if defined (__STDC__) || defined (__cplusplus)
static void
yy_reduce_print (int yyrule)
#else
static void
yy_reduce_print (yyrule)
    int yyrule;
#endif
{
  int yyi;
  unsigned int yylno = yyrline[yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
             yyrule - 1, yylno);
  /* Print the symbols being reduced, and their result.  */
  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (yydebug)				\
    yy_reduce_print (Rule);		\
} while (0)

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef	YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif



#if YYERROR_VERBOSE

# ifndef yystrlen
#  if defined (__GLIBC__) && defined (_STRING_H)
#   define yystrlen strlen
#  else
/* Return the length of YYSTR.  */
static YYSIZE_T
#   if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)