Fossil

typedef struct Pik Pik;          /* Complete parsing context */
typedef struct PToken PToken;    /* A single token */
typedef struct PElem PElem;      /* A single diagram object or "element" */
typedef struct PEList PEList;    /* A list of elements */
typedef struct PClass PClass;    /* Description of elements types */
typedef double PNum;             /* Numeric value */

typedef struct PPoint PPoint;    /* A position in 2-D space */
typedef struct PVar PVar;        /* script-defined variable */
typedef struct PBox PBox;        /* A bounding box */

/* Compass points */
#define CP_N      1
#define CP_NE     2

  PNum x, y;             /* X and Y coordinates */
};

/* A bounding box */
struct PBox {
  PPoint sw, ne;         /* Lower-left and top-right corners */
};















/* A variable created by the ID = EXPR construct of the PIKCHR script 
**
** PIKCHR (and PIC) scripts do not use many varaibles, so it is reasonable
** to store them all on a linked list.
*/
struct PVar {

** The behavior of an object class is defined by an instance of
** this structure. This it the "virtual method" table.
*/
struct PClass {
  const char *zName;                     /* Name of class */
  char isLine;                           /* True if a line class */
  char eJust;                            /* Use box-style text justification */
  void (*xInit)(Pik*,PElem*);            /* Initializer */
  void (*xNumProp)(Pik*,PElem*,PToken*); /* Value change notification */

  PPoint (*xChop)(PElem*,PPoint*);       /* Chopper */
  PPoint (*xOffset)(Pik*,PElem*,int);    /* Offset from center to edge point */
  void (*xFit)(Pik*,PElem*,PNum w,PNum h); /* Size to fit text */
  void (*xRender)(Pik*,PElem*);            /* Render */
};


/* Forward declarations */
static void pik_append(Pik*, const char*,int);

static PNum pik_value(Pik*,const char*,int,int*);
static PNum pik_lookup_color(Pik*,PToken*);
static PNum pik_get_var(Pik*,PToken*);
static PNum pik_atof(Pik*,PToken*);
static void pik_after_adding_attributes(Pik*,PElem*);
static void pik_elem_move(PElem*,PNum dx, PNum dy);
static void pik_elist_move(PEList*,PNum dx, PNum dy);
static void pik_set_numprop(Pik*,PToken*,PNum,PNum);

static void pik_set_dashed(Pik*,PToken*,PNum*);
static void pik_then(Pik*,PToken*,PElem*);
static void pik_add_direction(Pik*,PToken*,PNum*,int);
static void pik_move_hdg(Pik*,PNum*,PToken*,PNum,PToken*,PToken*);
static void pik_evenwith(Pik*,PToken*,PPoint*);
static void pik_set_from(Pik*,PElem*,PToken*,PPoint*);
static void pik_add_to(Pik*,PElem*,PToken*,PPoint*);
static void pik_close_path(Pik*,PToken*);
static void pik_set_at(Pik*,PToken*,PPoint*,PToken*);
static short int pik_nth_value(Pik*,PToken*);
static PElem *pik_find_nth(Pik*,PElem*,PToken*);

static PToken pik_next_semantic_token(Pik *p, PToken *pThis);
static void pik_compute_layout_settings(Pik*);
static void pik_behind(Pik*,PElem*);
static PElem *pik_assert(Pik*,PNum,PToken*,PNum);
static PElem *pik_place_assert(Pik*,PPoint*,PToken*,PPoint*);


#line 459 "pikchr.c"
/**************** End of %include directives **********************************/
/* These constants specify the various numeric values for terminal symbols.
***************** Begin token definitions *************************************/
#ifndef T_ID
#define T_ID                              1
#define T_EDGEPT                          2
#define T_OF                              3

**    YY_MAX_REDUCE      Maximum value for reduce actions
*/
#ifndef INTERFACE
# define INTERFACE 1
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned char
#define YYNOCODE 128
#define YYACTIONTYPE unsigned short int
#define pik_parserTOKENTYPE PToken
typedef union {
  int yyinit;
  pik_parserTOKENTYPE yy0;

  PEList* yy52;
  PElem* yy58;
  int yy92;
  PPoint yy95;
  PNum yy149;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
#endif
#define pik_parserARG_SDECL
#define pik_parserARG_PDECL
#define pik_parserARG_PARAM
#define pik_parserARG_FETCH
#define pik_parserARG_STORE
#define pik_parserCTX_SDECL Pik *p;
#define pik_parserCTX_PDECL ,Pik *p
#define pik_parserCTX_PARAM ,p
#define pik_parserCTX_FETCH Pik *p=yypParser->p;
#define pik_parserCTX_STORE yypParser->p=p;
#define YYFALLBACK 1
#define YYNSTATE             164
#define YYNRULE              155
#define YYNRULE_WITH_ACTION  116
#define YYNTOKEN             94
#define YY_MAX_SHIFT         163
#define YY_MIN_SHIFTREDUCE   283
#define YY_MAX_SHIFTREDUCE   437
#define YY_ERROR_ACTION      438
#define YY_ACCEPT_ACTION     439
#define YY_NO_ACTION         440
#define YY_MIN_REDUCE        441
#define YY_MAX_REDUCE        595
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section

**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (1270)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   569,  554,  441,   21,  555,  556,  116,  442,  449,   27,
 /*    10 */   569,  132,   31,  445,   65,   64,   63,   62,  422,  423,
 /*    20 */   339,   70,   83,  374,  163,  133,  569,   23,  494,  161,
 /*    30 */   124,  318,  319,    6,    5,   37,  573,   36,    4,   72,
 /*    40 */   131,   55,  335,   67,   54,   34,  430,  339,  339,  339,
 /*    50 */   339,  420,  421,  340,  341,  342,  343,  344,  345,  346,
 /*    60 */   347,  466,   31,  528,  571,   78,  571,  407,  408,  409,
 /*    70 */   410,  466,   30,  436,  435,  491,  161,  124,  305,  422,
 /*    80 */   423,  339,  356,   83,  526,  161,  124,  466,    8,  115,
 /*    90 */    75,   32,  318,  319,    6,    5,   37,  122,   36,    4,
 /*   100 */    72,  131,   70,  335,   67,  429,   52,   48,  339,  339,
 /*   110 */   339,  339,  420,  421,  340,  341,  342,  343,  344,  345,
 /*   120 */   346,  347,  465,  301,  431,  432,  433,  434,   26,  443,
 /*   130 */   449,   27,  465,   25,  329,  445,   65,   64,   63,   62,
 /*   140 */   422,  423,  339,   84,   83,   29,  163,   85,  465,   23,
 /*   150 */   531,  161,  124,  318,  319,    6,    5,   37,   76,   36,
 /*   160 */     4,   72,  131,   76,  335,   67,  394,  395,   42,  339,
 /*   170 */   339,  339,  339,  420,  421,  340,  341,  342,  343,  344,
 /*   180 */   345,  346,  347,  391,  430,  294,   60,   61,   65,   64,
 /*   190 */    63,   62,   82,   33,  374,   63,   62,   20,   24,  391,
 /*   200 */   430,   68,   60,   61,   81,   66,  303,   80,    2,    3,
 /*   210 */   374,  436,  435,   20,  419,  349,  349,  349,  349,  349,
 /*   220 */   349,  349,  349,  349,  349,  114,  418,  436,  435,  399,
 /*   230 */   529,  161,  124,  135,  125,  161,  124,  355,  457,  427,
 /*   240 */   153,  140,  130,  429,  564,    7,  400,  401,  402,  404,
 /*   250 */    81,  139,  303,   80,  154,  407,  408,  409,  410,  429,
 /*   260 */   113,  425,  431,  432,  433,  434,  149,    9,  122,  390,
 /*   270 */   156,  155,  128,  127,  161,  124,  113,   11,  431,  432,
 /*   280 */   433,  434,  378,  157,  122,  390,  156,  155,  391,  430,
 /*   290 */    39,   60,   61,  128,  377,  159,  447,   27,   74,  374,
 /*   300 */   149,   13,   59,   14,  119,  448,  118,  125,  161,  124,
 /*   310 */    15,  126,  442,  449,   27,   69,  436,  435,  445,  143,
 /*   320 */   141,   65,   64,   63,   62,  376,  158,  150,  358,  163,
 /*   330 */    57,  439,   23,   86,  389,    1,   65,   64,   63,   62,
 /*   340 */    53,   18,  125,  161,  124,   58,  148,  147,  429,  389,
 /*   350 */   382,  380,  381,   38,  375,   45,  143,  141,   65,   64,
 /*   360 */    63,   62,  154,  376,  158,  113,  160,  431,  432,  433,
 /*   370 */   434,  440,   71,  122,  390,  156,  155,   53,   35,  440,
 /*   380 */   162,   17,   16,  148,  147,  440,  440,  123,  440,   19,
 /*   390 */    38,  146,  142,  426,  391,  440,  440,   60,   61,   65,
 /*   400 */    64,   63,   62,  314,  440,  112,  532,  440,   59,  440,
 /*   410 */   440,  296,  297,  298,  440,  300,  440,  440,   17,   16,
 /*   420 */   391,  440,  440,   60,   61,  123,   19,  440,  146,  142,
 /*   430 */   426,  374,  391,  330,   59,   60,   61,  391,  326,  440,
 /*   440 */    60,   61,  440,  374,  440,  532,   59,  440,  374,  440,
 /*   450 */   532,   59,  440,  532,  440,  440,  422,  423,  339,  440,
 /*   460 */   440,  440,  440,  136,  134,  440,   87,   41,  440,  440,
 /*   470 */   440,  113,   43,  440,  430,  125,  161,  124,  440,  122,
 /*   480 */   390,  156,  155,   98,  374,  339,  339,  339,  339,  420,
 /*   490 */   421,  440,  125,  161,  124,  154,  440,  113,   22,  440,
 /*   500 */   440,  436,  435,  440,  440,  122,  390,  156,  155,  113,
 /*   510 */   440,  440,  154,  440,  113,  440,  440,  122,  390,  156,
 /*   520 */   155,  440,  122,  390,  156,  155,  391,  144,  440,   60,
 /*   530 */    61,  391,  145,  429,   60,   61,  440,  374,  440,  440,
 /*   540 */    59,  440,  374,  440,  440,   59,  440,  440,  440,  440,
 /*   550 */   113,  440,  431,  432,  433,  434,  391,  440,  122,   60,
 /*   560 */    61,  391,  440,  440,   60,   61,  440,  374,  440,  440,
 /*   570 */    59,  440,  112,  440,  391,   59,  440,   60,   61,  391,
 /*   580 */   440,  440,   60,   61,  440,  374,  114,  440,   46,  440,
 /*   590 */   374,   92,  440,   50,  440,  125,  161,  124,  440,  457,
 /*   600 */   125,  161,  124,  113,   79,   79,  440,  440,  113,  440,
 /*   610 */   440,  122,  390,  156,  155,  154,  122,  390,  156,  155,
 /*   620 */   154,   74,  440,  149,  440,  440,  114,  440,  496,  118,





 /*   630 */   125,  161,  124,  113,  440,  125,  161,  124,  113,  471,
 /*   640 */   440,  122,  390,  156,  155,  430,  122,  390,  156,  155,
 /*   650 */   150,  113,  440,  440,  440,  154,  113,  440,  440,  122,
 /*   660 */   390,  156,  155,  440,  122,  390,  156,  155,  440,   74,
 /*   670 */   440,  149,  436,  435,  440,  440,  495,  118,  125,  161,
 /*   680 */   124,   74,  440,  149,  114,  440,  440,  440,  489,  118,
 /*   690 */   125,  161,  124,  125,  161,  124,  440,  446,  150,   65,
 /*   700 */    64,   63,   62,  440,  429,  440,  440,   74,  440,  149,
 /*   710 */   150,  440,  293,  154,  479,  118,  125,  161,  124,  440,
 /*   720 */    74,  440,  149,  431,  432,  433,  434,  478,  118,  125,
 /*   730 */   161,  124,   74,  440,  149,  440,  150,  440,  440,  515,
 /*   740 */   118,  125,  161,  124,  440,   74,  440,  149,  440,  150,
 /*   750 */   440,  440,  138,  118,  125,  161,  124,  440,   74,  440,
 /*   760 */   149,  150,  440,  440,  440,  523,  118,  125,  161,  124,
 /*   770 */    74,  440,  149,  440,  150,  440,  440,  525,  118,  125,
 /*   780 */   161,  124,   74,  440,  149,  440,  440,  150,  440,  522,
 /*   790 */   118,  125,  161,  124,   93,   65,   64,   63,   62,  150,
 /*   800 */   440,  440,  440,  125,  161,  124,   74,   40,  149,  440,
 /*   810 */   440,  150,  440,  524,  118,  125,  161,  124,  440,   74,
 /*   820 */   440,  149,  440,  154,  440,  440,  521,  118,  125,  161,
 /*   830 */   124,   74,  440,  149,  440,  150,  440,  440,  520,  118,
 /*   840 */   125,  161,  124,  440,   74,  440,  149,  440,  150,  440,
 /*   850 */   440,  519,  118,  125,  161,  124,  440,   74,  440,  149,
 /*   860 */   150,  440,  440,  440,  518,  118,  125,  161,  124,   74,
 /*   870 */   440,  149,  440,  150,  440,  440,  517,  118,  125,  161,
 /*   880 */   124,   74,  440,  149,  440,  440,  150,  440,  151,  118,
 /*   890 */   125,  161,  124,   90,   65,   64,   63,   62,  150,  440,
 /*   900 */   440,  440,  125,  161,  124,   74,  440,  149,  440,  440,
 /*   910 */   150,  440,  152,  118,  125,  161,  124,  440,   73,  440,
 /*   920 */   149,  440,  154,   10,  440,  117,  118,  125,  161,  124,
 /*   930 */    74,  440,  149,  440,  150,  440,  440,  137,  118,  125,
 /*   940 */   161,  124,  440,   74,  440,  149,  440,  150,  440,  440,








 /*   950 */   475,  118,  125,  161,  124,  440,   91,  440,  149,  150,
 /*   960 */   440,  440,  440,  440,  129,  125,  161,  124,   77,  440,
 /*   970 */   440,  325,  150,   65,   64,   63,   62,  125,  161,  124,
 /*   980 */    65,   64,   63,   62,  440,  150,  440,  440,  440,  460,
 /*   990 */   440,   28,  104,  389,  440,  440,  440,  154,  440,   49,
 /*  1000 */   440,  125,  161,  124,  105,   44,  440,  440,  440,  106,
 /*  1010 */   440,  440,  440,  125,  161,  124,  440,  107,  125,  161,
 /*  1020 */   124,  154,  440,  440,  440,   94,  125,  161,  124,  440,
 /*  1030 */   440,   88,  440,  154,  125,  161,  124,  440,  154,  108,
 /*  1040 */   125,  161,  124,  440,  440,  440,  154,  440,  125,  161,
 /*  1050 */   124,  440,   95,  440,  154,   96,  440,  440,  440,  440,
 /*  1060 */   154,  125,  161,  124,  125,  161,  124,  440,  154,   65,
 /*  1070 */    64,   63,   62,  440,  440,  440,   89,  440,  440,  109,
 /*  1080 */   440,  154,   97,  440,  154,  125,  161,  124,  125,  161,
 /*  1090 */   124,  125,  161,  124,   65,   64,   63,   62,   12,   65,
 /*  1100 */    64,   63,   62,  110,  440,  154,  440,  354,  154,  440,
 /*  1110 */   440,  154,  125,  161,  124,  440,  111,  440,   47,   99,
 /*  1120 */   440,  440,  440,  440,  100,  125,  161,  124,  125,  161,
 /*  1130 */   124,  440,  154,  125,  161,  124,  440,  440,  440,  440,
 /*  1140 */   101,  440,  440,  440,  440,  154,  440,  102,  154,  125,
 /*  1150 */   161,  124,  440,  154,  103,  440,  125,  161,  124,  440,
 /*  1160 */   440,  546,  440,  125,  161,  124,  440,  440,  440,  154,
 /*  1170 */   125,  161,  124,  440,  440,  545,  154,  440,  544,  440,
 /*  1180 */   440,  440,  440,  154,  125,  161,  124,  125,  161,  124,
 /*  1190 */   154,  543,   65,   64,   63,   62,   65,   64,   63,   62,
 /*  1200 */   125,  161,  124,  440,  154,  353,  440,  154,  440,  393,
 /*  1210 */   440,  440,  120,  440,  440,  121,  440,  440,  440,  440,
 /*  1220 */   154,  125,  161,  124,  125,  161,  124,   65,   64,   63,
 /*  1230 */    62,   65,   64,   63,   62,  309,   65,   64,   63,   62,
 /*  1240 */   440,  154,  440,  440,  154,  440,   51,  440,  440,   65,
 /*  1250 */    64,   63,   62,  440,  440,   56,   65,   64,   63,   62,
 /*  1260 */   440,  440,  392,  440,  440,  440,  440,  440,  440,  389,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */     0,   99,    0,  126,  102,  103,   94,   95,   96,   97,
 /*    10 */    10,  100,   10,  101,    4,    5,    6,    7,   18,   19,
 /*    20 */    20,    3,   22,   12,  112,  100,   26,  115,  107,  108,
 /*    30 */   109,   31,   32,   33,   34,   35,  125,   37,   38,   39,
 /*    40 */    40,   99,   42,   43,  102,  103,    2,   47,   48,   49,
 /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   59,
 /*    60 */    60,    0,   10,  100,  122,  123,  124,   27,   28,   29,
 /*    70 */    30,   10,  121,   29,   30,  107,  108,  109,   26,   18,
 /*    80 */    19,   20,   17,   22,  107,  108,  109,   26,   23,   78,
 /*    90 */    46,  101,   31,   32,   33,   34,   35,   86,   37,   38,
 /*   100 */    39,   40,   84,   42,   43,   61,    4,    5,   47,   48,
 /*   110 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
 /*   120 */    59,   60,    0,   23,   80,   81,   82,   83,  120,   95,
 /*   130 */    96,   97,   10,  118,    2,  101,    4,    5,    6,    7,
 /*   140 */    18,   19,   20,  110,   22,  121,  112,  110,   26,  115,
 /*   150 */   107,  108,  109,   31,   32,   33,   34,   35,   46,   37,
 /*   160 */    38,   39,   40,   46,   42,   43,   91,   92,   36,   47,
 /*   170 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
 /*   180 */    58,   59,   60,    1,    2,   17,    4,    5,    4,    5,
 /*   190 */     6,    7,    8,   16,   12,    6,    7,   15,   15,    1,
 /*   200 */     2,   41,    4,    5,   22,   93,   24,   25,   38,   38,
 /*   210 */    12,   29,   30,   15,   39,   61,   62,   63,   64,   65,
 /*   220 */    66,   67,   68,   69,   70,   98,   39,   29,   30,    1,
 /*   230 */   107,  108,  109,   45,  107,  108,  109,   17,  111,   76,
 /*   240 */    12,   77,   14,   61,  117,   71,   18,   19,   20,   21,
 /*   250 */    22,   75,   24,   25,  127,   27,   28,   29,   30,   61,
 /*   260 */    78,   76,   80,   81,   82,   83,  100,    3,   86,   87,
 /*   270 */    88,   89,  106,  107,  108,  109,   78,    3,   80,   81,
 /*   280 */    82,   83,   24,   25,   86,   87,   88,   89,    1,    2,
 /*   290 */    36,    4,    5,  127,   24,   25,   96,   97,   98,   12,
 /*   300 */   100,    3,   15,    3,   90,  105,  106,  107,  108,  109,
 /*   310 */     3,   94,   95,   96,   97,    3,   29,   30,  101,    2,
 /*   320 */     3,    4,    5,    6,    7,   24,   25,  127,   73,  112,
 /*   330 */    15,  114,  115,   98,   17,   13,    4,    5,    6,    7,
 /*   340 */    23,   23,  107,  108,  109,   15,   29,   30,   61,   17,
 /*   350 */    26,   26,   26,   36,   12,   23,    2,    3,    4,    5,
 /*   360 */     6,    7,  127,   24,   25,   78,   85,   80,   81,   82,

 /*   370 */    83,  128,    3,   86,   87,   88,   89,   23,   11,  128,
 /*   380 */    79,   64,   65,   29,   30,  128,  128,   86,  128,   72,
 /*   390 */    36,   74,   75,   76,    1,  128,  128,    4,    5,    4,
 /*   400 */     5,    6,    7,    8,  128,   12,   46,  128,   15,  128,
 /*   410 */   128,   18,   19,   20,  128,   22,  128,  128,   64,   65,





 /*   420 */     1,  128,  128,    4,    5,   86,   72,  128,   74,   75,

 /*   430 */    76,   12,    1,    2,   15,    4,    5,    1,    2,  128,
 /*   440 */     4,    5,  128,   12,  128,   85,   15,  128,   12,  128,
 /*   450 */    90,   15,  128,   93,  128,  128,   18,   19,   20,  128,
 /*   460 */   128,  128,  128,   44,   45,  128,   98,   36,  128,  128,
 /*   470 */   128,   78,   36,  128,    2,  107,  108,  109,  128,   86,
 /*   480 */    87,   88,   89,   98,   12,   47,   48,   49,   50,   51,
 /*   490 */    52,  128,  107,  108,  109,  127,  128,   78,  113,  128,
 /*   500 */   128,   29,   30,  128,  128,   86,   87,   88,   89,   78,
 /*   510 */   128,  128,  127,  128,   78,  128,  128,   86,   87,   88,
 /*   520 */    89,  128,   86,   87,   88,   89,    1,    2,  128,    4,
 /*   530 */     5,    1,    2,   61,    4,    5,  128,   12,  128,  128,
 /*   540 */    15,  128,   12,  128,  128,   15,  128,  128,  128,  128,
 /*   550 */    78,  128,   80,   81,   82,   83,    1,  128,   86,    4,
 /*   560 */     5,    1,  128,  128,    4,    5,  128,   12,  128,  128,
 /*   570 */    15,  128,   12,  128,    1,   15,  128,    4,    5,    1,
 /*   580 */   128,  128,    4,    5,  128,   12,   98,  128,   15,  128,
 /*   590 */    12,   98,  128,   15,  128,  107,  108,  109,  128,  111,
 /*   600 */   107,  108,  109,   78,  116,  117,  128,  128,   78,  128,
 /*   610 */   128,   86,   87,   88,   89,  127,   86,   87,   88,   89,
 /*   620 */   127,   98,  128,  100,  128,  128,   98,  128,  105,  106,
 /*   630 */   107,  108,  109,   78,  128,  107,  108,  109,   78,  111,
 /*   640 */   128,   86,   87,   88,   89,    2,   86,   87,   88,   89,
 /*   650 */   127,   78,  128,  128,  128,  127,   78,  128,  128,   86,
 /*   660 */    87,   88,   89,  128,   86,   87,   88,   89,  128,   98,
 /*   670 */   128,  100,   29,   30,  128,  128,  105,  106,  107,  108,
 /*   680 */   109,   98,  128,  100,   98,  128,  128,  128,  105,  106,
 /*   690 */   107,  108,  109,  107,  108,  109,  128,  111,  127,    4,
 /*   700 */     5,    6,    7,  128,   61,  128,  128,   98,  128,  100,
 /*   710 */   127,  128,   17,  127,  105,  106,  107,  108,  109,  128,
 /*   720 */    98,  128,  100,   80,   81,   82,   83,  105,  106,  107,
 /*   730 */   108,  109,   98,  128,  100,  128,  127,  128,  128,  105,
 /*   740 */   106,  107,  108,  109,  128,   98,  128,  100,  128,  127,
 /*   750 */   128,  128,  105,  106,  107,  108,  109,  128,   98,  128,
 /*   760 */   100,  127,  128,  128,  128,  105,  106,  107,  108,  109,
 /*   770 */    98,  128,  100,  128,  127,  128,  128,  105,  106,  107,
 /*   780 */   108,  109,   98,  128,  100,  128,  128,  127,  128,  105,
 /*   790 */   106,  107,  108,  109,   98,    4,    5,    6,    7,  127,
 /*   800 */   128,  128,  128,  107,  108,  109,   98,   16,  100,  128,
 /*   810 */   128,  127,  128,  105,  106,  107,  108,  109,  128,   98,
 /*   820 */   128,  100,  128,  127,  128,  128,  105,  106,  107,  108,
 /*   830 */   109,   98,  128,  100,  128,  127,  128,  128,  105,  106,
 /*   840 */   107,  108,  109,  128,   98,  128,  100,  128,  127,  128,
 /*   850 */   128,  105,  106,  107,  108,  109,  128,   98,  128,  100,
 /*   860 */   127,  128,  128,  128,  105,  106,  107,  108,  109,   98,
 /*   870 */   128,  100,  128,  127,  128,  128,  105,  106,  107,  108,
 /*   880 */   109,   98,  128,  100,  128,  128,  127,  128,  105,  106,
 /*   890 */   107,  108,  109,   98,    4,    5,    6,    7,  127,  128,
 /*   900 */   128,  128,  107,  108,  109,   98,  128,  100,  128,  128,
 /*   910 */   127,  128,  105,  106,  107,  108,  109,  128,   98,  128,
 /*   920 */   100,  128,  127,   33,  128,  105,  106,  107,  108,  109,
 /*   930 */    98,  128,  100,  128,  127,  128,  128,  105,  106,  107,
 /*   940 */   108,  109,  128,   98,  128,  100,  128,  127,  128,  128,
 /*   950 */   105,  106,  107,  108,  109,  128,   98,  128,  100,  127,
 /*   960 */   128,  128,  128,  128,  106,  107,  108,  109,   98,  128,
 /*   970 */   128,    2,  127,    4,    5,    6,    7,  107,  108,  109,
 /*   980 */     4,    5,    6,    7,  128,  127,  128,  128,  128,  119,
 /*   990 */   128,  121,   98,   17,  128,  128,  128,  127,  128,   23,
 /*  1000 */   128,  107,  108,  109,   98,   36,  128,  128,  128,   98,
 /*  1010 */   128,  128,  128,  107,  108,  109,  128,   98,  107,  108,
 /*  1020 */   109,  127,  128,  128,  128,   98,  107,  108,  109,  128,
 /*  1030 */   128,   98,  128,  127,  107,  108,  109,  128,  127,   98,
 /*  1040 */   107,  108,  109,  128,  128,  128,  127,  128,  107,  108,
 /*  1050 */   109,  128,   98,  128,  127,   98,  128,  128,  128,  128,
 /*  1060 */   127,  107,  108,  109,  107,  108,  109,  128,  127,    4,
 /*  1070 */     5,    6,    7,  128,  128,  128,   98,  128,  128,   98,
 /*  1080 */   128,  127,   98,  128,  127,  107,  108,  109,  107,  108,
 /*  1090 */   109,  107,  108,  109,    4,    5,    6,    7,   33,    4,
 /*  1100 */     5,    6,    7,   98,  128,  127,  128,   17,  127,  128,
 /*  1110 */   128,  127,  107,  108,  109,  128,   98,  128,   23,   98,
 /*  1120 */   128,  128,  128,  128,   98,  107,  108,  109,  107,  108,
 /*  1130 */   109,  128,  127,  107,  108,  109,  128,  128,  128,  128,
 /*  1140 */    98,  128,  128,  128,  128,  127,  128,   98,  127,  107,
 /*  1150 */   108,  109,  128,  127,   98,  128,  107,  108,  109,  128,
 /*  1160 */   128,   98,  128,  107,  108,  109,  128,  128,  128,  127,
 /*  1170 */   107,  108,  109,  128,  128,   98,  127,  128,   98,  128,
 /*  1180 */   128,  128,  128,  127,  107,  108,  109,  107,  108,  109,
 /*  1190 */   127,   98,    4,    5,    6,    7,    4,    5,    6,    7,
 /*  1200 */   107,  108,  109,  128,  127,   17,  128,  127,  128,   17,
 /*  1210 */   128,  128,   98,  128,  128,   98,  128,  128,  128,  128,
 /*  1220 */   127,  107,  108,  109,  107,  108,  109,    4,    5,    6,
 /*  1230 */     7,    4,    5,    6,    7,    8,    4,    5,    6,    7,
 /*  1240 */   128,  127,  128,  128,  127,  128,   23,  128,  128,    4,
 /*  1250 */     5,    6,    7,  128,  128,   23,    4,    5,    6,    7,
 /*  1260 */   128,  128,   17,  128,  128,  128,  128,  128,  128,   17,
 /*  1270 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1280 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1290 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1300 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1310 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1320 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1330 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1340 */   128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
 /*  1350 */   128,   94,   94,   94,   94,   94,   94,   94,   94,   94,
 /*  1360 */    94,   94,   94,   94,
};
#define YY_SHIFT_COUNT    (163)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (1252)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */   228,  182,  198,  198,  198,  198,  198,  198,  198,  198,
 /*    10 */   198,  198,  198,  198,  198,  198,  198,  198,  198,  198,
 /*    20 */   198,  198,  198,  393,  287,  393,  228,  555,    0,   61,
 /*    30 */   122,  228,  419,  472,  560,  560,  431,  436,  525,  530,
 /*    40 */   555,  555,  555,  555,  555,  555,  555,  555,  573,  555,
 /*    50 */   555,  555,  578,  555,  555,  555,  555,  555,  555,  555,
 /*    60 */   555,  555,  555,  555,  555,  555,  438,   11,   11,   11,
 /*    70 */    11,   11,   44,  317,  354,  643,  643,  184,   40,  100,
 /*    80 */  1270, 1270, 1270, 1270,  154,  154,  132,  969,  332,  976,
 /*    90 */   695,  791,  890, 1065, 1090, 1095, 1188, 1223,  395, 1227,
 /*   100 */  1192, 1232, 1245, 1252,   10,   10,   10,   10,   10,   10,
 /*   110 */    10,   10,  360,  301,   10,  339,   52,   65,  102,   75,
 /*   120 */   189,  189,  258,  270,   18,  112,    2,  117,  168,  177,
 /*   130 */   183,  160,  170,  171,  175,  187,  188,  174,  220,  163,
 /*   140 */   176,  164,  185,  264,  274,  298,  254,  300,  307,  312,
 /*   150 */   214,  255,  318,  322,  214,  315,  330,  324,  325,  326,
 /*   160 */   342,  281,  369,  367,
};
#define YY_REDUCE_COUNT (83)
#define YY_REDUCE_MIN   (-123)
#define YY_REDUCE_MAX   (1117)
static const short yy_reduce_ofst[] = {
 /*     0 */   217,  200,  523,  571,  583,  609,  622,  634,  647,  660,
 /*    10 */   672,  684,  708,  721,  733,  746,  759,  771,  783,  807,
 /*    20 */   820,  832,  845,  488,  858,  127,  -88,  870,  -58,  -58,
 /*    30 */   -58,   34,  385,  166,  528,  586,  235,  368,  493,  696,
 /*    40 */   795,  894,  906,  911,  919,  927,  933,  941,  954,  957,
 /*    50 */   978,  981,  984, 1005, 1018, 1021, 1026, 1042, 1049, 1056,
 /*    60 */  1063, 1077, 1080, 1093, 1114, 1117,  -98,  -79,  -32,  -23,
 /*    70 */    43,  123,  -89, -123, -123,  -75,  -37,  -49,  -10,   15,
 /*    80 */     8,   33,   24,   37,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   444,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*    10 */   438,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*    20 */   438,  438,  438,  438,  438,  438,  444,  570,  575,  575,
 /*    30 */   575,  444,  474,  438,  438,  438,  574,  480,  438,  438,
 /*    40 */   438,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*    50 */   438,  438,  438,  438,  470,  438,  438,  438,  438,  438,
 /*    60 */   438,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*    70 */   438,  438,  438,  438,  438,  438,  438,  570,  438,  450,
 /*    80 */   464,  506,  570,  506,  462,  492,  438,  438,  438,  438,
 /*    90 */   438,  438,  438,  438,  438,  438,  438,  438,  473,  468,
 /*   100 */   438,  438,  438,  438,  486,  485,  482,  481,  510,  509,
 /*   110 */   508,  469,  453,  438,  561,  438,  438,  438,  582,  438,
 /*   120 */   542,  541,  537,  438,  530,  527,  438,  527,  438,  438,
 /*   130 */   438,  490,  438,  438,  438,  438,  438,  438,  438,  438,
 /*   140 */   438,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*   150 */   586,  438,  438,  438,  438,  438,  438,  438,  438,  438,
 /*   160 */   438,  595,  438,  438,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.  
** If a construct like the following:
** 
**      %fallback ID X Y Z.

  /*  107 */ "object",
  /*  108 */ "objectname",
  /*  109 */ "nth",
  /*  110 */ "textposition",
  /*  111 */ "rvalue",
  /*  112 */ "lvalue",
  /*  113 */ "even",
  /*  114 */ "document",
  /*  115 */ "print",
  /*  116 */ "prlist",
  /*  117 */ "pritem",
  /*  118 */ "prsep",
  /*  119 */ "attribute_list",
  /*  120 */ "savelist",
  /*  121 */ "alist",
  /*  122 */ "attribute",
  /*  123 */ "go",
  /*  124 */ "boolproperty",
  /*  125 */ "withclause",
  /*  126 */ "between",
  /*  127 */ "place2",


};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */

#ifndef NDEBUG
/* For tracing reduce actions, the names of all rules are required.
*/
static const char *const yyRuleName[] = {

 /*  17 */ "pritem ::= STRING",
 /*  18 */ "prsep ::= COMMA",
 /*  19 */ "unnamed_element ::= basetype attribute_list",
 /*  20 */ "basetype ::= CLASSNAME",
 /*  21 */ "basetype ::= STRING textposition",
 /*  22 */ "basetype ::= LB savelist element_list RB",
 /*  23 */ "savelist ::=",
 /*  24 */ "attribute_list ::= expr alist",
 /*  25 */ "attribute_list ::= expr PERCENT alist",
 /*  26 */ "attribute ::= numproperty expr PERCENT",
 /*  27 */ "attribute ::= numproperty expr",
 /*  28 */ "attribute ::= dashproperty expr",
 /*  29 */ "attribute ::= dashproperty",
 /*  30 */ "attribute ::= colorproperty rvalue",
 /*  31 */ "attribute ::= go direction expr PERCENT",
 /*  32 */ "attribute ::= go direction expr",
 /*  33 */ "attribute ::= go direction",
 /*  34 */ "attribute ::= go direction even position",
 /*  35 */ "attribute ::= CLOSE",
 /*  36 */ "attribute ::= CHOP",
 /*  37 */ "attribute ::= FROM position",
 /*  38 */ "attribute ::= TO position",
 /*  39 */ "attribute ::= THEN",
 /*  40 */ "attribute ::= THEN expr HEADING expr",
 /*  41 */ "attribute ::= THEN HEADING expr",
 /*  42 */ "attribute ::= THEN expr EDGEPT",
 /*  43 */ "attribute ::= THEN EDGEPT",
 /*  44 */ "attribute ::= GO expr HEADING expr",
 /*  45 */ "attribute ::= GO HEADING expr",
 /*  46 */ "attribute ::= GO expr EDGEPT",
 /*  47 */ "attribute ::= GO EDGEPT",
 /*  48 */ "attribute ::= AT position",
 /*  49 */ "attribute ::= SAME",
 /*  50 */ "attribute ::= SAME AS object",
 /*  51 */ "attribute ::= STRING textposition",
 /*  52 */ "attribute ::= FIT",
 /*  53 */ "attribute ::= BEHIND object",
 /*  54 */ "withclause ::= DOT_E edge AT position",
 /*  55 */ "withclause ::= edge AT position",
 /*  56 */ "numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS",
 /*  57 */ "boolproperty ::= CW",
 /*  58 */ "boolproperty ::= CCW",
 /*  59 */ "boolproperty ::= LARROW",
 /*  60 */ "boolproperty ::= RARROW",
 /*  61 */ "boolproperty ::= LRARROW",
 /*  62 */ "boolproperty ::= INVIS",
 /*  63 */ "boolproperty ::= THICK",
 /*  64 */ "boolproperty ::= THIN",
 /*  65 */ "textposition ::=",
 /*  66 */ "textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL",
 /*  67 */ "position ::= expr COMMA expr",
 /*  68 */ "position ::= place PLUS expr COMMA expr",
 /*  69 */ "position ::= place MINUS expr COMMA expr",
 /*  70 */ "position ::= place PLUS LP expr COMMA expr RP",
 /*  71 */ "position ::= place MINUS LP expr COMMA expr RP",
 /*  72 */ "position ::= LP position COMMA position RP",
 /*  73 */ "position ::= LP position RP",
 /*  74 */ "position ::= expr between position AND position",
 /*  75 */ "position ::= expr LT position COMMA position GT",
 /*  76 */ "position ::= expr ABOVE position",
 /*  77 */ "position ::= expr BELOW position",
 /*  78 */ "position ::= expr LEFT OF position",
 /*  79 */ "position ::= expr RIGHT OF position",
 /*  80 */ "position ::= expr ON HEADING EDGEPT OF position",
 /*  81 */ "position ::= expr HEADING EDGEPT OF position",
 /*  82 */ "position ::= expr EDGEPT OF position",
 /*  83 */ "position ::= expr ON HEADING expr FROM position",
 /*  84 */ "position ::= expr HEADING expr FROM position",
 /*  85 */ "place ::= edge OF object",
 /*  86 */ "place2 ::= object",
 /*  87 */ "place2 ::= object DOT_E edge",
 /*  88 */ "place2 ::= NTH VERTEX OF object",
 /*  89 */ "object ::= nth",
 /*  90 */ "object ::= nth OF|IN object",
 /*  91 */ "objectname ::= PLACENAME",
 /*  92 */ "objectname ::= objectname DOT_U PLACENAME",
 /*  93 */ "nth ::= NTH CLASSNAME",
 /*  94 */ "nth ::= NTH LAST CLASSNAME",
 /*  95 */ "nth ::= LAST CLASSNAME",
 /*  96 */ "nth ::= LAST",
 /*  97 */ "nth ::= NTH LB RB",
 /*  98 */ "nth ::= NTH LAST LB RB",
 /*  99 */ "nth ::= LAST LB RB",
 /* 100 */ "expr ::= expr PLUS expr",
 /* 101 */ "expr ::= expr MINUS expr",
 /* 102 */ "expr ::= expr STAR expr",
 /* 103 */ "expr ::= expr SLASH expr",
 /* 104 */ "expr ::= MINUS expr",
 /* 105 */ "expr ::= PLUS expr",
 /* 106 */ "expr ::= LP expr RP",
 /* 107 */ "expr ::= NUMBER",
 /* 108 */ "expr ::= ID",
 /* 109 */ "expr ::= FUNC1 LP expr RP",
 /* 110 */ "expr ::= FUNC2 LP expr COMMA expr RP",
 /* 111 */ "expr ::= place2 DOT_XY X",
 /* 112 */ "expr ::= place2 DOT_XY Y",
 /* 113 */ "expr ::= object DOT_L numproperty",
 /* 114 */ "expr ::= object DOT_L dashproperty",
 /* 115 */ "expr ::= object DOT_L colorproperty",
 /* 116 */ "lvalue ::= ID",
 /* 117 */ "lvalue ::= FILL",
 /* 118 */ "lvalue ::= COLOR",
 /* 119 */ "lvalue ::= THICKNESS",
 /* 120 */ "rvalue ::= expr",
 /* 121 */ "print ::= PRINT",
 /* 122 */ "prlist ::= pritem",
 /* 123 */ "prlist ::= prlist prsep pritem",
 /* 124 */ "direction ::= UP",
 /* 125 */ "direction ::= DOWN",
 /* 126 */ "direction ::= LEFT",
 /* 127 */ "direction ::= RIGHT",

 /* 128 */ "attribute_list ::= alist",
 /* 129 */ "alist ::=",
 /* 130 */ "alist ::= alist attribute",
 /* 131 */ "attribute ::= boolproperty",
 /* 132 */ "attribute ::= WITH withclause",
 /* 133 */ "go ::= GO",
 /* 134 */ "go ::=",
 /* 135 */ "even ::= UNTIL EVEN WITH",
 /* 136 */ "even ::= EVEN WITH",
 /* 137 */ "dashproperty ::= DOTTED",
 /* 138 */ "dashproperty ::= DASHED",
 /* 139 */ "colorproperty ::= FILL",
 /* 140 */ "colorproperty ::= COLOR",
 /* 141 */ "position ::= place",
 /* 142 */ "between ::= WAY BETWEEN",
 /* 143 */ "between ::= BETWEEN",
 /* 144 */ "between ::= OF THE WAY BETWEEN",
 /* 145 */ "place ::= place2",
 /* 146 */ "edge ::= CENTER",
 /* 147 */ "edge ::= EDGEPT",
 /* 148 */ "edge ::= TOP",
 /* 149 */ "edge ::= BOTTOM",
 /* 150 */ "edge ::= START",
 /* 151 */ "edge ::= END",
 /* 152 */ "edge ::= RIGHT",
 /* 153 */ "edge ::= LEFT",
 /* 154 */ "object ::= objectname",
};
#endif /* NDEBUG */


#if YYSTACKDEPTH<=0
/*
** Try to increase the size of the parser stack.  Return the number

    ** Note: during a reduce, the only symbols destroyed are those
    ** which appear on the RHS of the rule, but which are *not* used
    ** inside the C code.
    */
/********* Begin destructor definitions ***************************************/
    case 94: /* element_list */
{
#line 448 "pikchr.y"
pik_elist_free(p,(yypminor->yy52));
#line 1662 "pikchr.c"
}
      break;
    case 95: /* element */
    case 96: /* unnamed_element */
    case 97: /* basetype */
{
#line 450 "pikchr.y"
pik_elem_free(p,(yypminor->yy58));
#line 1671 "pikchr.c"
}
      break;
/********* End destructor definitions *****************************************/
    default:  break;   /* If no destructor action specified: do nothing */
  }
}

     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
   }
#endif
   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
   /* Here code is inserted which will execute if the parser
   ** stack every overflows */
/******** Begin %stack_overflow code ******************************************/
#line 479 "pikchr.y"

  pik_error(p, 0, "parser stack overflow");
#line 1892 "pikchr.c"
/******** End %stack_overflow code ********************************************/
   pik_parserARG_STORE /* Suppress warning about unused %extra_argument var */
   pik_parserCTX_STORE
}

/*
** Print tracing information for a SHIFT action

  yytos->minor.yy0 = yyMinor;
  yyTraceShift(yypParser, yyNewState, "Shift");
}

/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
** of that rule */
static const YYCODETYPE yyRuleInfoLhs[] = {
   114,  /* (0) document ::= element_list */
    94,  /* (1) element_list ::= element */
    94,  /* (2) element_list ::= element_list EOL element */
    95,  /* (3) element ::= */
    95,  /* (4) element ::= direction */
    95,  /* (5) element ::= lvalue ASSIGN rvalue */
    95,  /* (6) element ::= PLACENAME COLON unnamed_element */
    95,  /* (7) element ::= PLACENAME COLON position */
    95,  /* (8) element ::= unnamed_element */
    95,  /* (9) element ::= print prlist */
    95,  /* (10) element ::= ASSERT LP expr EQ expr RP */
    95,  /* (11) element ::= ASSERT LP place EQ place RP */
   111,  /* (12) rvalue ::= PLACENAME */
   117,  /* (13) pritem ::= FILL */
   117,  /* (14) pritem ::= COLOR */
   117,  /* (15) pritem ::= THICKNESS */
   117,  /* (16) pritem ::= rvalue */
   117,  /* (17) pritem ::= STRING */
   118,  /* (18) prsep ::= COMMA */
    96,  /* (19) unnamed_element ::= basetype attribute_list */
    97,  /* (20) basetype ::= CLASSNAME */
    97,  /* (21) basetype ::= STRING textposition */
    97,  /* (22) basetype ::= LB savelist element_list RB */
   120,  /* (23) savelist ::= */
   119,  /* (24) attribute_list ::= expr alist */
   119,  /* (25) attribute_list ::= expr PERCENT alist */
   122,  /* (26) attribute ::= numproperty expr PERCENT */

   122,  /* (27) attribute ::= numproperty expr */
   122,  /* (28) attribute ::= dashproperty expr */
   122,  /* (29) attribute ::= dashproperty */
   122,  /* (30) attribute ::= colorproperty rvalue */
   122,  /* (31) attribute ::= go direction expr PERCENT */
   122,  /* (32) attribute ::= go direction expr */
   122,  /* (33) attribute ::= go direction */
   122,  /* (34) attribute ::= go direction even position */
   122,  /* (35) attribute ::= CLOSE */
   122,  /* (36) attribute ::= CHOP */
   122,  /* (37) attribute ::= FROM position */
   122,  /* (38) attribute ::= TO position */
   122,  /* (39) attribute ::= THEN */
   122,  /* (40) attribute ::= THEN expr HEADING expr */
   122,  /* (41) attribute ::= THEN HEADING expr */
   122,  /* (42) attribute ::= THEN expr EDGEPT */
   122,  /* (43) attribute ::= THEN EDGEPT */
   122,  /* (44) attribute ::= GO expr HEADING expr */
   122,  /* (45) attribute ::= GO HEADING expr */
   122,  /* (46) attribute ::= GO expr EDGEPT */
   122,  /* (47) attribute ::= GO EDGEPT */
   122,  /* (48) attribute ::= AT position */
   122,  /* (49) attribute ::= SAME */
   122,  /* (50) attribute ::= SAME AS object */
   122,  /* (51) attribute ::= STRING textposition */
   122,  /* (52) attribute ::= FIT */
   122,  /* (53) attribute ::= BEHIND object */
   125,  /* (54) withclause ::= DOT_E edge AT position */
   125,  /* (55) withclause ::= edge AT position */
    99,  /* (56) numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
   124,  /* (57) boolproperty ::= CW */
   124,  /* (58) boolproperty ::= CCW */
   124,  /* (59) boolproperty ::= LARROW */
   124,  /* (60) boolproperty ::= RARROW */
   124,  /* (61) boolproperty ::= LRARROW */
   124,  /* (62) boolproperty ::= INVIS */
   124,  /* (63) boolproperty ::= THICK */
   124,  /* (64) boolproperty ::= THIN */
   110,  /* (65) textposition ::= */
   110,  /* (66) textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
   105,  /* (67) position ::= expr COMMA expr */
   105,  /* (68) position ::= place PLUS expr COMMA expr */
   105,  /* (69) position ::= place MINUS expr COMMA expr */
   105,  /* (70) position ::= place PLUS LP expr COMMA expr RP */
   105,  /* (71) position ::= place MINUS LP expr COMMA expr RP */
   105,  /* (72) position ::= LP position COMMA position RP */
   105,  /* (73) position ::= LP position RP */
   105,  /* (74) position ::= expr between position AND position */
   105,  /* (75) position ::= expr LT position COMMA position GT */
   105,  /* (76) position ::= expr ABOVE position */
   105,  /* (77) position ::= expr BELOW position */
   105,  /* (78) position ::= expr LEFT OF position */
   105,  /* (79) position ::= expr RIGHT OF position */
   105,  /* (80) position ::= expr ON HEADING EDGEPT OF position */
   105,  /* (81) position ::= expr HEADING EDGEPT OF position */
   105,  /* (82) position ::= expr EDGEPT OF position */
   105,  /* (83) position ::= expr ON HEADING expr FROM position */
   105,  /* (84) position ::= expr HEADING expr FROM position */
   106,  /* (85) place ::= edge OF object */
   127,  /* (86) place2 ::= object */
   127,  /* (87) place2 ::= object DOT_E edge */
   127,  /* (88) place2 ::= NTH VERTEX OF object */
   107,  /* (89) object ::= nth */
   107,  /* (90) object ::= nth OF|IN object */
   108,  /* (91) objectname ::= PLACENAME */
   108,  /* (92) objectname ::= objectname DOT_U PLACENAME */
   109,  /* (93) nth ::= NTH CLASSNAME */
   109,  /* (94) nth ::= NTH LAST CLASSNAME */
   109,  /* (95) nth ::= LAST CLASSNAME */
   109,  /* (96) nth ::= LAST */
   109,  /* (97) nth ::= NTH LB RB */
   109,  /* (98) nth ::= NTH LAST LB RB */
   109,  /* (99) nth ::= LAST LB RB */
    98,  /* (100) expr ::= expr PLUS expr */
    98,  /* (101) expr ::= expr MINUS expr */
    98,  /* (102) expr ::= expr STAR expr */
    98,  /* (103) expr ::= expr SLASH expr */
    98,  /* (104) expr ::= MINUS expr */
    98,  /* (105) expr ::= PLUS expr */
    98,  /* (106) expr ::= LP expr RP */
    98,  /* (107) expr ::= NUMBER */
    98,  /* (108) expr ::= ID */
    98,  /* (109) expr ::= FUNC1 LP expr RP */
    98,  /* (110) expr ::= FUNC2 LP expr COMMA expr RP */
    98,  /* (111) expr ::= place2 DOT_XY X */
    98,  /* (112) expr ::= place2 DOT_XY Y */
    98,  /* (113) expr ::= object DOT_L numproperty */
    98,  /* (114) expr ::= object DOT_L dashproperty */
    98,  /* (115) expr ::= object DOT_L colorproperty */
   112,  /* (116) lvalue ::= ID */
   112,  /* (117) lvalue ::= FILL */
   112,  /* (118) lvalue ::= COLOR */
   112,  /* (119) lvalue ::= THICKNESS */
   111,  /* (120) rvalue ::= expr */
   115,  /* (121) print ::= PRINT */
   116,  /* (122) prlist ::= pritem */
   116,  /* (123) prlist ::= prlist prsep pritem */
   101,  /* (124) direction ::= UP */
   101,  /* (125) direction ::= DOWN */
   101,  /* (126) direction ::= LEFT */
   101,  /* (127) direction ::= RIGHT */

   119,  /* (128) attribute_list ::= alist */
   121,  /* (129) alist ::= */
   121,  /* (130) alist ::= alist attribute */
   122,  /* (131) attribute ::= boolproperty */
   122,  /* (132) attribute ::= WITH withclause */
   123,  /* (133) go ::= GO */
   123,  /* (134) go ::= */
   113,  /* (135) even ::= UNTIL EVEN WITH */
   113,  /* (136) even ::= EVEN WITH */
   102,  /* (137) dashproperty ::= DOTTED */
   102,  /* (138) dashproperty ::= DASHED */
   103,  /* (139) colorproperty ::= FILL */
   103,  /* (140) colorproperty ::= COLOR */
   105,  /* (141) position ::= place */
   126,  /* (142) between ::= WAY BETWEEN */
   126,  /* (143) between ::= BETWEEN */
   126,  /* (144) between ::= OF THE WAY BETWEEN */
   106,  /* (145) place ::= place2 */
   100,  /* (146) edge ::= CENTER */
   100,  /* (147) edge ::= EDGEPT */
   100,  /* (148) edge ::= TOP */
   100,  /* (149) edge ::= BOTTOM */
   100,  /* (150) edge ::= START */
   100,  /* (151) edge ::= END */
   100,  /* (152) edge ::= RIGHT */
   100,  /* (153) edge ::= LEFT */
   107,  /* (154) object ::= objectname */
};

/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
** of symbols on the right-hand side of that rule. */
static const signed char yyRuleInfoNRhs[] = {
   -1,  /* (0) document ::= element_list */
   -1,  /* (1) element_list ::= element */

   -1,  /* (17) pritem ::= STRING */
   -1,  /* (18) prsep ::= COMMA */
   -2,  /* (19) unnamed_element ::= basetype attribute_list */
   -1,  /* (20) basetype ::= CLASSNAME */
   -2,  /* (21) basetype ::= STRING textposition */
   -4,  /* (22) basetype ::= LB savelist element_list RB */
    0,  /* (23) savelist ::= */
   -2,  /* (24) attribute_list ::= expr alist */
   -3,  /* (25) attribute_list ::= expr PERCENT alist */
   -3,  /* (26) attribute ::= numproperty expr PERCENT */
   -2,  /* (27) attribute ::= numproperty expr */
   -2,  /* (28) attribute ::= dashproperty expr */
   -1,  /* (29) attribute ::= dashproperty */
   -2,  /* (30) attribute ::= colorproperty rvalue */
   -4,  /* (31) attribute ::= go direction expr PERCENT */
   -3,  /* (32) attribute ::= go direction expr */
   -2,  /* (33) attribute ::= go direction */
   -4,  /* (34) attribute ::= go direction even position */
   -1,  /* (35) attribute ::= CLOSE */
   -1,  /* (36) attribute ::= CHOP */
   -2,  /* (37) attribute ::= FROM position */
   -2,  /* (38) attribute ::= TO position */
   -1,  /* (39) attribute ::= THEN */
   -4,  /* (40) attribute ::= THEN expr HEADING expr */
   -3,  /* (41) attribute ::= THEN HEADING expr */
   -3,  /* (42) attribute ::= THEN expr EDGEPT */
   -2,  /* (43) attribute ::= THEN EDGEPT */
   -4,  /* (44) attribute ::= GO expr HEADING expr */
   -3,  /* (45) attribute ::= GO HEADING expr */
   -3,  /* (46) attribute ::= GO expr EDGEPT */
   -2,  /* (47) attribute ::= GO EDGEPT */
   -2,  /* (48) attribute ::= AT position */
   -1,  /* (49) attribute ::= SAME */
   -3,  /* (50) attribute ::= SAME AS object */
   -2,  /* (51) attribute ::= STRING textposition */
   -1,  /* (52) attribute ::= FIT */
   -2,  /* (53) attribute ::= BEHIND object */
   -4,  /* (54) withclause ::= DOT_E edge AT position */
   -3,  /* (55) withclause ::= edge AT position */
   -1,  /* (56) numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
   -1,  /* (57) boolproperty ::= CW */
   -1,  /* (58) boolproperty ::= CCW */
   -1,  /* (59) boolproperty ::= LARROW */
   -1,  /* (60) boolproperty ::= RARROW */
   -1,  /* (61) boolproperty ::= LRARROW */
   -1,  /* (62) boolproperty ::= INVIS */
   -1,  /* (63) boolproperty ::= THICK */
   -1,  /* (64) boolproperty ::= THIN */
    0,  /* (65) textposition ::= */
   -2,  /* (66) textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
   -3,  /* (67) position ::= expr COMMA expr */
   -5,  /* (68) position ::= place PLUS expr COMMA expr */
   -5,  /* (69) position ::= place MINUS expr COMMA expr */
   -7,  /* (70) position ::= place PLUS LP expr COMMA expr RP */
   -7,  /* (71) position ::= place MINUS LP expr COMMA expr RP */
   -5,  /* (72) position ::= LP position COMMA position RP */
   -3,  /* (73) position ::= LP position RP */
   -5,  /* (74) position ::= expr between position AND position */
   -6,  /* (75) position ::= expr LT position COMMA position GT */
   -3,  /* (76) position ::= expr ABOVE position */
   -3,  /* (77) position ::= expr BELOW position */
   -4,  /* (78) position ::= expr LEFT OF position */
   -4,  /* (79) position ::= expr RIGHT OF position */
   -6,  /* (80) position ::= expr ON HEADING EDGEPT OF position */
   -5,  /* (81) position ::= expr HEADING EDGEPT OF position */
   -4,  /* (82) position ::= expr EDGEPT OF position */
   -6,  /* (83) position ::= expr ON HEADING expr FROM position */
   -5,  /* (84) position ::= expr HEADING expr FROM position */
   -3,  /* (85) place ::= edge OF object */
   -1,  /* (86) place2 ::= object */
   -3,  /* (87) place2 ::= object DOT_E edge */
   -4,  /* (88) place2 ::= NTH VERTEX OF object */
   -1,  /* (89) object ::= nth */
   -3,  /* (90) object ::= nth OF|IN object */
   -1,  /* (91) objectname ::= PLACENAME */
   -3,  /* (92) objectname ::= objectname DOT_U PLACENAME */
   -2,  /* (93) nth ::= NTH CLASSNAME */
   -3,  /* (94) nth ::= NTH LAST CLASSNAME */
   -2,  /* (95) nth ::= LAST CLASSNAME */
   -1,  /* (96) nth ::= LAST */
   -3,  /* (97) nth ::= NTH LB RB */
   -4,  /* (98) nth ::= NTH LAST LB RB */
   -3,  /* (99) nth ::= LAST LB RB */
   -3,  /* (100) expr ::= expr PLUS expr */
   -3,  /* (101) expr ::= expr MINUS expr */
   -3,  /* (102) expr ::= expr STAR expr */
   -3,  /* (103) expr ::= expr SLASH expr */
   -2,  /* (104) expr ::= MINUS expr */
   -2,  /* (105) expr ::= PLUS expr */
   -3,  /* (106) expr ::= LP expr RP */
   -1,  /* (107) expr ::= NUMBER */
   -1,  /* (108) expr ::= ID */
   -4,  /* (109) expr ::= FUNC1 LP expr RP */
   -6,  /* (110) expr ::= FUNC2 LP expr COMMA expr RP */
   -3,  /* (111) expr ::= place2 DOT_XY X */
   -3,  /* (112) expr ::= place2 DOT_XY Y */
   -3,  /* (113) expr ::= object DOT_L numproperty */
   -3,  /* (114) expr ::= object DOT_L dashproperty */
   -3,  /* (115) expr ::= object DOT_L colorproperty */
   -1,  /* (116) lvalue ::= ID */
   -1,  /* (117) lvalue ::= FILL */
   -1,  /* (118) lvalue ::= COLOR */
   -1,  /* (119) lvalue ::= THICKNESS */
   -1,  /* (120) rvalue ::= expr */
   -1,  /* (121) print ::= PRINT */
   -1,  /* (122) prlist ::= pritem */
   -3,  /* (123) prlist ::= prlist prsep pritem */
   -1,  /* (124) direction ::= UP */
   -1,  /* (125) direction ::= DOWN */
   -1,  /* (126) direction ::= LEFT */
   -1,  /* (127) direction ::= RIGHT */

   -1,  /* (128) attribute_list ::= alist */
    0,  /* (129) alist ::= */
   -2,  /* (130) alist ::= alist attribute */
   -1,  /* (131) attribute ::= boolproperty */
   -2,  /* (132) attribute ::= WITH withclause */
   -1,  /* (133) go ::= GO */
    0,  /* (134) go ::= */
   -3,  /* (135) even ::= UNTIL EVEN WITH */
   -2,  /* (136) even ::= EVEN WITH */
   -1,  /* (137) dashproperty ::= DOTTED */
   -1,  /* (138) dashproperty ::= DASHED */
   -1,  /* (139) colorproperty ::= FILL */
   -1,  /* (140) colorproperty ::= COLOR */
   -1,  /* (141) position ::= place */
   -2,  /* (142) between ::= WAY BETWEEN */
   -1,  /* (143) between ::= BETWEEN */
   -4,  /* (144) between ::= OF THE WAY BETWEEN */
   -1,  /* (145) place ::= place2 */
   -1,  /* (146) edge ::= CENTER */
   -1,  /* (147) edge ::= EDGEPT */
   -1,  /* (148) edge ::= TOP */
   -1,  /* (149) edge ::= BOTTOM */
   -1,  /* (150) edge ::= START */
   -1,  /* (151) edge ::= END */
   -1,  /* (152) edge ::= RIGHT */
   -1,  /* (153) edge ::= LEFT */
   -1,  /* (154) object ::= objectname */
};

static void yy_accept(yyParser*);  /* Forward Declaration */

/*
** Perform a reduce action and the shift that must immediately
** follow the reduce.

  **     { ... }           // User supplied code
  **  #line <lineno> <thisfile>
  **     break;
  */
/********** Begin reduce actions **********************************************/
        YYMINORTYPE yylhsminor;
      case 0: /* document ::= element_list */
#line 483 "pikchr.y"
{pik_render(p,yymsp[0].minor.yy52);}
#line 2371 "pikchr.c"
        break;
      case 1: /* element_list ::= element */
#line 486 "pikchr.y"
{ yylhsminor.yy52 = pik_elist_append(p,0,yymsp[0].minor.yy58); }
#line 2376 "pikchr.c"
  yymsp[0].minor.yy52 = yylhsminor.yy52;
        break;
      case 2: /* element_list ::= element_list EOL element */
#line 488 "pikchr.y"
{ yylhsminor.yy52 = pik_elist_append(p,yymsp[-2].minor.yy52,yymsp[0].minor.yy58); }
#line 2382 "pikchr.c"
  yymsp[-2].minor.yy52 = yylhsminor.yy52;
        break;
      case 3: /* element ::= */
#line 491 "pikchr.y"
{ yymsp[1].minor.yy58 = 0; }
#line 2388 "pikchr.c"
        break;
      case 4: /* element ::= direction */
#line 492 "pikchr.y"
{ pik_set_direction(p,yymsp[0].minor.yy0.eCode);  yylhsminor.yy58=0; }
#line 2393 "pikchr.c"
  yymsp[0].minor.yy58 = yylhsminor.yy58;
        break;
      case 5: /* element ::= lvalue ASSIGN rvalue */
#line 493 "pikchr.y"
{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy149,&yymsp[-1].minor.yy0); yylhsminor.yy58=0;}
#line 2399 "pikchr.c"
  yymsp[-2].minor.yy58 = yylhsminor.yy58;
        break;
      case 6: /* element ::= PLACENAME COLON unnamed_element */
#line 495 "pikchr.y"
{ yylhsminor.yy58 = yymsp[0].minor.yy58;  pik_elem_setname(p,yymsp[0].minor.yy58,&yymsp[-2].minor.yy0); }
#line 2405 "pikchr.c"
  yymsp[-2].minor.yy58 = yylhsminor.yy58;
        break;
      case 7: /* element ::= PLACENAME COLON position */
#line 497 "pikchr.y"
{ yylhsminor.yy58 = pik_elem_new(p,0,0,0);
                 if(yylhsminor.yy58){ yylhsminor.yy58->ptAt = yymsp[0].minor.yy95; pik_elem_setname(p,yylhsminor.yy58,&yymsp[-2].minor.yy0); }}
#line 2412 "pikchr.c"
  yymsp[-2].minor.yy58 = yylhsminor.yy58;
        break;
      case 8: /* element ::= unnamed_element */
#line 499 "pikchr.y"
{yylhsminor.yy58 = yymsp[0].minor.yy58;}
#line 2418 "pikchr.c"
  yymsp[0].minor.yy58 = yylhsminor.yy58;
        break;
      case 9: /* element ::= print prlist */
#line 500 "pikchr.y"
{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy58=0;}
#line 2424 "pikchr.c"
        break;
      case 10: /* element ::= ASSERT LP expr EQ expr RP */
#line 505 "pikchr.y"
{yymsp[-5].minor.yy58=pik_assert(p,yymsp[-3].minor.yy149,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy149);}
#line 2429 "pikchr.c"
        break;
      case 11: /* element ::= ASSERT LP place EQ place RP */
#line 507 "pikchr.y"
{yymsp[-5].minor.yy58=pik_place_assert(p,&yymsp[-3].minor.yy95,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy95);}
#line 2434 "pikchr.c"
        break;
      case 12: /* rvalue ::= PLACENAME */
#line 518 "pikchr.y"
{yylhsminor.yy149 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
#line 2439 "pikchr.c"
  yymsp[0].minor.yy149 = yylhsminor.yy149;
        break;
      case 13: /* pritem ::= FILL */
      case 14: /* pritem ::= COLOR */ yytestcase(yyruleno==14);
      case 15: /* pritem ::= THICKNESS */ yytestcase(yyruleno==15);
#line 523 "pikchr.y"
{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
#line 2447 "pikchr.c"
        break;
      case 16: /* pritem ::= rvalue */
#line 526 "pikchr.y"
{pik_append_num(p,"",yymsp[0].minor.yy149);}
#line 2452 "pikchr.c"
        break;
      case 17: /* pritem ::= STRING */
#line 527 "pikchr.y"
{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
#line 2457 "pikchr.c"
        break;
      case 18: /* prsep ::= COMMA */
#line 528 "pikchr.y"
{pik_append(p, " ", 1);}
#line 2462 "pikchr.c"
        break;
      case 19: /* unnamed_element ::= basetype attribute_list */
#line 531 "pikchr.y"
{yylhsminor.yy58 = yymsp[-1].minor.yy58; pik_after_adding_attributes(p,yylhsminor.yy58);}
#line 2467 "pikchr.c"
  yymsp[-1].minor.yy58 = yylhsminor.yy58;
        break;
      case 20: /* basetype ::= CLASSNAME */
#line 533 "pikchr.y"
{yylhsminor.yy58 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
#line 2473 "pikchr.c"
  yymsp[0].minor.yy58 = yylhsminor.yy58;
        break;
      case 21: /* basetype ::= STRING textposition */
#line 535 "pikchr.y"
{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy92; yylhsminor.yy58 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
#line 2479 "pikchr.c"
  yymsp[-1].minor.yy58 = yylhsminor.yy58;
        break;
      case 22: /* basetype ::= LB savelist element_list RB */
#line 537 "pikchr.y"
{ p->list = yymsp[-2].minor.yy52; yymsp[-3].minor.yy58 = pik_elem_new(p,0,0,yymsp[-1].minor.yy52); if(yymsp[-3].minor.yy58) yymsp[-3].minor.yy58->errTok = yymsp[0].minor.yy0; }
#line 2485 "pikchr.c"
        break;
      case 23: /* savelist ::= */
#line 542 "pikchr.y"
{yymsp[1].minor.yy52 = p->list; p->list = 0;}

















#line 2490 "pikchr.c"
        break;
      case 24: /* attribute_list ::= expr alist */
#line 549 "pikchr.y"
{ pik_add_direction(p,0,&yymsp[-1].minor.yy149,0);}
#line 2495 "pikchr.c"
        break;
      case 25: /* attribute_list ::= expr PERCENT alist */
#line 550 "pikchr.y"
{ pik_add_direction(p,0,&yymsp[-2].minor.yy149,1);}
#line 2500 "pikchr.c"
        break;
      case 26: /* attribute ::= numproperty expr PERCENT */
#line 555 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-2].minor.yy0,0.0,yymsp[-1].minor.yy149/100.0); }
#line 2505 "pikchr.c"
        break;
      case 27: /* attribute ::= numproperty expr */
      case 30: /* attribute ::= colorproperty rvalue */ yytestcase(yyruleno==30);
#line 556 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy149,0.0); }
#line 2511 "pikchr.c"
        break;
      case 28: /* attribute ::= dashproperty expr */
#line 557 "pikchr.y"
{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy149); }
#line 2516 "pikchr.c"
        break;
      case 29: /* attribute ::= dashproperty */
#line 558 "pikchr.y"
{ pik_set_dashed(p,&yymsp[0].minor.yy0,0);  }
#line 2521 "pikchr.c"
        break;
      case 31: /* attribute ::= go direction expr PERCENT */
#line 561 "pikchr.y"
{ pik_add_direction(p,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy149,1);}
#line 2526 "pikchr.c"
        break;
      case 32: /* attribute ::= go direction expr */
#line 562 "pikchr.y"
{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy149,0);}
#line 2531 "pikchr.c"
        break;
      case 33: /* attribute ::= go direction */
#line 563 "pikchr.y"
{ pik_add_direction(p,&yymsp[0].minor.yy0,0,0); }
#line 2536 "pikchr.c"
        break;
      case 34: /* attribute ::= go direction even position */
#line 564 "pikchr.y"
{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy95);}
#line 2541 "pikchr.c"
        break;
      case 35: /* attribute ::= CLOSE */
#line 565 "pikchr.y"
{ pik_close_path(p,&yymsp[0].minor.yy0); }
#line 2546 "pikchr.c"
        break;
      case 36: /* attribute ::= CHOP */
#line 566 "pikchr.y"
{ p->cur->bChop = 1; }
#line 2551 "pikchr.c"
        break;
      case 37: /* attribute ::= FROM position */
#line 567 "pikchr.y"
{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy95); }
#line 2556 "pikchr.c"
        break;
      case 38: /* attribute ::= TO position */
#line 568 "pikchr.y"
{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy95); }
#line 2561 "pikchr.c"
        break;
      case 39: /* attribute ::= THEN */
#line 569 "pikchr.y"
{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }






#line 2566 "pikchr.c"
        break;
      case 40: /* attribute ::= THEN expr HEADING expr */










      case 44: /* attribute ::= GO expr HEADING expr */ yytestcase(yyruleno==44);
#line 571 "pikchr.y"
{pik_move_hdg(p,&yymsp[-2].minor.yy149,&yymsp[-1].minor.yy0,yymsp[0].minor.yy149,0,&yymsp[-3].minor.yy0);}
#line 2572 "pikchr.c"
        break;
      case 41: /* attribute ::= THEN HEADING expr */
      case 45: /* attribute ::= GO HEADING expr */ yytestcase(yyruleno==45);
#line 572 "pikchr.y"
{pik_move_hdg(p,0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy149,0,&yymsp[-2].minor.yy0);}
#line 2578 "pikchr.c"
        break;
      case 42: /* attribute ::= THEN expr EDGEPT */
      case 46: /* attribute ::= GO expr EDGEPT */ yytestcase(yyruleno==46);
#line 573 "pikchr.y"
{pik_move_hdg(p,&yymsp[-1].minor.yy149,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
#line 2584 "pikchr.c"
        break;
      case 43: /* attribute ::= THEN EDGEPT */
      case 47: /* attribute ::= GO EDGEPT */ yytestcase(yyruleno==47);
#line 574 "pikchr.y"
{pik_move_hdg(p,0,0,0,&yymsp[0].minor.yy0,&yymsp[-1].minor.yy0);}
#line 2590 "pikchr.c"
        break;
      case 48: /* attribute ::= AT position */
#line 580 "pikchr.y"
{ pik_set_at(p,0,&yymsp[0].minor.yy95,&yymsp[-1].minor.yy0); }
#line 2595 "pikchr.c"
        break;
      case 49: /* attribute ::= SAME */
#line 582 "pikchr.y"
{pik_same(p,0,&yymsp[0].minor.yy0);}
#line 2600 "pikchr.c"
        break;
      case 50: /* attribute ::= SAME AS object */
#line 583 "pikchr.y"
{pik_same(p,yymsp[0].minor.yy58,&yymsp[-2].minor.yy0);}
#line 2605 "pikchr.c"
        break;
      case 51: /* attribute ::= STRING textposition */
#line 584 "pikchr.y"
{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy92);}
#line 2610 "pikchr.c"
        break;
      case 52: /* attribute ::= FIT */
#line 585 "pikchr.y"
{pik_size_to_fit(p,&yymsp[0].minor.yy0); }
#line 2615 "pikchr.c"
        break;
      case 53: /* attribute ::= BEHIND object */
#line 586 "pikchr.y"
{pik_behind(p,yymsp[0].minor.yy58);}
#line 2620 "pikchr.c"
        break;
      case 54: /* withclause ::= DOT_E edge AT position */
      case 55: /* withclause ::= edge AT position */ yytestcase(yyruleno==55);
#line 594 "pikchr.y"
{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy95,&yymsp[-1].minor.yy0); }
#line 2626 "pikchr.c"
        break;
      case 56: /* numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
#line 598 "pikchr.y"
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
#line 2631 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 57: /* boolproperty ::= CW */
#line 609 "pikchr.y"
{p->cur->cw = 1;}
#line 2637 "pikchr.c"
        break;
      case 58: /* boolproperty ::= CCW */
#line 610 "pikchr.y"
{p->cur->cw = 0;}
#line 2642 "pikchr.c"
        break;
      case 59: /* boolproperty ::= LARROW */
#line 611 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=0; }
#line 2647 "pikchr.c"
        break;
      case 60: /* boolproperty ::= RARROW */
#line 612 "pikchr.y"
{p->cur->larrow=0; p->cur->rarrow=1; }
#line 2652 "pikchr.c"
        break;
      case 61: /* boolproperty ::= LRARROW */
#line 613 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=1; }
#line 2657 "pikchr.c"
        break;
      case 62: /* boolproperty ::= INVIS */
#line 614 "pikchr.y"
{p->cur->sw = 0.0;}
#line 2662 "pikchr.c"
        break;
      case 63: /* boolproperty ::= THICK */
#line 615 "pikchr.y"
{p->cur->sw *= 1.5;}
#line 2667 "pikchr.c"
        break;
      case 64: /* boolproperty ::= THIN */
#line 616 "pikchr.y"
{p->cur->sw *= 0.67;}




























#line 2672 "pikchr.c"

        break;
      case 65: /* textposition ::= */
#line 618 "pikchr.y"
{yymsp[1].minor.yy92 = 0;}
#line 2677 "pikchr.c"

        break;
      case 66: /* textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
#line 621 "pikchr.y"
{yylhsminor.yy92 = pik_text_position(p,yymsp[-1].minor.yy92,&yymsp[0].minor.yy0);}
#line 2682 "pikchr.c"
  yymsp[-1].minor.yy92 = yylhsminor.yy92;
        break;
      case 67: /* position ::= expr COMMA expr */
#line 624 "pikchr.y"
{yylhsminor.yy95.x=yymsp[-2].minor.yy149; yylhsminor.yy95.y=yymsp[0].minor.yy149;}
#line 2688 "pikchr.c"
  yymsp[-2].minor.yy95 = yylhsminor.yy95;
        break;
      case 68: /* position ::= place PLUS expr COMMA expr */
#line 626 "pikchr.y"
{yylhsminor.yy95.x=yymsp[-4].minor.yy95.x+yymsp[-2].minor.yy149; yylhsminor.yy95.y=yymsp[-4].minor.yy95.y+yymsp[0].minor.yy149;}
#line 2694 "pikchr.c"
  yymsp[-4].minor.yy95 = yylhsminor.yy95;
        break;
      case 69: /* position ::= place MINUS expr COMMA expr */
#line 627 "pikchr.y"
{yylhsminor.yy95.x=yymsp[-4].minor.yy95.x-yymsp[-2].minor.yy149; yylhsminor.yy95.y=yymsp[-4].minor.yy95.y-yymsp[0].minor.yy149;}
#line 2700 "pikchr.c"
  yymsp[-4].minor.yy95 = yylhsminor.yy95;
        break;
      case 70: /* position ::= place PLUS LP expr COMMA expr RP */
#line 629 "pikchr.y"
{yylhsminor.yy95.x=yymsp[-6].minor.yy95.x+yymsp[-3].minor.yy149; yylhsminor.yy95.y=yymsp[-6].minor.yy95.y+yymsp[-1].minor.yy149;}
#line 2706 "pikchr.c"
  yymsp[-6].minor.yy95 = yylhsminor.yy95;
        break;
      case 71: /* position ::= place MINUS LP expr COMMA expr RP */
#line 631 "pikchr.y"
{yylhsminor.yy95.x=yymsp[-6].minor.yy95.x-yymsp[-3].minor.yy149; yylhsminor.yy95.y=yymsp[-6].minor.yy95.y-yymsp[-1].minor.yy149;}
#line 2712 "pikchr.c"
  yymsp[-6].minor.yy95 = yylhsminor.yy95;
        break;
      case 72: /* position ::= LP position COMMA position RP */
#line 632 "pikchr.y"
{yymsp[-4].minor.yy95.x=yymsp[-3].minor.yy95.x; yymsp[-4].minor.yy95.y=yymsp[-1].minor.yy95.y;}
#line 2718 "pikchr.c"
        break;
      case 73: /* position ::= LP position RP */
#line 633 "pikchr.y"
{yymsp[-2].minor.yy95=yymsp[-1].minor.yy95;}
#line 2723 "pikchr.c"
        break;
      case 74: /* position ::= expr between position AND position */
#line 635 "pikchr.y"
{yylhsminor.yy95 = pik_position_between(p,yymsp[-4].minor.yy149,yymsp[-2].minor.yy95,yymsp[0].minor.yy95);}
#line 2728 "pikchr.c"
  yymsp[-4].minor.yy95 = yylhsminor.yy95;
        break;
      case 75: /* position ::= expr LT position COMMA position GT */
#line 637 "pikchr.y"
{yylhsminor.yy95 = pik_position_between(p,yymsp[-5].minor.yy149,yymsp[-3].minor.yy95,yymsp[-1].minor.yy95);}
#line 2734 "pikchr.c"
  yymsp[-5].minor.yy95 = yylhsminor.yy95;
        break;
      case 76: /* position ::= expr ABOVE position */
#line 638 "pikchr.y"
{yylhsminor.yy95=yymsp[0].minor.yy95; yylhsminor.yy95.y += yymsp[-2].minor.yy149;}
#line 2740 "pikchr.c"
  yymsp[-2].minor.yy95 = yylhsminor.yy95;
        break;
      case 77: /* position ::= expr BELOW position */
#line 639 "pikchr.y"
{yylhsminor.yy95=yymsp[0].minor.yy95; yylhsminor.yy95.y -= yymsp[-2].minor.yy149;}
#line 2746 "pikchr.c"
  yymsp[-2].minor.yy95 = yylhsminor.yy95;
        break;
      case 78: /* position ::= expr LEFT OF position */
#line 640 "pikchr.y"
{yylhsminor.yy95=yymsp[0].minor.yy95; yylhsminor.yy95.x -= yymsp[-3].minor.yy149;}
#line 2752 "pikchr.c"
  yymsp[-3].minor.yy95 = yylhsminor.yy95;
        break;
      case 79: /* position ::= expr RIGHT OF position */
#line 641 "pikchr.y"
{yylhsminor.yy95=yymsp[0].minor.yy95; yylhsminor.yy95.x += yymsp[-3].minor.yy149;}
#line 2758 "pikchr.c"
  yymsp[-3].minor.yy95 = yylhsminor.yy95;
        break;
      case 80: /* position ::= expr ON HEADING EDGEPT OF position */
#line 643 "pikchr.y"
{yylhsminor.yy95 = pik_position_at_hdg(p,yymsp[-5].minor.yy149,&yymsp[-2].minor.yy0,yymsp[0].minor.yy95);}
#line 2764 "pikchr.c"
  yymsp[-5].minor.yy95 = yylhsminor.yy95;
        break;
      case 81: /* position ::= expr HEADING EDGEPT OF position */
#line 645 "pikchr.y"
{yylhsminor.yy95 = pik_position_at_hdg(p,yymsp[-4].minor.yy149,&yymsp[-2].minor.yy0,yymsp[0].minor.yy95);}
#line 2770 "pikchr.c"
  yymsp[-4].minor.yy95 = yylhsminor.yy95;
        break;
      case 82: /* position ::= expr EDGEPT OF position */
#line 647 "pikchr.y"
{yylhsminor.yy95 = pik_position_at_hdg(p,yymsp[-3].minor.yy149,&yymsp[-2].minor.yy0,yymsp[0].minor.yy95);}
#line 2776 "pikchr.c"
  yymsp[-3].minor.yy95 = yylhsminor.yy95;
        break;
      case 83: /* position ::= expr ON HEADING expr FROM position */
#line 649 "pikchr.y"
{yylhsminor.yy95 = pik_position_at_angle(p,yymsp[-5].minor.yy149,yymsp[-2].minor.yy149,yymsp[0].minor.yy95);}
#line 2782 "pikchr.c"
  yymsp[-5].minor.yy95 = yylhsminor.yy95;
        break;
      case 84: /* position ::= expr HEADING expr FROM position */
#line 651 "pikchr.y"
{yylhsminor.yy95 = pik_position_at_angle(p,yymsp[-4].minor.yy149,yymsp[-2].minor.yy149,yymsp[0].minor.yy95);}
#line 2788 "pikchr.c"
  yymsp[-4].minor.yy95 = yylhsminor.yy95;
        break;
      case 85: /* place ::= edge OF object */
#line 663 "pikchr.y"
{yylhsminor.yy95 = pik_place_of_elem(p,yymsp[0].minor.yy58,&yymsp[-2].minor.yy0);}
#line 2794 "pikchr.c"
  yymsp[-2].minor.yy95 = yylhsminor.yy95;
        break;
      case 86: /* place2 ::= object */
#line 664 "pikchr.y"
{yylhsminor.yy95 = pik_place_of_elem(p,yymsp[0].minor.yy58,0);}
#line 2800 "pikchr.c"
  yymsp[0].minor.yy95 = yylhsminor.yy95;
        break;
      case 87: /* place2 ::= object DOT_E edge */
#line 665 "pikchr.y"
{yylhsminor.yy95 = pik_place_of_elem(p,yymsp[-2].minor.yy58,&yymsp[0].minor.yy0);}
#line 2806 "pikchr.c"
  yymsp[-2].minor.yy95 = yylhsminor.yy95;
        break;
      case 88: /* place2 ::= NTH VERTEX OF object */
#line 666 "pikchr.y"
{yylhsminor.yy95 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy58);}
#line 2812 "pikchr.c"
  yymsp[-3].minor.yy95 = yylhsminor.yy95;
        break;
      case 89: /* object ::= nth */
#line 678 "pikchr.y"
{yylhsminor.yy58 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
#line 2818 "pikchr.c"
  yymsp[0].minor.yy58 = yylhsminor.yy58;
        break;
      case 90: /* object ::= nth OF|IN object */
#line 679 "pikchr.y"
{yylhsminor.yy58 = pik_find_nth(p,yymsp[0].minor.yy58,&yymsp[-2].minor.yy0);}
#line 2824 "pikchr.c"
  yymsp[-2].minor.yy58 = yylhsminor.yy58;
        break;
      case 91: /* objectname ::= PLACENAME */
#line 681 "pikchr.y"


















{yylhsminor.yy58 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
#line 2830 "pikchr.c"
  yymsp[0].minor.yy58 = yylhsminor.yy58;
        break;
      case 92: /* objectname ::= objectname DOT_U PLACENAME */
#line 683 "pikchr.y"
{yylhsminor.yy58 = pik_find_byname(p,yymsp[-2].minor.yy58,&yymsp[0].minor.yy0);}
#line 2836 "pikchr.c"
  yymsp[-2].minor.yy58 = yylhsminor.yy58;
        break;
      case 93: /* nth ::= NTH CLASSNAME */
#line 685 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
#line 2842 "pikchr.c"
  yymsp[-1].minor.yy0 = yylhsminor.yy0;
        break;
      case 94: /* nth ::= NTH LAST CLASSNAME */
#line 686 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
#line 2848 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 95: /* nth ::= LAST CLASSNAME */
#line 687 "pikchr.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
#line 2854 "pikchr.c"
        break;
      case 96: /* nth ::= LAST */
#line 688 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
#line 2859 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 97: /* nth ::= NTH LB RB */
#line 689 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
#line 2865 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 98: /* nth ::= NTH LAST LB RB */
#line 690 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
#line 2871 "pikchr.c"
  yymsp[-3].minor.yy0 = yylhsminor.yy0;
        break;
      case 99: /* nth ::= LAST LB RB */
#line 691 "pikchr.y"
{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
#line 2877 "pikchr.c"
        break;
      case 100: /* expr ::= expr PLUS expr */
#line 693 "pikchr.y"
{yylhsminor.yy149=yymsp[-2].minor.yy149+yymsp[0].minor.yy149;}
#line 2882 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 101: /* expr ::= expr MINUS expr */
#line 694 "pikchr.y"
{yylhsminor.yy149=yymsp[-2].minor.yy149-yymsp[0].minor.yy149;}
#line 2888 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 102: /* expr ::= expr STAR expr */
#line 695 "pikchr.y"
{yylhsminor.yy149=yymsp[-2].minor.yy149*yymsp[0].minor.yy149;}
#line 2894 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 103: /* expr ::= expr SLASH expr */
#line 696 "pikchr.y"
{
  if( yymsp[0].minor.yy149==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy149 = 0.0; }
  else{ yylhsminor.yy149 = yymsp[-2].minor.yy149/yymsp[0].minor.yy149; }
}
#line 2903 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 104: /* expr ::= MINUS expr */
#line 700 "pikchr.y"
{yymsp[-1].minor.yy149=-yymsp[0].minor.yy149;}
#line 2909 "pikchr.c"
        break;
      case 105: /* expr ::= PLUS expr */
#line 701 "pikchr.y"
{yymsp[-1].minor.yy149=yymsp[0].minor.yy149;}
#line 2914 "pikchr.c"
        break;
      case 106: /* expr ::= LP expr RP */
#line 702 "pikchr.y"
{yymsp[-2].minor.yy149=yymsp[-1].minor.yy149;}
#line 2919 "pikchr.c"
        break;
      case 107: /* expr ::= NUMBER */
#line 703 "pikchr.y"
{yylhsminor.yy149=pik_atof(p,&yymsp[0].minor.yy0);}
#line 2924 "pikchr.c"
  yymsp[0].minor.yy149 = yylhsminor.yy149;
        break;
      case 108: /* expr ::= ID */
#line 704 "pikchr.y"
{yylhsminor.yy149=pik_get_var(p,&yymsp[0].minor.yy0);}
#line 2930 "pikchr.c"
  yymsp[0].minor.yy149 = yylhsminor.yy149;
        break;
      case 109: /* expr ::= FUNC1 LP expr RP */
#line 705 "pikchr.y"
{yylhsminor.yy149 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy149,0.0);}
#line 2936 "pikchr.c"
  yymsp[-3].minor.yy149 = yylhsminor.yy149;
        break;
      case 110: /* expr ::= FUNC2 LP expr COMMA expr RP */
#line 706 "pikchr.y"
{yylhsminor.yy149 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy149,yymsp[-1].minor.yy149);}
#line 2942 "pikchr.c"
  yymsp[-5].minor.yy149 = yylhsminor.yy149;
        break;
      case 111: /* expr ::= place2 DOT_XY X */
#line 707 "pikchr.y"
{yylhsminor.yy149 = yymsp[-2].minor.yy95.x;}
#line 2948 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 112: /* expr ::= place2 DOT_XY Y */
#line 708 "pikchr.y"
{yylhsminor.yy149 = yymsp[-2].minor.yy95.y;}
#line 2954 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      case 113: /* expr ::= object DOT_L numproperty */
      case 114: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==114);
      case 115: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==115);
#line 709 "pikchr.y"
{yylhsminor.yy149=pik_property_of(p,yymsp[-2].minor.yy58,&yymsp[0].minor.yy0);}
#line 2962 "pikchr.c"
  yymsp[-2].minor.yy149 = yylhsminor.yy149;
        break;
      default:
      /* (116) lvalue ::= ID */ yytestcase(yyruleno==116);
      /* (117) lvalue ::= FILL */ yytestcase(yyruleno==117);
      /* (118) lvalue ::= COLOR */ yytestcase(yyruleno==118);
      /* (119) lvalue ::= THICKNESS */ yytestcase(yyruleno==119);
      /* (120) rvalue ::= expr */ yytestcase(yyruleno==120);
      /* (121) print ::= PRINT */ yytestcase(yyruleno==121);
      /* (122) prlist ::= pritem (OPTIMIZED OUT) */ assert(yyruleno!=122);
      /* (123) prlist ::= prlist prsep pritem */ yytestcase(yyruleno==123);
      /* (124) direction ::= UP */ yytestcase(yyruleno==124);
      /* (125) direction ::= DOWN */ yytestcase(yyruleno==125);
      /* (126) direction ::= LEFT */ yytestcase(yyruleno==126);
      /* (127) direction ::= RIGHT */ yytestcase(yyruleno==127);

      /* (128) attribute_list ::= alist */ yytestcase(yyruleno==128);
      /* (129) alist ::= */ yytestcase(yyruleno==129);
      /* (130) alist ::= alist attribute */ yytestcase(yyruleno==130);
      /* (131) attribute ::= boolproperty (OPTIMIZED OUT) */ assert(yyruleno!=131);
      /* (132) attribute ::= WITH withclause */ yytestcase(yyruleno==132);
      /* (133) go ::= GO */ yytestcase(yyruleno==133);
      /* (134) go ::= */ yytestcase(yyruleno==134);
      /* (135) even ::= UNTIL EVEN WITH */ yytestcase(yyruleno==135);
      /* (136) even ::= EVEN WITH */ yytestcase(yyruleno==136);
      /* (137) dashproperty ::= DOTTED */ yytestcase(yyruleno==137);
      /* (138) dashproperty ::= DASHED */ yytestcase(yyruleno==138);
      /* (139) colorproperty ::= FILL */ yytestcase(yyruleno==139);
      /* (140) colorproperty ::= COLOR */ yytestcase(yyruleno==140);
      /* (141) position ::= place */ yytestcase(yyruleno==141);
      /* (142) between ::= WAY BETWEEN */ yytestcase(yyruleno==142);
      /* (143) between ::= BETWEEN */ yytestcase(yyruleno==143);
      /* (144) between ::= OF THE WAY BETWEEN */ yytestcase(yyruleno==144);
      /* (145) place ::= place2 */ yytestcase(yyruleno==145);
      /* (146) edge ::= CENTER */ yytestcase(yyruleno==146);
      /* (147) edge ::= EDGEPT */ yytestcase(yyruleno==147);
      /* (148) edge ::= TOP */ yytestcase(yyruleno==148);
      /* (149) edge ::= BOTTOM */ yytestcase(yyruleno==149);
      /* (150) edge ::= START */ yytestcase(yyruleno==150);
      /* (151) edge ::= END */ yytestcase(yyruleno==151);
      /* (152) edge ::= RIGHT */ yytestcase(yyruleno==152);
      /* (153) edge ::= LEFT */ yytestcase(yyruleno==153);
      /* (154) object ::= objectname */ yytestcase(yyruleno==154);
        break;
/********** End reduce actions ************************************************/
  };
  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
  yygoto = yyRuleInfoLhs[yyruleno];
  yysize = yyRuleInfoNRhs[yyruleno];
  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);

  int yymajor,                   /* The major type of the error token */
  pik_parserTOKENTYPE yyminor         /* The minor type of the error token */
){
  pik_parserARG_FETCH
  pik_parserCTX_FETCH
#define TOKEN yyminor
/************ Begin %syntax_error code ****************************************/
#line 472 "pikchr.y"

  if( TOKEN.z && TOKEN.z[0] ){
    pik_error(p, &TOKEN, "syntax error");
  }else{
    pik_error(p, 0, "syntax error");
  }
#line 3071 "pikchr.c"
/************ End %syntax_error code ******************************************/
  pik_parserARG_STORE /* Suppress warning about unused %extra_argument variable */
  pik_parserCTX_STORE
}

/*
** The following is executed when the parser accepts

  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
  return yyFallback[iToken];
#else
  (void)iToken;
  return 0;
#endif
}
#line 714 "pikchr.y"



/* Chart of the 140 official HTML color names with their
** corresponding RGB value.
**
** Two new names "None" and "Off" are added with a value

}
/* Hack: Arcs are here rendered as quadratic Bezier curves rather
** than true arcs.  Multiple reasons: (1) the legacy-PIC parameters
** that control arcs are obscure and I could not figure out what they
** mean based on available documentation.  (2) Arcs are rarely used,
** and so do not seem that important.
*/
static void arcRender(Pik *p, PElem *pElem){

  PNum dx, dy;























  PPoint f, m, t;
  if( pElem->nPath<2 ) return;
  if( pElem->sw<=0.0 ) return;
  f = pElem->aPath[0];
  t = pElem->aPath[1];
  m.x = 0.5*(f.x+t.x);
  m.y = 0.5*(f.y+t.y);
  dx = t.x - f.x;
  dy = t.y - f.y;
  if( pElem->cw ){
    m.x -= 0.4*dy;
    m.y += 0.4*dx;
  }else{
    m.x += 0.4*dy;
    m.y -= 0.4*dx;
  }
  if( pElem->larrow ){
    pik_draw_arrowhead(p,&m,&f,pElem);
  }
  if( pElem->rarrow ){
    pik_draw_arrowhead(p,&m,&t,pElem);
  }
  pik_append_xy(p,"<path d=\"M", f.x, f.y);

/* Methods for the "text" class */
static void textInit(Pik *p, PElem *pElem){
  pik_value(p, "textwid",7,0);
  pik_value(p, "textht",6,0);
  pElem->sw = 0.0;
}







/* Methods for the "sublist" class */
static void sublistInit(Pik *p, PElem *pElem){
  PEList *pList = pElem->pSublist;
  int i;
  pik_bbox_init(&pElem->bbox);
  for(i=0; i<pList->n; i++){

*/
static const PClass aClass[] = {
   {  /* name */          "arc",
      /* isline */        1,
      /* eJust */         0,
      /* xInit */         arcInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       0,
      /* xFit */          0,
      /* xRender */       arcRender
   },
   {  /* name */          "arrow",
      /* isline */        1,
      /* eJust */         0,
      /* xInit */         arrowInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       lineOffset,
      /* xFit */          0,
      /* xRender */       splineRender 
   },
   {  /* name */          "box",
      /* isline */        0,
      /* eJust */         1,
      /* xInit */         boxInit,
      /* xNumProp */      0,

      /* xChop */         boxChop,
      /* xOffset */       boxOffset,
      /* xFit */          boxFit,
      /* xRender */       boxRender 
   },
   {  /* name */          "circle",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         circleInit,
      /* xNumProp */      circleNumProp,

      /* xChop */         circleChop,
      /* xOffset */       ellipseOffset,
      /* xFit */          circleFit,
      /* xRender */       circleRender 
   },
   {  /* name */          "cylinder",
      /* isline */        0,
      /* eJust */         1,
      /* xInit */         cylinderInit,
      /* xNumProp */      0,

      /* xChop */         boxChop,
      /* xOffset */       cylinderOffset,
      /* xFit */          0,
      /* xRender */       cylinderRender
   },
   {  /* name */          "dot",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         dotInit,
      /* xNumProp */      dotNumProp,

      /* xChop */         circleChop,
      /* xOffset */       ellipseOffset,
      /* xFit */          0,
      /* xRender */       dotRender 
   },
   {  /* name */          "ellipse",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         ellipseInit,
      /* xNumProp */      0,

      /* xChop */         ellipseChop,
      /* xOffset */       ellipseOffset,
      /* xFit */          0,
      /* xRender */       ellipseRender
   },
   {  /* name */          "file",
      /* isline */        0,
      /* eJust */         1,
      /* xInit */         fileInit,
      /* xNumProp */      0,

      /* xChop */         boxChop,
      /* xOffset */       fileOffset,
      /* xFit */          fileFit,
      /* xRender */       fileRender 
   },
   {  /* name */          "line",
      /* isline */        1,
      /* eJust */         0,
      /* xInit */         lineInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       lineOffset,
      /* xFit */          0,
      /* xRender */       splineRender
   },
   {  /* name */          "move",
      /* isline */        1,
      /* eJust */         0,
      /* xInit */         moveInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       0,
      /* xFit */          0,
      /* xRender */       moveRender
   },
   {  /* name */          "oval",
      /* isline */        0,
      /* eJust */         1,
      /* xInit */         ovalInit,
      /* xNumProp */      ovalNumProp,

      /* xChop */         boxChop,
      /* xOffset */       boxOffset,
      /* xFit */          ovalFit,
      /* xRender */       boxRender
   },
   {  /* name */          "spline",
      /* isline */        1,
      /* eJust */         0,
      /* xInit */         splineInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       lineOffset,
      /* xFit */          0,
      /* xRender */       splineRender
   },
   {  /* name */          "text",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         textInit,
      /* xNumProp */      0,

      /* xChop */         boxChop,
      /* xOffset */       boxOffset,
      /* xFit */          boxFit,
      /* xRender */       boxRender 
   },
};
static const PClass sublistClass = 
   {  /* name */          "[]",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         sublistInit,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       0,
      /* xFit */          0,
      /* xRender */       0 
   };
static const PClass noopClass = 
   {  /* name */          "noop",
      /* isline */        0,
      /* eJust */         0,
      /* xInit */         0,
      /* xNumProp */      0,

      /* xChop */         0,
      /* xOffset */       0,
      /* xFit */          0,
      /* xRender */       0
   };

/*
** Set a numeric property like "width 7" or "radius 200%".
**
** The rAbs term is an absolute value to add in.  rRel is
** a relative value by which to change the current value.
*/
void pik_set_numprop(Pik *p, PToken *pId, PNum rAbs, PNum rRel){
  PElem *pElem = p->cur;
  switch( pId->eType ){
    case T_HEIGHT:
      if( pik_param_ok(p, pElem, pId, A_HEIGHT, A_BOTTOM|A_TOP|A_AT) ) return;
      pElem->h = pElem->h*rRel + rAbs;
      break;
    case T_TOP:
      if( pik_param_ok(p, pElem, pId, A_TOP, A_BOTTOM|A_WIDTH|A_AT) ) return;
      pElem->top = rAbs;
      break;
    case T_BOTTOM:
      if( pik_param_ok(p, pElem, pId, A_BOTTOM, A_TOP|A_WIDTH|A_AT) ) return;
      pElem->bottom = rAbs;
      break;
    case T_WIDTH:
      if( pik_param_ok(p, pElem, pId, A_WIDTH, A_RIGHT|A_LEFT|A_AT) ) return;
      pElem->w = pElem->w*rRel + rAbs;
      break;
    case T_RIGHT:
      if( pik_param_ok(p, pElem, pId, A_RIGHT, A_WIDTH|A_LEFT|A_AT) ) return;
      pElem->right = rAbs;
      break;
    case T_LEFT:
      if( pik_param_ok(p, pElem, pId, A_LEFT, A_WIDTH|A_RIGHT|A_AT) ) return;
      pElem->left = rAbs;
      break;
    case T_RADIUS:
      if( pik_param_ok(p, pElem, pId, A_RADIUS, 0) ) return;
      pElem->rad = pElem->rad*rRel + rAbs;
      break;
    case T_DIAMETER:
      if( pik_param_ok(p, pElem, pId, A_RADIUS, 0) ) return;
      pElem->rad = pElem->rad*rRel + 0.5*rAbs; /* diam it 2x radius */
      break;
    case T_THICKNESS:
      if( pik_param_ok(p, pElem, pId, A_THICKNESS, 0) ) return;
      pElem->sw = pElem->sw*rRel + rAbs;
      break;













    case T_FILL:
      if( pik_param_ok(p, pElem, pId, A_FILL, 0) ) return;
      pElem->fill = rAbs;
      break;
    case T_COLOR:
      if( pik_param_ok(p, pElem, pId, A_COLOR, 0) ) return;
      pElem->color = rAbs;
      break;
  }
  if( pElem->type->xNumProp ){
    pElem->type->xNumProp(p, pElem, pId);
  }
  return;
}

  p->nTPath++;
  p->aTPath[n] = p->aTPath[n-1];
  p->mTPath = 0;
  return n;
}

/* Add a direction term to an element.  "up 0.5", or "left 3", or "down"
** or "down to 1.3".  Specific processing depends on parameters:
**
**   pVal==0   Add the default width or height to the coordinate.
**             Used to implement "down" and similar.
**
**   rel==0    Add or subtract *pVal to the path coordinate.  Used to
**             implement "up 0.5" and similar.
**
**   rel==1    Multiple 0.01*pVal with the width or height (as appropriate)
**             and add that to the coordinate.  Used for "left 50%" and
**             similar.
**
**   rel==2    Make the coordinate exactly equal to *pVal.  Used to
**             implement things like "down to 1.3".
*/
static void pik_add_direction(Pik *p, PToken *pDir, PNum *pVal, int rel){
  PElem *pElem = p->cur;
  int n;
  int dir;
  PNum scale = 1.0;
  if( !pElem->type->isLine ){
    if( pDir ){
      pik_error(p, pDir, "use with line-oriented objects only");
    }else{
      PToken x = pik_next_semantic_token(p, &pElem->errTok);
      pik_error(p, &x, "syntax error");
    }
    return;
  }
  if( pVal && rel==1 ){
    scale = *pVal/100;
    pVal = 0;
  }
  if( rel==2 ){
    pElem->mProp |= A_FROM;
  }
  n = p->nTPath - 1;
  if( p->thenFlag || p->mTPath==3 || n==0 ){
    n = pik_next_rpath(p, pDir);
    p->thenFlag = 0;
  }
  dir = pDir ? pDir->eCode : p->eDir;
  switch( dir ){
    case DIR_UP:
       if( p->mTPath & 2 ) n = pik_next_rpath(p, pDir);
       if( rel==2 ) p->aTPath[n].y = 0;
       p->aTPath[n].y += (pVal ? *pVal : pElem->h*scale);
       p->mTPath |= 2;
       break;
    case DIR_DOWN:
       if( p->mTPath & 2 ) n = pik_next_rpath(p, pDir);
       if( rel==2 ) p->aTPath[n].y = 0;
       p->aTPath[n].y -= (pVal ? *pVal : pElem->h*scale);
       p->mTPath |= 2;
       break;
    case DIR_RIGHT:
       if( p->mTPath & 1 ) n = pik_next_rpath(p, pDir);
       if( rel==2 ) p->aTPath[n].x = 0;
       p->aTPath[n].x += (pVal ? *pVal : pElem->w*scale);
       p->mTPath |= 1;
       break;
    case DIR_LEFT:
       if( p->mTPath & 1 ) n = pik_next_rpath(p, pDir);
       if( rel==2 ) p->aTPath[n].x = 0;
       p->aTPath[n].x -= (pVal ? *pVal : pElem->w*scale);
       p->mTPath |= 1;
       break;
  }
  pElem->outDir = dir;
}

/* Process a movement attribute of one of these forms:
**
**         pDist   pHdgKW  rHdg    pEdgept
**     GO distance HEADING angle
**     GO          HEADING angle
**     GO distance               compasspoint
**     GO                        compasspoint
*/
static void pik_move_hdg(
  Pik *p,              /* The Pikchr context */
  PNum *pDist,         /* Distance to move.  NULL means standard distance */
  PToken *pHeading,    /* "heading" keyword if present */
  PNum rHdg,           /* Angle argument to "heading" keyword */
  PToken *pEdgept,     /* EDGEPT keyword "ne", "sw", etc... */
  PToken *pErr         /* Token to use for error messages */
){
  PElem *pElem = p->cur;
  int n;
  PNum rDist;
  if( !pElem->type->isLine ){
    pik_error(p, pErr, "use with line-oriented objects only");
    return;
  }
  if( pDist ){
    rDist = *pDist;
  }else{
    rDist = pik_value(p, "linewid", 7, 0);
  }
  do{
    n = pik_next_rpath(p, pErr);
  }while( n<1 );
  if( pHeading ){
    if( rHdg<0.0 || rHdg>360.0 ){
      pik_error(p, pHeading, "headings should be between 0 and 360");
      return;

    assert( p->nTPath==2 );
    switch( pElem->inDir ){
      default:        p->aTPath[1].x += pElem->w; break;
      case DIR_DOWN:  p->aTPath[1].y -= pElem->h; break;
      case DIR_LEFT:  p->aTPath[1].x -= pElem->w; break;
      case DIR_UP:    p->aTPath[1].y += pElem->h; break;
    }
    if( strcmp(pElem->type->zName,"arc")==0 ){
      p->eDir = pElem->outDir = (pElem->inDir + (pElem->cw ? 1 : 3))%4;
      switch( pElem->outDir ){
        default:        p->aTPath[1].x += pElem->w; break;
        case DIR_DOWN:  p->aTPath[1].y -= pElem->h; break;
        case DIR_LEFT:  p->aTPath[1].x -= pElem->w; break;
        case DIR_UP:    p->aTPath[1].y += pElem->h; break;
      }
    }
  }



  /* Run "fit" on the text type automatically */

  if( pElem->type->xInit==textInit && pElem->nTxt ){
    pik_size_to_fit(p, &pElem->errTok);

  }

  /* Compute final bounding box, entry and exit points, center
  ** point (ptAt) and path for the element
  */
  pik_bbox_init(&pElem->bbox);
  if( pElem->type->isLine ){
    pElem->aPath = malloc( sizeof(PPoint)*p->nTPath );
    if( pElem->aPath==0 ){
      pik_error(p, 0, 0);
      pElem->nPath = 0;
    }else{
      pElem->nPath = p->nTPath;

    }
  }
  printf("</body></html>\n");
  return 0; 
}
#endif /* PIKCHR_SHELL */

#line 7026 "pikchr.c"