
#ifdef YY_QUERY_API_VER
#define YY_BYACCIC
#define YY_API_MAJOR 1
#define YY_API_MINOR 0
#endif /*YY_QUERY_API_VER*/

#define pcb_bxl_EMPTY        (-1)
#define pcb_bxl_clearin      (pcb_bxl_chr = pcb_bxl_EMPTY)
#define pcb_bxl_errok        (pcb_bxl_errflag = 0)
#define pcb_bxl_RECOVERING() (pcb_bxl_errflag != 0)
#define pcb_bxl_ENOMEM       (-2)
#define pcb_bxl_EOF          0
#line 16 "../src_plugins/io_bxl/bxl_gram.c"
#include "../src_plugins/io_bxl/bxl_gram.h"
static const pcb_bxl_int_t pcb_bxl_lhs[] = {                     -1,
    0,    5,    5,    6,    6,    6,    6,    3,    3,    7,
    7,    4,    4,    1,    1,    2,   12,   12,   12,   13,
   14,   15,   17,    8,   16,   16,   18,   18,   18,   18,
   18,   20,   22,    9,   19,   19,   23,   23,   23,   23,
   21,   21,   26,   24,   25,   25,   27,   27,   27,   27,
   29,   10,   28,   28,   30,   30,   30,   30,   31,   32,
   32,   33,   33,   33,   33,   33,   33,   33,   33,   43,
   34,   42,   42,   44,   44,   44,   44,   44,   44,   44,
   46,   35,   45,   45,   47,   47,   47,   47,   47,   49,
   36,   48,   48,   50,   50,   50,   50,   52,   37,   51,
   51,   53,   53,   53,   53,   55,   39,   54,   54,   56,
   56,   56,   56,   56,   56,   58,   40,   57,   57,   59,
   59,   59,   59,   59,   59,   41,   38,   60,   60,   61,
   61,   61,   62,   11,   63,   11,
};
static const pcb_bxl_int_t pcb_bxl_len[] = {                      2,
    2,    0,    3,    1,    1,    1,    1,    1,    1,    1,
    2,    0,    1,    1,    1,    1,    2,    2,    2,    4,
    2,    2,    0,    4,    0,    4,    2,    2,    2,    2,
    2,    0,    0,   12,    0,    4,    2,    2,    2,    2,
    0,    2,    0,    5,    0,    4,    2,    2,    1,    1,
    0,    6,    0,    3,    1,    6,    6,    6,    6,    0,
    3,    1,    1,    1,    1,    1,    1,    1,    1,    0,
    3,    0,    4,    2,    2,    2,    2,    2,    2,    1,
    0,    3,    0,    4,    2,    3,    1,    1,    1,    0,
    3,    0,    4,    4,    1,    1,    1,    0,    3,    0,
    4,    3,    1,    1,    1,    0,    3,    0,    4,    2,
    2,    2,    1,    1,    1,    0,    3,    0,    4,    2,
    2,    2,    1,    1,    1,    2,    2,    0,    4,    2,
    2,    1,    0,    4,    0,    4,
};
static const pcb_bxl_int_t pcb_bxl_defred[] = {                   0,
    0,    0,    0,   13,   11,    0,    0,    0,    1,    0,
    4,    5,    6,    7,    0,    0,   23,   32,    0,    0,
    0,    0,    0,    0,   51,    3,    0,    0,    0,   24,
    0,    0,    0,  134,  136,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   55,   14,   15,   27,   28,   29,   30,
   31,    0,   16,   37,    8,    9,   38,   39,   40,    0,
    0,    0,    0,    0,    0,   52,    0,   26,   36,    0,
    0,    0,    0,    0,   54,    0,    0,    0,    0,    0,
   33,   70,   81,   90,   98,  106,  116,    0,    0,    0,
    0,   62,   63,   64,   65,   66,   67,   68,   69,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  126,  127,   59,    0,   56,   57,   58,    0,    0,    0,
    0,   71,    0,   82,    0,   91,    0,   99,    0,  107,
    0,  117,    0,    0,    0,  132,    0,   61,   43,   34,
   42,    0,    0,    0,    0,    0,    0,   80,    0,    0,
    0,    0,    0,   87,   88,   89,    0,    0,   95,   96,
   97,    0,    0,    0,    0,    0,  103,  104,  105,    0,
    0,    0,    0,  113,  114,  115,    0,    0,    0,    0,
  123,  124,  125,    0,    0,  130,  131,    0,    0,   74,
   75,   76,   77,   78,   79,    0,   22,   21,   85,    0,
    0,    0,    0,   18,    0,   17,   19,    0,  110,  111,
  112,    0,  122,  120,  121,    0,    0,  129,    0,    0,
   73,   86,   84,    0,   93,  102,  101,  109,  119,   20,
    0,    0,   49,   50,    0,   44,   94,   47,   48,    0,
   46,
};
static const pcb_bxl_int_t pcb_bxl_dgoto[] = {                    2,
   63,   64,   67,    3,    9,   10,    4,   11,   12,   13,
   14,  177,  146,  165,  166,   30,   23,   41,   32,   24,
  129,  113,   46,  130,  230,  199,  245,   52,   33,   53,
   54,  100,  101,  102,  103,  104,  105,  106,  107,  108,
  109,  132,  114,  159,  134,  115,  167,  136,  116,  172,
  138,  117,  180,  140,  118,  187,  142,  119,  194,  121,
  147,   15,   16,
};
static const pcb_bxl_int_t pcb_bxl_sindex[] = {                  15,
   15,    0, -186,    0,    0, -250, -248, -233,    0,   15,
    0,    0,    0,    0, -284, -277,    0,    0,   15, -186,
 -214, -209,   10,   17,    0,    0, -260, -238, -135,    0,
 -237,   15, -148,    0,    0, -196, -196, -196, -195, -179,
   43, -196, -173, -173, -173,   51, -178,   37,   61,   64,
   65, -175,   15,    0,    0,    0,    0,    0,    0,    0,
    0,   10,    0,    0,    0,    0,    0,    0,    0,   17,
   52, -149, -196, -196, -196,    0, -148,    0,    0, -144,
   15,   74,   76,   96,    0,   15, -252, -196, -196, -196,
    0,    0,    0,    0,    0,    0,    0,  106,  106, -136,
   15,    0,    0,    0,    0,    0,    0,    0,    0,  107,
  108,  109, -121,  112,  114,  115,  116,  117,  119, -269,
    0,    0,    0, -252,    0,    0,    0,  -98, -107, -121,
 -166,    0, -225,    0, -189,    0, -231,    0, -206,    0,
 -234,    0, -196,  -93,  -92,    0,  123,    0,    0,    0,
    0,  -89,  -90,  -87,  -86,  -83, -196,    0,  130, -196,
  -81,  -82,  133,    0,    0,    0,  138, -196,    0,    0,
    0,  139,  -79,  -78,  -74, -173,    0,    0,    0,  143,
 -196, -196, -196,    0,    0,    0,  144, -196,  -73, -173,
    0,    0,    0,  145,  146,    0,    0,  106,  148,    0,
    0,    0,    0,    0,    0,  112,    0,    0,    0, -196,
  114,  147,  115,    0,  -71,    0,    0,  116,    0,    0,
    0,  117,    0,    0,    0,  119, -196,    0, -134,   15,
    0,    0,    0, -196,    0,    0,    0,    0,    0,    0,
 -196,  -66,    0,    0,  152,    0,    0,    0,    0,  148,
    0,
};
static const pcb_bxl_int_t pcb_bxl_rindex[] = {                  11,
    1,    0,    2,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    2,
    0,    0,  184,  185,    0,    0,    0,    0,    0,    0,
    0,    0,  -85,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  184,    0,    0,    0,    0,    0,    0,    0,  185,
    0,    0,    0,    0,    0,    0,  -85,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  -84,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  187,  187,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,  -72,  190,  191,  192,  193,  194,  195,    0,
    0,    0,    0,  -84,    0,    0,    0,    0,    0,  -72,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  187,  196,    0,
    0,    0,    0,    0,    0,  190,    0,    0,    0,    0,
  191,    0,  192,    0,    0,    0,    0,  193,    0,    0,
    0,  194,    0,    0,    0,  195,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  196,
    0,
};
static const pcb_bxl_int_t pcb_bxl_gindex[] = {                   0,
  -22,  -69,  -37,    0,  188,    0,   -1,    0,    0,    0,
    0,   66,  -20, -113, -122,  149,    0,    0,  140,    0,
   79,    0,    0,    0,  -38,    0,    0,  136,    0,    0,
    0,   90,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    9,    0,    0,    5,    0,    0,    4,    0,    0,
    3,    0,    0,   -4,    0,    0,   -7,    0,    0,  -96,
    0,    0,    0,
};
#define pcb_bxl_TABLESIZE 327
static const pcb_bxl_int_t pcb_bxl_table[] = {                    5,
   10,    2,  122,   82,   83,   84,   68,   69,   20,   17,
   12,   18,  171,   57,   58,   59,  186,   25,  110,  111,
  112,  170,  143,  179,    1,  185,   19,  193,  173,   21,
   47,  173,   55,   56,   92,   42,   43,   44,   22,  144,
  145,   27,   93,   94,  161,   95,   28,  161,   96,   29,
  160,   77,   97,  161,   34,   98,   31,  143,   99,  188,
  143,   55,   56,  163,   60,  175,  143,  174,  175,  160,
  189,  176,  161,  195,  176,   45,    6,  190,   35,   87,
   61,  162,    7,   62,   91,  143,  160,   65,   66,  161,
  207,   70,   71,    8,   72,  181,  182,  183,  212,  124,
   73,  228,  143,   74,   75,   76,  244,  168,   81,   80,
  158,  219,  164,   86,  169,  243,  178,   88,  184,   89,
  192,  152,  153,  154,  155,  143,  156,  157,   36,   37,
   38,   39,   40,   48,  205,   49,   50,   51,  217,   90,
  232,  160,  241,  242,  161,  120,  123,  125,  126,  127,
  128,  131,  225,  133,  135,  137,  139,  240,  141,  220,
  221,  149,  150,  198,  247,  223,  196,  197,  200,  201,
  206,  248,  202,  203,  204,  208,  210,  209,  211,  213,
  214,  215,  216,  218,  222,  226,  224,  229,  236,  227,
  234,  249,  250,   25,   35,   53,  128,   41,   60,   72,
   83,   92,  100,  108,  118,   45,  191,   26,  151,   79,
   78,  251,   85,  148,  231,  233,  235,  238,  239,    0,
  237,    0,    0,    0,    0,    0,    0,    0,  246,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,   10,    0,    0,    0,    0,    0,   10,
   10,   10,   10,   12,    0,    0,    0,    0,    0,   12,
   10,   10,   10,   10,   10,   10,   10,   10,    0,    0,
   12,    0,    0,    0,    0,   10,   10,    0,   10,    0,
    0,   10,    0,    0,    0,   10,    0,    0,   10,    0,
    0,   10,    0,    0,   10,  133,   10,  135,    0,    0,
    0,    0,    0,    0,   12,    0,   12,
};
static const pcb_bxl_int_t pcb_bxl_check[] = {                    1,
    0,    0,   99,   73,   74,   75,   44,   45,   10,  260,
    0,  260,  135,   36,   37,   38,  139,   19,   88,   89,
   90,  135,  292,  137,   10,  139,  260,  141,  263,  314,
   32,  263,  258,  259,  287,  273,  274,  275,  316,  309,
  310,  256,  295,  296,  279,  298,  256,  279,  301,   40,
  276,   53,  305,  279,  315,  308,   40,  292,  311,  294,
  292,  258,  259,  133,  260,  300,  292,  299,  300,  276,
  305,  306,  279,  143,  306,  313,  263,  312,  317,   81,
  260,  307,  269,   41,   86,  292,  276,  261,  262,  279,
  160,   41,  271,  280,   58,  302,  303,  304,  168,  101,
   40,  198,  292,   40,   40,  281,  229,  297,  258,   58,
  131,  181,  133,  258,  135,  229,  137,   44,  139,   44,
  141,  288,  289,  290,  291,  292,  293,  294,  264,  265,
  266,  267,  268,  282,  157,  284,  285,  286,  176,   44,
  210,  276,  277,  278,  279,   40,  283,   41,   41,   41,
  272,   40,  190,   40,   40,   40,   40,  227,   40,  182,
  183,  260,  270,   41,  234,  188,  260,  260,  258,  260,
   41,  241,  260,  260,  258,  257,   44,  260,   41,   41,
  260,  260,  257,   41,   41,   41,  260,   40,  260,   44,
   44,  258,   41,   10,   10,  281,   10,  270,  283,   10,
   10,   10,   10,   10,   10,   10,  141,   20,  130,   70,
   62,  250,   77,  124,  206,  211,  213,  222,  226,   -1,
  218,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  230,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  263,   -1,   -1,   -1,   -1,   -1,  269,
  270,  271,  272,  263,   -1,   -1,   -1,   -1,   -1,  269,
  280,  281,  282,  283,  284,  285,  286,  287,   -1,   -1,
  280,   -1,   -1,   -1,   -1,  295,  296,   -1,  298,   -1,
   -1,  301,   -1,   -1,   -1,  305,   -1,   -1,  308,   -1,
   -1,  311,   -1,   -1,  314,  314,  316,  316,   -1,   -1,
   -1,   -1,   -1,   -1,  314,   -1,  316,
};
#define pcb_bxl_FINAL 2
#define pcb_bxl_MAXTOKEN 317
#define pcb_bxl_UNDFTOKEN 383
#define pcb_bxl_TRANSLATE(a) ((a) > pcb_bxl_MAXTOKEN ? pcb_bxl_UNDFTOKEN : (a))
#if pcb_bxl_DEBUG
static const char *const pcb_bxl_name[] = {

"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,"':'",0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"T_ID",
"T_INTEGER","T_REAL_ONLY","T_QSTR","T_TRUE","T_FALSE","T_TEXTSTYLE",
"T_FONTWIDTH","T_FONTCHARWIDTH","T_FONTHEIGHT","T_FONTFAMILY","T_FONTFACE",
"T_PADSTACK","T_ENDPADSTACK","T_SHAPES","T_PADSHAPE","T_HOLEDIAM","T_SURFACE",
"T_PLATED","T_WIDTH","T_HEIGHT","T_PADTYPE","T_LAYER","T_PATTERN",
"T_ENDPATTERN","T_DATA","T_ENDDATA","T_ORIGINPOINT","T_PICKPOINT","T_GLUEPOINT",
"T_PAD","T_NUMBER","T_PINNAME","T_PADSTYLE","T_ORIGINALPADSTYLE","T_ORIGIN",
"T_ORIGINALPINNUMBER","T_ROTATE","T_POLY","T_LINE","T_ENDPOINT","T_ATTRIBUTE",
"T_ATTR","T_JUSTIFY","T_ARC","T_RADIUS","T_STARTANGLE","T_SWEEPANGLE","T_TEXT",
"T_ISVISIBLE","T_PROPERTY","T_WIZARD","T_VARNAME","T_VARDATA","T_TEMPLATEDATA",
"T_ISFLIPPED","T_NOPASTE","T_SYMBOL","T_ENDSYMBOL","T_COMPONENT",
"T_ENDCOMPONENT",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
"illegal-symbol",
};
static const char *const pcb_bxl_rule[] = {
"$accept : full_file",
"full_file : maybe_nl file",
"file :",
"file : statement nl file",
"statement : text_style",
"statement : pad_stack",
"statement : pattern",
"statement : boring_section",
"boolean : T_TRUE",
"boolean : T_FALSE",
"nl : '\\n'",
"nl : '\\n' nl",
"maybe_nl :",
"maybe_nl : nl",
"real : T_INTEGER",
"real : T_REAL_ONLY",
"coord : real",
"common_attr_text : T_JUSTIFY T_ID",
"common_attr_text : T_TEXTSTYLE T_QSTR",
"common_attr_text : T_ISVISIBLE boolean",
"common_origin : T_ORIGIN coord ',' coord",
"common_layer : T_LAYER T_ID",
"common_width : T_WIDTH coord",
"$$1 :",
"text_style : T_TEXTSTYLE T_QSTR $$1 text_style_attrs",
"text_style_attrs :",
"text_style_attrs : '(' text_style_attr ')' text_style_attrs",
"text_style_attr : T_FONTWIDTH real",
"text_style_attr : T_FONTCHARWIDTH real",
"text_style_attr : T_FONTHEIGHT real",
"text_style_attr : T_FONTFAMILY T_QSTR",
"text_style_attr : T_FONTFACE T_QSTR",
"$$2 :",
"$$3 :",
"pad_stack : T_PADSTACK T_QSTR $$2 pstk_attrs nl T_SHAPES ':' T_INTEGER nl $$3 pad_shapes T_ENDPADSTACK",
"pstk_attrs :",
"pstk_attrs : '(' pstk_attr ')' pstk_attrs",
"pstk_attr : T_HOLEDIAM coord",
"pstk_attr : T_SURFACE boolean",
"pstk_attr : T_PLATED boolean",
"pstk_attr : T_NOPASTE boolean",
"pad_shapes :",
"pad_shapes : pad_shape pad_shapes",
"$$4 :",
"pad_shape : T_PADSHAPE T_QSTR $$4 padshape_attrs nl",
"padshape_attrs :",
"padshape_attrs : '(' padshape_attr ')' padshape_attrs",
"padshape_attr : T_HEIGHT coord",
"padshape_attr : T_PADTYPE T_INTEGER",
"padshape_attr : common_layer",
"padshape_attr : common_width",
"$$5 :",
"pattern : T_PATTERN T_QSTR nl $$5 pattern_chldrn T_ENDPATTERN",
"pattern_chldrn :",
"pattern_chldrn : pattern_chld nl pattern_chldrn",
"pattern_chld : data",
"pattern_chld : T_ORIGINPOINT '(' coord ',' coord ')'",
"pattern_chld : T_PICKPOINT '(' coord ',' coord ')'",
"pattern_chld : T_GLUEPOINT '(' coord ',' coord ')'",
"data : T_DATA ':' T_INTEGER nl data_chldrn T_ENDDATA",
"data_chldrn :",
"data_chldrn : data_chld nl data_chldrn",
"data_chld : pad",
"data_chld : poly",
"data_chld : line",
"data_chld : attribute",
"data_chld : templatedata",
"data_chld : arc",
"data_chld : text",
"data_chld : wizard",
"$$6 :",
"pad : T_PAD $$6 pad_attrs",
"pad_attrs :",
"pad_attrs : '(' pad_attr ')' pad_attrs",
"pad_attr : T_NUMBER T_INTEGER",
"pad_attr : T_PINNAME T_QSTR",
"pad_attr : T_PADSTYLE T_QSTR",
"pad_attr : T_ORIGINALPADSTYLE T_QSTR",
"pad_attr : T_ORIGINALPINNUMBER T_INTEGER",
"pad_attr : T_ROTATE real",
"pad_attr : common_origin",
"$$7 :",
"poly : T_POLY $$7 poly_attrs",
"poly_attrs :",
"poly_attrs : '(' poly_attr ')' poly_attrs",
"poly_attr : T_PROPERTY T_QSTR",
"poly_attr : coord ',' coord",
"poly_attr : common_origin",
"poly_attr : common_layer",
"poly_attr : common_width",
"$$8 :",
"line : T_LINE $$8 line_attrs",
"line_attrs :",
"line_attrs : '(' line_attr ')' line_attrs",
"line_attr : T_ENDPOINT coord ',' coord",
"line_attr : common_origin",
"line_attr : common_layer",
"line_attr : common_width",
"$$9 :",
"attribute : T_ATTRIBUTE $$9 attribute_attrs",
"attribute_attrs :",
"attribute_attrs : '(' attribute_attr ')' attribute_attrs",
"attribute_attr : T_ATTR T_QSTR T_QSTR",
"attribute_attr : common_attr_text",
"attribute_attr : common_origin",
"attribute_attr : common_layer",
"$$10 :",
"arc : T_ARC $$10 arc_attrs",
"arc_attrs :",
"arc_attrs : '(' arc_attr ')' arc_attrs",
"arc_attr : T_RADIUS coord",
"arc_attr : T_STARTANGLE real",
"arc_attr : T_SWEEPANGLE real",
"arc_attr : common_origin",
"arc_attr : common_layer",
"arc_attr : common_width",
"$$11 :",
"text : T_TEXT $$11 text_attrs",
"text_attrs :",
"text_attrs : '(' text_attr ')' text_attrs",
"text_attr : T_TEXT T_QSTR",
"text_attr : T_ISFLIPPED boolean",
"text_attr : T_ROTATE real",
"text_attr : common_attr_text",
"text_attr : common_origin",
"text_attr : common_layer",
"wizard : T_WIZARD wizard_attrs",
"templatedata : T_TEMPLATEDATA wizard_attrs",
"wizard_attrs :",
"wizard_attrs : '(' wizard_attr ')' wizard_attrs",
"wizard_attr : T_VARNAME T_QSTR",
"wizard_attr : T_VARDATA T_QSTR",
"wizard_attr : common_origin",
"$$12 :",
"boring_section : $$12 T_SYMBOL error T_ENDSYMBOL",
"$$13 :",
"boring_section : $$13 T_COMPONENT error T_ENDCOMPONENT",

};
#endif


#if pcb_bxl_DEBUG
#include <stdio.h> /* needed for printf */
#endif

#include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */

/* allocate initial stack or double stack size, up to yyctx->stack_max_depth */
static int pcb_bxl_growstack(pcb_bxl_yyctx_t *yyctx, pcb_bxl_STACKDATA *data)
{
	int i;
	unsigned newsize;
	pcb_bxl_int_t *newss;
	pcb_bxl_STYPE *newvs;

	if ((newsize = data->stacksize) == 0)
		newsize = pcb_bxl_INITSTACKSIZE;
	else if (newsize >= yyctx->stack_max_depth)
		return pcb_bxl_ENOMEM;
	else if ((newsize *= 2) > yyctx->stack_max_depth)
		newsize = yyctx->stack_max_depth;

	i = (int)(data->s_mark - data->s_base);
	newss = (pcb_bxl_int_t *) realloc(data->s_base, newsize * sizeof(*newss));
	if (newss == 0)
		return pcb_bxl_ENOMEM;

	data->s_base = newss;
	data->s_mark = newss + i;

	newvs = (pcb_bxl_STYPE *) realloc(data->l_base, newsize * sizeof(*newvs));
	if (newvs == 0)
		return pcb_bxl_ENOMEM;

	data->l_base = newvs;
	data->l_mark = newvs + i;

	data->stacksize = newsize;
	data->s_last = data->s_base + newsize - 1;
	return 0;
}

static void pcb_bxl_freestack(pcb_bxl_STACKDATA *data)
{
	free(data->s_base);
	free(data->l_base);
	memset(data, 0, sizeof(*data));
}

#define pcb_bxl_ABORT  goto yyabort
#define pcb_bxl_REJECT goto yyabort
#define pcb_bxl_ACCEPT goto yyaccept
#define pcb_bxl_ERROR  goto yyerrlab

int pcb_bxl_parse_init(pcb_bxl_yyctx_t *yyctx)
{
#if pcb_bxl_DEBUG
	const char *yys;

	if ((yys = getenv("pcb_bxl_DEBUG")) != 0) {
		yyctx->yyn = *yys;
		if (yyctx->yyn >= '0' && yyctx->yyn <= '9')
			yyctx->debug = yyctx->yyn - '0';
	}
#endif

	memset(&yyctx->val, 0, sizeof(yyctx->val));
	memset(&yyctx->lval, 0, sizeof(yyctx->lval));

	yyctx->yym = 0;
	yyctx->yyn = 0;
	yyctx->nerrs = 0;
	yyctx->errflag = 0;
	yyctx->chr = pcb_bxl_EMPTY;
	yyctx->state = 0;

	memset(&yyctx->stack, 0, sizeof(yyctx->stack));

	yyctx->stack_max_depth = pcb_bxl_INITSTACKSIZE > 10000 ? pcb_bxl_INITSTACKSIZE : 10000;
	if (yyctx->stack.s_base == NULL && pcb_bxl_growstack(yyctx, &yyctx->stack) == pcb_bxl_ENOMEM)
		return -1;
	yyctx->stack.s_mark = yyctx->stack.s_base;
	yyctx->stack.l_mark = yyctx->stack.l_base;
	yyctx->state = 0;
	*yyctx->stack.s_mark = 0;
	yyctx->jump = 0;
	return 0;
}


#define pcb_bxl_GETCHAR(labidx) \
do { \
	if (used)               { yyctx->jump = labidx; return pcb_bxl_RES_NEXT; } \
	getchar_ ## labidx:;    yyctx->chr = tok; yyctx->lval = *lval; used = 1; \
} while(0)

pcb_bxl_res_t pcb_bxl_parse(pcb_bxl_yyctx_t *yyctx, pcb_bxl_ctx_t *ctx, int tok, pcb_bxl_STYPE *lval)
{
	int used = 0;
#if pcb_bxl_DEBUG
	const char *yys;
#endif

yyloop:;
	if (yyctx->jump == 1) { yyctx->jump = 0; goto getchar_1; }
	if (yyctx->jump == 2) { yyctx->jump = 0; goto getchar_2; }

	if ((yyctx->yyn = pcb_bxl_defred[yyctx->state]) != 0)
		goto yyreduce;
	if (yyctx->chr < 0) {
		pcb_bxl_GETCHAR(1);
		if (yyctx->chr < 0)
			yyctx->chr = pcb_bxl_EOF;
#if pcb_bxl_DEBUG
		if (yyctx->debug) {
			if ((yys = pcb_bxl_name[pcb_bxl_TRANSLATE(yyctx->chr)]) == NULL)
				yys = pcb_bxl_name[pcb_bxl_UNDFTOKEN];
			printf("yyctx->debug: state %d, reading %d (%s)\n", yyctx->state, yyctx->chr, yys);
		}
#endif
	}
	if (((yyctx->yyn = pcb_bxl_sindex[yyctx->state]) != 0) && (yyctx->yyn += yyctx->chr) >= 0 && yyctx->yyn <= pcb_bxl_TABLESIZE && pcb_bxl_check[yyctx->yyn] == (pcb_bxl_int_t) yyctx->chr) {
#if pcb_bxl_DEBUG
		if (yyctx->debug)
			printf("yyctx->debug: state %d, shifting to state %d\n", yyctx->state, pcb_bxl_table[yyctx->yyn]);
#endif
		if (yyctx->stack.s_mark >= yyctx->stack.s_last && pcb_bxl_growstack(yyctx, &yyctx->stack) == pcb_bxl_ENOMEM)
			goto yyoverflow;
		yyctx->state = pcb_bxl_table[yyctx->yyn];
		*++yyctx->stack.s_mark = pcb_bxl_table[yyctx->yyn];
		*++yyctx->stack.l_mark = yyctx->lval;
		yyctx->chr = pcb_bxl_EMPTY;
		if (yyctx->errflag > 0)
			--yyctx->errflag;
		goto yyloop;
	}
	if (((yyctx->yyn = pcb_bxl_rindex[yyctx->state]) != 0) && (yyctx->yyn += yyctx->chr) >= 0 && yyctx->yyn <= pcb_bxl_TABLESIZE && pcb_bxl_check[yyctx->yyn] == (pcb_bxl_int_t) yyctx->chr) {
		yyctx->yyn = pcb_bxl_table[yyctx->yyn];
		goto yyreduce;
	}
	if (yyctx->errflag != 0)
		goto yyinrecovery;

	pcb_bxl_error(ctx, yyctx->lval, "syntax error");

	goto yyerrlab;	/* redundant goto avoids 'unused label' warning */
yyerrlab:
	++yyctx->nerrs;

yyinrecovery:
	if (yyctx->errflag < 3) {
		yyctx->errflag = 3;
		for(;;) {
			if (((yyctx->yyn = pcb_bxl_sindex[*yyctx->stack.s_mark]) != 0) && (yyctx->yyn += pcb_bxl_ERRCODE) >= 0 && yyctx->yyn <= pcb_bxl_TABLESIZE && pcb_bxl_check[yyctx->yyn] == (pcb_bxl_int_t) pcb_bxl_ERRCODE) {
#if pcb_bxl_DEBUG
				if (yyctx->debug)
					printf("yyctx->debug: state %d, error recovery shifting to state %d\n", *yyctx->stack.s_mark, pcb_bxl_table[yyctx->yyn]);
#endif
				if (yyctx->stack.s_mark >= yyctx->stack.s_last && pcb_bxl_growstack(yyctx, &yyctx->stack) == pcb_bxl_ENOMEM)
					goto yyoverflow;
				yyctx->state = pcb_bxl_table[yyctx->yyn];
				*++yyctx->stack.s_mark = pcb_bxl_table[yyctx->yyn];
				*++yyctx->stack.l_mark = yyctx->lval;
				goto yyloop;
			}
			else {
#if pcb_bxl_DEBUG
				if (yyctx->debug)
					printf("yyctx->debug: error recovery discarding state %d\n", *yyctx->stack.s_mark);
#endif
				if (yyctx->stack.s_mark <= yyctx->stack.s_base)
					goto yyabort;
				--yyctx->stack.s_mark;
				--yyctx->stack.l_mark;
			}
		}
	}
	else {
		if (yyctx->chr == pcb_bxl_EOF)
			goto yyabort;
#if pcb_bxl_DEBUG
		if (yyctx->debug) {
			if ((yys = pcb_bxl_name[pcb_bxl_TRANSLATE(yyctx->chr)]) == NULL)
				yys = pcb_bxl_name[pcb_bxl_UNDFTOKEN];
			printf("yyctx->debug: state %d, error recovery discards token %d (%s)\n", yyctx->state, yyctx->chr, yys);
		}
#endif
		yyctx->chr = pcb_bxl_EMPTY;
		goto yyloop;
	}

yyreduce:
#if pcb_bxl_DEBUG
	if (yyctx->debug)
		printf("yyctx->debug: state %d, reducing by rule %d (%s)\n", yyctx->state, yyctx->yyn, pcb_bxl_rule[yyctx->yyn]);
#endif
	yyctx->yym = pcb_bxl_len[yyctx->yyn];
	if (yyctx->yym > 0)
		yyctx->val = yyctx->stack.l_mark[1 - yyctx->yym];
	else
		memset(&yyctx->val, 0, sizeof yyctx->val);

	switch (yyctx->yyn) {
case 8:
#line 105 "../src_plugins/io_bxl/bxl_gram.y"
	{ yyctx->val.un.i = 1; }
break;
case 9:
#line 106 "../src_plugins/io_bxl/bxl_gram.y"
	{ yyctx->val.un.i = 0; }
break;
case 14:
#line 120 "../src_plugins/io_bxl/bxl_gram.y"
	{ yyctx->val.un.d = yyctx->stack.l_mark[0].un.i; }
break;
case 15:
#line 121 "../src_plugins/io_bxl/bxl_gram.y"
	{ yyctx->val.un.d = yyctx->stack.l_mark[0].un.d; }
break;
case 16:
#line 125 "../src_plugins/io_bxl/bxl_gram.y"
	{ yyctx->val.un.c = RND_MIL_TO_COORD(yyctx->stack.l_mark[0].un.d); }
break;
case 17:
#line 129 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_set_justify(ctx, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 18:
#line 130 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_set_text_style(ctx, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 19:
#line 131 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.is_visible = yyctx->stack.l_mark[0].un.i; }
break;
case 20:
#line 135 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.origin_x = XCRD(yyctx->stack.l_mark[-2].un.c); ctx->state.origin_y = YCRD(yyctx->stack.l_mark[0].un.c); }
break;
case 21:
#line 139 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_set_layer(ctx, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 22:
#line 143 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.width = yyctx->stack.l_mark[0].un.c; }
break;
case 23:
#line 149 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_text_style_begin(ctx, yyctx->stack.l_mark[0].un.s); /* $2 is taken over */ }
break;
case 24:
#line 150 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_text_style_end(ctx); }
break;
case 27:
#line 159 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.text_style->width = yyctx->stack.l_mark[0].un.d; }
break;
case 28:
#line 160 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.text_style->char_width = yyctx->stack.l_mark[0].un.d; }
break;
case 29:
#line 161 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.text_style->height = yyctx->stack.l_mark[0].un.d; }
break;
case 30:
#line 162 "../src_plugins/io_bxl/bxl_gram.y"
	{ free(yyctx->stack.l_mark[0].un.s); /* ignore for now */ }
break;
case 31:
#line 163 "../src_plugins/io_bxl/bxl_gram.y"
	{ free(yyctx->stack.l_mark[0].un.s); /* ignore for now */ }
break;
case 32:
#line 170 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset(ctx); pcb_bxl_padstack_begin(ctx, yyctx->stack.l_mark[0].un.s); /* $2 is taken over */ }
break;
case 33:
#line 172 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.num_shapes = yyctx->stack.l_mark[-1].un.i; }
break;
case 34:
#line 174 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_padstack_end(ctx); }
break;
case 37:
#line 183 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.hole = yyctx->stack.l_mark[0].un.c; }
break;
case 38:
#line 184 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.surface = yyctx->stack.l_mark[0].un.i; }
break;
case 39:
#line 185 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.plated = yyctx->stack.l_mark[0].un.i; }
break;
case 40:
#line 186 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.nopaste = yyctx->stack.l_mark[0].un.i; }
break;
case 43:
#line 195 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_padstack_begin_shape(ctx, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 44:
#line 196 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_padstack_end_shape(ctx); }
break;
case 47:
#line 205 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.height = yyctx->stack.l_mark[0].un.c; }
break;
case 48:
#line 206 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.pad_type = yyctx->stack.l_mark[0].un.i; }
break;
case 51:
#line 213 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset_pattern(ctx); pcb_bxl_pattern_begin(ctx, yyctx->stack.l_mark[-1].un.s); free(yyctx->stack.l_mark[-1].un.s); }
break;
case 52:
#line 215 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_pattern_end(ctx); pcb_bxl_reset_pattern(ctx); }
break;
case 56:
#line 225 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->pat_state.origin_x = XCRD(yyctx->stack.l_mark[-3].un.c); ctx->pat_state.origin_y = YCRD(yyctx->stack.l_mark[-1].un.c); }
break;
case 57:
#line 226 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->pat_state.pick_x = XCRD(yyctx->stack.l_mark[-3].un.c); ctx->pat_state.pick_y = YCRD(yyctx->stack.l_mark[-1].un.c); }
break;
case 58:
#line 227 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->pat_state.glue_x = XCRD(yyctx->stack.l_mark[-3].un.c); ctx->pat_state.glue_y = YCRD(yyctx->stack.l_mark[-1].un.c); }
break;
case 70:
#line 255 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_pad_begin(ctx); }
break;
case 71:
#line 256 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_pad_end(ctx); }
break;
case 74:
#line 265 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.pin_number = yyctx->stack.l_mark[0].un.i; }
break;
case 75:
#line 266 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.pin_name = yyctx->stack.l_mark[0].un.s; /* takes over $2 */ }
break;
case 76:
#line 267 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_pad_set_style(ctx, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 77:
#line 268 "../src_plugins/io_bxl/bxl_gram.y"
	{ /* what's this?! */ free(yyctx->stack.l_mark[0].un.s); }
break;
case 78:
#line 269 "../src_plugins/io_bxl/bxl_gram.y"
	{ /* what's this?! */ }
break;
case 79:
#line 270 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.rot = yyctx->stack.l_mark[0].un.d; }
break;
case 81:
#line 276 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_poly_begin(ctx); }
break;
case 82:
#line 277 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_poly_end(ctx); }
break;
case 85:
#line 287 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_add_property(ctx, (pcb_any_obj_t *)ctx->state.poly, yyctx->stack.l_mark[0].un.s); free(yyctx->stack.l_mark[0].un.s); }
break;
case 86:
#line 288 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_poly_add_vertex(ctx, XCRD(yyctx->stack.l_mark[-2].un.c), YCRD(yyctx->stack.l_mark[0].un.c)); }
break;
case 90:
#line 296 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset(ctx); }
break;
case 91:
#line 297 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_add_line(ctx); pcb_bxl_reset(ctx); }
break;
case 94:
#line 306 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.endp_x = XCRD(yyctx->stack.l_mark[-2].un.c); ctx->state.endp_y = YCRD(yyctx->stack.l_mark[0].un.c); }
break;
case 98:
#line 314 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset(ctx); ctx->state.is_text = 0; }
break;
case 99:
#line 315 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_add_text(ctx); pcb_bxl_reset(ctx); }
break;
case 102:
#line 324 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_set_attr_val(ctx, yyctx->stack.l_mark[-1].un.s, yyctx->stack.l_mark[0].un.s); /* $2 and $3 are taken over */ }
break;
case 106:
#line 333 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset(ctx); }
break;
case 107:
#line 334 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_add_arc(ctx); pcb_bxl_reset(ctx); }
break;
case 110:
#line 343 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.radius = yyctx->stack.l_mark[0].un.c;  }
break;
case 111:
#line 344 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.arc_start = yyctx->stack.l_mark[0].un.d; }
break;
case 112:
#line 345 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.arc_delta = yyctx->stack.l_mark[0].un.d; }
break;
case 116:
#line 353 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_reset(ctx); ctx->state.is_text = 1; }
break;
case 117:
#line 354 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_add_text(ctx); pcb_bxl_reset(ctx); }
break;
case 120:
#line 363 "../src_plugins/io_bxl/bxl_gram.y"
	{ pcb_bxl_set_text_str(ctx, yyctx->stack.l_mark[0].un.s); /* $2 is taken over */ }
break;
case 121:
#line 364 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.flipped = yyctx->stack.l_mark[0].un.i; }
break;
case 122:
#line 365 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->state.rot = yyctx->stack.l_mark[0].un.d; }
break;
case 130:
#line 386 "../src_plugins/io_bxl/bxl_gram.y"
	{ free(yyctx->stack.l_mark[0].un.s); }
break;
case 131:
#line 387 "../src_plugins/io_bxl/bxl_gram.y"
	{ free(yyctx->stack.l_mark[0].un.s); }
break;
case 133:
#line 393 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->in_error = 1; }
break;
case 134:
#line 393 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->in_error = 0; }
break;
case 135:
#line 394 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->in_error = 1; }
break;
case 136:
#line 394 "../src_plugins/io_bxl/bxl_gram.y"
	{ ctx->in_error = 0; }
break;
#line 880 "../src_plugins/io_bxl/bxl_gram.c"
	}
	yyctx->stack.s_mark -= yyctx->yym;
	yyctx->state = *yyctx->stack.s_mark;
	yyctx->stack.l_mark -= yyctx->yym;
	yyctx->yym = pcb_bxl_lhs[yyctx->yyn];
	if (yyctx->state == 0 && yyctx->yym == 0) {
#if pcb_bxl_DEBUG
		if (yyctx->debug)
			printf("yyctx->debug: after reduction, shifting from state 0 to state %d\n", pcb_bxl_FINAL);
#endif
		yyctx->state = pcb_bxl_FINAL;
		*++yyctx->stack.s_mark = pcb_bxl_FINAL;
		*++yyctx->stack.l_mark = yyctx->val;
		if (yyctx->chr < 0) {
			pcb_bxl_GETCHAR(2);
			if (yyctx->chr < 0)
				yyctx->chr = pcb_bxl_EOF;
#if pcb_bxl_DEBUG
			if (yyctx->debug) {
				if ((yys = pcb_bxl_name[pcb_bxl_TRANSLATE(yyctx->chr)]) == NULL)
					yys = pcb_bxl_name[pcb_bxl_UNDFTOKEN];
				printf("yyctx->debug: state %d, reading %d (%s)\n", pcb_bxl_FINAL, yyctx->chr, yys);
			}
#endif
		}
		if (yyctx->chr == pcb_bxl_EOF)
			goto yyaccept;
		goto yyloop;
	}
	if (((yyctx->yyn = pcb_bxl_gindex[yyctx->yym]) != 0) && (yyctx->yyn += yyctx->state) >= 0 && yyctx->yyn <= pcb_bxl_TABLESIZE && pcb_bxl_check[yyctx->yyn] == (pcb_bxl_int_t) yyctx->state)
		yyctx->state = pcb_bxl_table[yyctx->yyn];
	else
		yyctx->state = pcb_bxl_dgoto[yyctx->yym];
#if pcb_bxl_DEBUG
	if (yyctx->debug)
		printf("yyctx->debug: after reduction, shifting from state %d to state %d\n", *yyctx->stack.s_mark, yyctx->state);
#endif
	if (yyctx->stack.s_mark >= yyctx->stack.s_last && pcb_bxl_growstack(yyctx, &yyctx->stack) == pcb_bxl_ENOMEM)
		goto yyoverflow;
	*++yyctx->stack.s_mark = (pcb_bxl_int_t) yyctx->state;
	*++yyctx->stack.l_mark = yyctx->val;
	goto yyloop;

yyoverflow:
	pcb_bxl_error(ctx, yyctx->lval, "yacc stack overflow");

yyabort:
	pcb_bxl_freestack(&yyctx->stack);
	return pcb_bxl_RES_ABORT;

yyaccept:
	pcb_bxl_freestack(&yyctx->stack);
	return pcb_bxl_RES_DONE;
}
