#include <ctype.h>
#include <math.h>
#include <assert.h>
#define count(X) (sizeof(X)/sizeof(X[0]))
#ifndef M_PI
# define M_PI 3.1415926535897932385
#endif





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 */

static void pik_append_xy(Pik*,const char*,PNum,PNum);
static void pik_append_dis(Pik*,const char*,PNum,const char*);
static void pik_append_arc(Pik*,PNum,PNum,PNum,PNum);
static void pik_append_clr(Pik*,const char*,PNum,const char*);
static void pik_append_style(Pik*,PElem*);
static void pik_append_txt(Pik*,PElem*, PBox*);
static void pik_draw_arrowhead(Pik*,PPoint*pFrom,PPoint*pTo,PElem*);
static void pik_chop(Pik*,PPoint*pFrom,PPoint*pTo,PNum);
static void pik_error(Pik*,PToken*,const char*);
static void pik_elist_free(Pik*,PEList*);
static void pik_elem_free(Pik*,PElem*);
static void pik_render(Pik*,PEList*);
static PEList *pik_elist_append(Pik*,PEList*,PElem*);
static PElem *pik_elem_new(Pik*,PToken*,PToken*,PEList*);
static void pik_set_direction(Pik*,int);
static void pik_elem_setname(Pik*,PElem*,PToken*);
static void pik_set_var(Pik*,PToken*,PNum,PToken*);
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*,PRel*);
static void pik_set_clrprop(Pik*,PToken*,PNum);
static void pik_set_dashed(Pik*,PToken*,PNum*);
static void pik_then(Pik*,PToken*,PElem*);

static void pik_bbox_init(PBox*);
static void pik_bbox_addbox(PBox*,PBox*);
static void pik_bbox_add_xy(PBox*,PNum,PNum);
static void pik_bbox_addellipse(PBox*,PNum x,PNum y,PNum rx,PNum ry);
static void pik_add_txt(Pik*,PToken*,int);
static int pik_text_length(const PToken *pToken);
static void pik_size_to_fit(Pik*,PToken*);
static int pik_text_position(Pik*,int,PToken*);
static PNum pik_property_of(Pik*,PElem*,PToken*);
static PNum pik_func(Pik*,PToken*,PNum,PNum);
static PPoint pik_position_between(Pik *p, PNum x, PPoint p1, PPoint p2);
static PPoint pik_position_at_angle(Pik *p, PNum dist, PNum r, PPoint pt);
static PPoint pik_position_at_hdg(Pik *p, PNum dist, PToken *pD, PPoint pt);
static void pik_same(Pik *p, PElem*, PToken*);
static PPoint pik_nth_vertex(Pik *p, PToken *pNth, PToken *pErr, PElem *pElem);
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 483 "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

    ** 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 472 "pikchr.y"
pik_elist_free(p,(yypminor->yy72));
#line 1660 "pikchr.c"
}
      break;
    case 95: /* element */
    case 96: /* unnamed_element */
    case 97: /* basetype */
{
#line 474 "pikchr.y"
pik_elem_free(p,(yypminor->yy254));
#line 1669 "pikchr.c"
}
      break;
/********* End destructor definitions *****************************************/
    default:  break;   /* If no destructor action specified: do nothing */
  }
}

#endif /* NDEBUG */
          return yy_action[j];
        }
      }
#endif /* YYWILDCARD */
      return yy_default[stateno];
    }else{
      assert( i>=0 && i<sizeof(yy_action)/sizeof(yy_action[0]) );
      return yy_action[i];
    }
  }while(1);
}

/*
** Find the appropriate action for a parser given the non-terminal

     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 505 "pikchr.y"

  pik_error(p, 0, "parser stack overflow");
#line 1890 "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

  **     { ... }           // User supplied code
  **  #line <lineno> <thisfile>
  **     break;
  */
/********** Begin reduce actions **********************************************/
        YYMINORTYPE yylhsminor;
      case 0: /* document ::= element_list */
#line 509 "pikchr.y"
{pik_render(p,yymsp[0].minor.yy72);}
#line 2361 "pikchr.c"
        break;
      case 1: /* element_list ::= element */
#line 512 "pikchr.y"
{ yylhsminor.yy72 = pik_elist_append(p,0,yymsp[0].minor.yy254); }
#line 2366 "pikchr.c"
  yymsp[0].minor.yy72 = yylhsminor.yy72;
        break;
      case 2: /* element_list ::= element_list EOL element */
#line 514 "pikchr.y"
{ yylhsminor.yy72 = pik_elist_append(p,yymsp[-2].minor.yy72,yymsp[0].minor.yy254); }
#line 2372 "pikchr.c"
  yymsp[-2].minor.yy72 = yylhsminor.yy72;
        break;
      case 3: /* element ::= */
#line 517 "pikchr.y"
{ yymsp[1].minor.yy254 = 0; }
#line 2378 "pikchr.c"
        break;
      case 4: /* element ::= direction */
#line 518 "pikchr.y"
{ pik_set_direction(p,yymsp[0].minor.yy0.eCode);  yylhsminor.yy254=0; }
#line 2383 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 5: /* element ::= lvalue ASSIGN rvalue */
#line 519 "pikchr.y"
{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy73,&yymsp[-1].minor.yy0); yylhsminor.yy254=0;}
#line 2389 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 6: /* element ::= PLACENAME COLON unnamed_element */
#line 521 "pikchr.y"
{ yylhsminor.yy254 = yymsp[0].minor.yy254;  pik_elem_setname(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0); }
#line 2395 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 7: /* element ::= PLACENAME COLON position */
#line 523 "pikchr.y"
{ yylhsminor.yy254 = pik_elem_new(p,0,0,0);
                 if(yylhsminor.yy254){ yylhsminor.yy254->ptAt = yymsp[0].minor.yy139; pik_elem_setname(p,yylhsminor.yy254,&yymsp[-2].minor.yy0); }}
#line 2402 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 8: /* element ::= unnamed_element */
#line 525 "pikchr.y"
{yylhsminor.yy254 = yymsp[0].minor.yy254;}
#line 2408 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 9: /* element ::= print prlist */
#line 526 "pikchr.y"
{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy254=0;}
#line 2414 "pikchr.c"
        break;
      case 10: /* element ::= ASSERT LP expr EQ expr RP */
#line 531 "pikchr.y"
{yymsp[-5].minor.yy254=pik_assert(p,yymsp[-3].minor.yy73,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy73);}
#line 2419 "pikchr.c"
        break;
      case 11: /* element ::= ASSERT LP place EQ place RP */
#line 533 "pikchr.y"
{yymsp[-5].minor.yy254=pik_place_assert(p,&yymsp[-3].minor.yy139,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy139);}
#line 2424 "pikchr.c"
        break;
      case 12: /* rvalue ::= PLACENAME */
#line 544 "pikchr.y"
{yylhsminor.yy73 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
#line 2429 "pikchr.c"
  yymsp[0].minor.yy73 = yylhsminor.yy73;
        break;
      case 13: /* pritem ::= FILL */
      case 14: /* pritem ::= COLOR */ yytestcase(yyruleno==14);
      case 15: /* pritem ::= THICKNESS */ yytestcase(yyruleno==15);
#line 549 "pikchr.y"
{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
#line 2437 "pikchr.c"
        break;
      case 16: /* pritem ::= rvalue */
#line 552 "pikchr.y"
{pik_append_num(p,"",yymsp[0].minor.yy73);}
#line 2442 "pikchr.c"
        break;
      case 17: /* pritem ::= STRING */
#line 553 "pikchr.y"
{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
#line 2447 "pikchr.c"
        break;
      case 18: /* prsep ::= COMMA */
#line 554 "pikchr.y"
{pik_append(p, " ", 1);}
#line 2452 "pikchr.c"
        break;
      case 19: /* unnamed_element ::= basetype attribute_list */
#line 557 "pikchr.y"
{yylhsminor.yy254 = yymsp[-1].minor.yy254; pik_after_adding_attributes(p,yylhsminor.yy254);}
#line 2457 "pikchr.c"
  yymsp[-1].minor.yy254 = yylhsminor.yy254;
        break;
      case 20: /* basetype ::= CLASSNAME */
#line 559 "pikchr.y"
{yylhsminor.yy254 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
#line 2463 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 21: /* basetype ::= STRING textposition */
#line 561 "pikchr.y"
{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy74; yylhsminor.yy254 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
#line 2469 "pikchr.c"
  yymsp[-1].minor.yy254 = yylhsminor.yy254;
        break;
      case 22: /* basetype ::= LB savelist element_list RB */
#line 563 "pikchr.y"
{ p->list = yymsp[-2].minor.yy72; yymsp[-3].minor.yy254 = pik_elem_new(p,0,0,yymsp[-1].minor.yy72); if(yymsp[-3].minor.yy254) yymsp[-3].minor.yy254->errTok = yymsp[0].minor.yy0; }
#line 2475 "pikchr.c"
        break;
      case 23: /* savelist ::= */
#line 568 "pikchr.y"
{yymsp[1].minor.yy72 = p->list; p->list = 0;}
#line 2480 "pikchr.c"
        break;
      case 24: /* relexpr ::= expr */
#line 575 "pikchr.y"
{yylhsminor.yy60.rAbs = yymsp[0].minor.yy73; yylhsminor.yy60.rRel = 0;}
#line 2485 "pikchr.c"
  yymsp[0].minor.yy60 = yylhsminor.yy60;
        break;
      case 25: /* relexpr ::= expr PERCENT */
#line 576 "pikchr.y"
{yylhsminor.yy60.rAbs = 0; yylhsminor.yy60.rRel = yymsp[-1].minor.yy73/100;}
#line 2491 "pikchr.c"
  yymsp[-1].minor.yy60 = yylhsminor.yy60;
        break;
      case 26: /* optrelexpr ::= */
#line 578 "pikchr.y"
{yymsp[1].minor.yy60.rAbs = 0; yymsp[1].minor.yy60.rRel = 1.0;}
#line 2497 "pikchr.c"
        break;
      case 27: /* attribute_list ::= relexpr alist */
#line 580 "pikchr.y"
{pik_add_direction(p,0,&yymsp[-1].minor.yy60);}
#line 2502 "pikchr.c"
        break;
      case 28: /* attribute ::= numproperty relexpr */
#line 584 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy60); }
#line 2507 "pikchr.c"
        break;
      case 29: /* attribute ::= dashproperty expr */
#line 585 "pikchr.y"
{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy73); }
#line 2512 "pikchr.c"
        break;
      case 30: /* attribute ::= dashproperty */
#line 586 "pikchr.y"
{ pik_set_dashed(p,&yymsp[0].minor.yy0,0);  }
#line 2517 "pikchr.c"
        break;
      case 31: /* attribute ::= colorproperty rvalue */
#line 587 "pikchr.y"
{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy73); }
#line 2522 "pikchr.c"
        break;
      case 32: /* attribute ::= go direction optrelexpr */
#line 588 "pikchr.y"
{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy60);}
#line 2527 "pikchr.c"
        break;
      case 33: /* attribute ::= go direction even position */
#line 589 "pikchr.y"
{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy139);}
#line 2532 "pikchr.c"
        break;
      case 34: /* attribute ::= CLOSE */
#line 590 "pikchr.y"
{ pik_close_path(p,&yymsp[0].minor.yy0); }
#line 2537 "pikchr.c"
        break;
      case 35: /* attribute ::= CHOP */
#line 591 "pikchr.y"
{ p->cur->bChop = 1; }
#line 2542 "pikchr.c"
        break;
      case 36: /* attribute ::= FROM position */
#line 592 "pikchr.y"
{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy139); }
#line 2547 "pikchr.c"
        break;
      case 37: /* attribute ::= TO position */
#line 593 "pikchr.y"
{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy139); }
#line 2552 "pikchr.c"
        break;
      case 38: /* attribute ::= THEN */
#line 594 "pikchr.y"
{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
#line 2557 "pikchr.c"
        break;
      case 39: /* attribute ::= THEN optrelexpr HEADING expr */
      case 41: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==41);
#line 596 "pikchr.y"
{pik_move_hdg(p,&yymsp[-2].minor.yy60,&yymsp[-1].minor.yy0,yymsp[0].minor.yy73,0,&yymsp[-3].minor.yy0);}
#line 2563 "pikchr.c"
        break;
      case 40: /* attribute ::= THEN optrelexpr EDGEPT */
      case 42: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==42);
#line 597 "pikchr.y"
{pik_move_hdg(p,&yymsp[-1].minor.yy60,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
#line 2569 "pikchr.c"
        break;
      case 43: /* attribute ::= AT position */
#line 602 "pikchr.y"
{ pik_set_at(p,0,&yymsp[0].minor.yy139,&yymsp[-1].minor.yy0); }
#line 2574 "pikchr.c"
        break;
      case 44: /* attribute ::= SAME */
#line 604 "pikchr.y"
{pik_same(p,0,&yymsp[0].minor.yy0);}
#line 2579 "pikchr.c"
        break;
      case 45: /* attribute ::= SAME AS object */
#line 605 "pikchr.y"
{pik_same(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2584 "pikchr.c"
        break;
      case 46: /* attribute ::= STRING textposition */
#line 606 "pikchr.y"
{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy74);}
#line 2589 "pikchr.c"
        break;
      case 47: /* attribute ::= FIT */
#line 607 "pikchr.y"
{pik_size_to_fit(p,&yymsp[0].minor.yy0); }
#line 2594 "pikchr.c"
        break;
      case 48: /* attribute ::= BEHIND object */
#line 608 "pikchr.y"
{pik_behind(p,yymsp[0].minor.yy254);}
#line 2599 "pikchr.c"
        break;
      case 49: /* withclause ::= DOT_E edge AT position */
      case 50: /* withclause ::= edge AT position */ yytestcase(yyruleno==50);
#line 616 "pikchr.y"
{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy139,&yymsp[-1].minor.yy0); }
#line 2605 "pikchr.c"
        break;
      case 51: /* numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
#line 620 "pikchr.y"
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
#line 2610 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 52: /* boolproperty ::= CW */
#line 631 "pikchr.y"
{p->cur->cw = 1;}
#line 2616 "pikchr.c"
        break;
      case 53: /* boolproperty ::= CCW */
#line 632 "pikchr.y"
{p->cur->cw = 0;}
#line 2621 "pikchr.c"
        break;
      case 54: /* boolproperty ::= LARROW */
#line 633 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=0; }
#line 2626 "pikchr.c"
        break;
      case 55: /* boolproperty ::= RARROW */
#line 634 "pikchr.y"
{p->cur->larrow=0; p->cur->rarrow=1; }
#line 2631 "pikchr.c"
        break;
      case 56: /* boolproperty ::= LRARROW */
#line 635 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=1; }
#line 2636 "pikchr.c"
        break;
      case 57: /* boolproperty ::= INVIS */
#line 636 "pikchr.y"
{p->cur->sw = 0.0;}
#line 2641 "pikchr.c"
        break;
      case 58: /* boolproperty ::= THICK */
#line 637 "pikchr.y"
{p->cur->sw *= 1.5;}
#line 2646 "pikchr.c"
        break;
      case 59: /* boolproperty ::= THIN */
#line 638 "pikchr.y"
{p->cur->sw *= 0.67;}
#line 2651 "pikchr.c"
        break;
      case 60: /* textposition ::= */
#line 640 "pikchr.y"
{yymsp[1].minor.yy74 = 0;}
#line 2656 "pikchr.c"
        break;
      case 61: /* textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
#line 643 "pikchr.y"
{yylhsminor.yy74 = pik_text_position(p,yymsp[-1].minor.yy74,&yymsp[0].minor.yy0);}
#line 2661 "pikchr.c"
  yymsp[-1].minor.yy74 = yylhsminor.yy74;
        break;
      case 62: /* position ::= expr COMMA expr */
#line 646 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-2].minor.yy73; yylhsminor.yy139.y=yymsp[0].minor.yy73;}
#line 2667 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 63: /* position ::= place PLUS expr COMMA expr */
#line 648 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-4].minor.yy139.x+yymsp[-2].minor.yy73; yylhsminor.yy139.y=yymsp[-4].minor.yy139.y+yymsp[0].minor.yy73;}
#line 2673 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 64: /* position ::= place MINUS expr COMMA expr */
#line 649 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-4].minor.yy139.x-yymsp[-2].minor.yy73; yylhsminor.yy139.y=yymsp[-4].minor.yy139.y-yymsp[0].minor.yy73;}
#line 2679 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 65: /* position ::= place PLUS LP expr COMMA expr RP */
#line 651 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-6].minor.yy139.x+yymsp[-3].minor.yy73; yylhsminor.yy139.y=yymsp[-6].minor.yy139.y+yymsp[-1].minor.yy73;}
#line 2685 "pikchr.c"
  yymsp[-6].minor.yy139 = yylhsminor.yy139;
        break;
      case 66: /* position ::= place MINUS LP expr COMMA expr RP */
#line 653 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-6].minor.yy139.x-yymsp[-3].minor.yy73; yylhsminor.yy139.y=yymsp[-6].minor.yy139.y-yymsp[-1].minor.yy73;}
#line 2691 "pikchr.c"
  yymsp[-6].minor.yy139 = yylhsminor.yy139;
        break;
      case 67: /* position ::= LP position COMMA position RP */
#line 654 "pikchr.y"
{yymsp[-4].minor.yy139.x=yymsp[-3].minor.yy139.x; yymsp[-4].minor.yy139.y=yymsp[-1].minor.yy139.y;}
#line 2697 "pikchr.c"
        break;
      case 68: /* position ::= LP position RP */
#line 655 "pikchr.y"
{yymsp[-2].minor.yy139=yymsp[-1].minor.yy139;}
#line 2702 "pikchr.c"
        break;
      case 69: /* position ::= expr between position AND position */
#line 657 "pikchr.y"
{yylhsminor.yy139 = pik_position_between(p,yymsp[-4].minor.yy73,yymsp[-2].minor.yy139,yymsp[0].minor.yy139);}
#line 2707 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 70: /* position ::= expr LT position COMMA position GT */
#line 659 "pikchr.y"
{yylhsminor.yy139 = pik_position_between(p,yymsp[-5].minor.yy73,yymsp[-3].minor.yy139,yymsp[-1].minor.yy139);}
#line 2713 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 71: /* position ::= expr ABOVE position */
#line 660 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.y += yymsp[-2].minor.yy73;}
#line 2719 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 72: /* position ::= expr BELOW position */
#line 661 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.y -= yymsp[-2].minor.yy73;}
#line 2725 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 73: /* position ::= expr LEFT OF position */
#line 662 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.x -= yymsp[-3].minor.yy73;}
#line 2731 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 74: /* position ::= expr RIGHT OF position */
#line 663 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.x += yymsp[-3].minor.yy73;}
#line 2737 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 75: /* position ::= expr ON HEADING EDGEPT OF position */
#line 665 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(p,yymsp[-5].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2743 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 76: /* position ::= expr HEADING EDGEPT OF position */
#line 667 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(p,yymsp[-4].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2749 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 77: /* position ::= expr EDGEPT OF position */
#line 669 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(p,yymsp[-3].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2755 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 78: /* position ::= expr ON HEADING expr FROM position */
#line 671 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_angle(p,yymsp[-5].minor.yy73,yymsp[-2].minor.yy73,yymsp[0].minor.yy139);}
#line 2761 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 79: /* position ::= expr HEADING expr FROM position */
#line 673 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_angle(p,yymsp[-4].minor.yy73,yymsp[-2].minor.yy73,yymsp[0].minor.yy139);}
#line 2767 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 80: /* place ::= edge OF object */
#line 685 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2773 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 81: /* place2 ::= object */
#line 686 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[0].minor.yy254,0);}
#line 2779 "pikchr.c"
  yymsp[0].minor.yy139 = yylhsminor.yy139;
        break;
      case 82: /* place2 ::= object DOT_E edge */
#line 687 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2785 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 83: /* place2 ::= NTH VERTEX OF object */
#line 688 "pikchr.y"
{yylhsminor.yy139 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy254);}
#line 2791 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 84: /* object ::= nth */
#line 700 "pikchr.y"
{yylhsminor.yy254 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
#line 2797 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 85: /* object ::= nth OF|IN object */
#line 701 "pikchr.y"
{yylhsminor.yy254 = pik_find_nth(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2803 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 86: /* objectname ::= PLACENAME */
#line 703 "pikchr.y"
{yylhsminor.yy254 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
#line 2809 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 87: /* objectname ::= objectname DOT_U PLACENAME */
#line 705 "pikchr.y"
{yylhsminor.yy254 = pik_find_byname(p,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2815 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 88: /* nth ::= NTH CLASSNAME */
#line 707 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
#line 2821 "pikchr.c"
  yymsp[-1].minor.yy0 = yylhsminor.yy0;
        break;
      case 89: /* nth ::= NTH LAST CLASSNAME */
#line 708 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
#line 2827 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 90: /* nth ::= LAST CLASSNAME */
#line 709 "pikchr.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
#line 2833 "pikchr.c"
        break;
      case 91: /* nth ::= LAST */
#line 710 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
#line 2838 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 92: /* nth ::= NTH LB RB */
#line 711 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
#line 2844 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 93: /* nth ::= NTH LAST LB RB */
#line 712 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
#line 2850 "pikchr.c"
  yymsp[-3].minor.yy0 = yylhsminor.yy0;
        break;
      case 94: /* nth ::= LAST LB RB */
#line 713 "pikchr.y"
{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
#line 2856 "pikchr.c"
        break;
      case 95: /* expr ::= expr PLUS expr */
#line 715 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73+yymsp[0].minor.yy73;}
#line 2861 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 96: /* expr ::= expr MINUS expr */
#line 716 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73-yymsp[0].minor.yy73;}
#line 2867 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 97: /* expr ::= expr STAR expr */
#line 717 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73*yymsp[0].minor.yy73;}
#line 2873 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 98: /* expr ::= expr SLASH expr */
#line 718 "pikchr.y"
{
  if( yymsp[0].minor.yy73==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy73 = 0.0; }
  else{ yylhsminor.yy73 = yymsp[-2].minor.yy73/yymsp[0].minor.yy73; }
}
#line 2882 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 99: /* expr ::= MINUS expr */
#line 722 "pikchr.y"
{yymsp[-1].minor.yy73=-yymsp[0].minor.yy73;}
#line 2888 "pikchr.c"
        break;
      case 100: /* expr ::= PLUS expr */
#line 723 "pikchr.y"
{yymsp[-1].minor.yy73=yymsp[0].minor.yy73;}
#line 2893 "pikchr.c"
        break;
      case 101: /* expr ::= LP expr RP */
#line 724 "pikchr.y"
{yymsp[-2].minor.yy73=yymsp[-1].minor.yy73;}
#line 2898 "pikchr.c"
        break;
      case 102: /* expr ::= NUMBER */
#line 725 "pikchr.y"
{yylhsminor.yy73=pik_atof(p,&yymsp[0].minor.yy0);}
#line 2903 "pikchr.c"
  yymsp[0].minor.yy73 = yylhsminor.yy73;
        break;
      case 103: /* expr ::= ID */
#line 726 "pikchr.y"
{yylhsminor.yy73=pik_get_var(p,&yymsp[0].minor.yy0);}
#line 2909 "pikchr.c"
  yymsp[0].minor.yy73 = yylhsminor.yy73;
        break;
      case 104: /* expr ::= FUNC1 LP expr RP */
#line 727 "pikchr.y"
{yylhsminor.yy73 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy73,0.0);}
#line 2915 "pikchr.c"
  yymsp[-3].minor.yy73 = yylhsminor.yy73;
        break;
      case 105: /* expr ::= FUNC2 LP expr COMMA expr RP */
#line 728 "pikchr.y"
{yylhsminor.yy73 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy73,yymsp[-1].minor.yy73);}
#line 2921 "pikchr.c"
  yymsp[-5].minor.yy73 = yylhsminor.yy73;
        break;
      case 106: /* expr ::= place2 DOT_XY X */
#line 729 "pikchr.y"
{yylhsminor.yy73 = yymsp[-2].minor.yy139.x;}
#line 2927 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 107: /* expr ::= place2 DOT_XY Y */
#line 730 "pikchr.y"
{yylhsminor.yy73 = yymsp[-2].minor.yy139.y;}
#line 2933 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 108: /* expr ::= object DOT_L numproperty */
      case 109: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==109);
      case 110: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==110);
#line 731 "pikchr.y"
{yylhsminor.yy73=pik_property_of(p,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2941 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      default:
      /* (111) lvalue ::= ID */ yytestcase(yyruleno==111);
      /* (112) lvalue ::= FILL */ yytestcase(yyruleno==112);
      /* (113) lvalue ::= COLOR */ yytestcase(yyruleno==113);
      /* (114) lvalue ::= THICKNESS */ yytestcase(yyruleno==114);

  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 498 "pikchr.y"

  if( TOKEN.z && TOKEN.z[0] ){
    pik_error(p, &TOKEN, "syntax error");
  }else{
    pik_error(p, 0, "syntax error");
  }

#line 3051 "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 736 "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

/* Methods for the "box" class */
static void boxInit(Pik *p, PElem *pElem){
  pElem->w = pik_value(p, "boxwid",6,0);
  pElem->h = pik_value(p, "boxht",5,0);
  pElem->rad = pik_value(p, "boxrad",6,0);
}
/* Translate the CP_START and CP_END reference points into the
** corresponding compass point based on the direction.
*/
static int boxTranslateEndPoint(PElem *pElem, int cp){
#if 0
  if( cp==CP_START ){
    switch( pElem->inDir ){
      case DIR_RIGHT: cp = CP_W;  break;
      case DIR_DOWN:  cp = CP_N;  break;
      case DIR_LEFT:  cp = CP_E;  break;
      case DIR_UP:    cp = CP_S;  break;
    }
  }else if( cp==CP_END ){
    switch( pElem->outDir ){
      case DIR_RIGHT: cp = CP_E;  break;
      case DIR_DOWN:  cp = CP_S;  break;
      case DIR_LEFT:  cp = CP_W;  break;
      case DIR_UP:    cp = CP_N;  break;
    }
  }
#endif
  return cp;
}
/* Return offset from the center of the box to the compass point 
** given by parameter cp */
static PPoint boxOffset(Pik *p, PElem *pElem, int cp){
  PPoint pt;
  PNum w2 = 0.5*pElem->w;
  PNum h2 = 0.5*pElem->h;
  PNum rad = pElem->rad;
  PNum rx;
  if( rad<=0.0 ){
    rx = 0.0;
  }else{
    if( rad>w2 ) rad = w2;
    if( rad>h2 ) rad = h2;
    rx = 0.29289321881345252392*rad;
  }
  pt.x = pt.y = 0.0;
  switch( boxTranslateEndPoint(pElem,cp) ){
    case CP_C:   pt.x = 0.0;      pt.y = 0.0;    break;
    case CP_N:   pt.x = 0.0;      pt.y = h2;     break;
    case CP_NE:  pt.x = w2-rx;    pt.y = h2-rx;  break;
    case CP_E:   pt.x = w2;       pt.y = 0.0;    break;
    case CP_SE:  pt.x = w2-rx;    pt.y = rx-h2;  break;
    case CP_S:   pt.x = 0.0;      pt.y = -h2;    break;
    case CP_SW:  pt.x = rx-w2;    pt.y = rx-h2;  break;
    case CP_W:   pt.x = -w2;      pt.y = 0.0;    break;
    case CP_NW:  pt.x = rx-w2;    pt.y = h2-rx;  break;
  }

  return pt;
}
static PPoint boxChop(Pik *p, PElem *pElem, PPoint *pPt){
  PNum dx, dy;
  int cp = CP_C;
  PPoint chop = pElem->ptAt;
  if( pElem->w<=0.0 ) return chop;

  chop.x += pElem->ptAt.x;
  chop.y += pElem->ptAt.y;
  return chop;
}
static void boxFit(Pik *p, PElem *pElem, PNum w, PNum h){
  if( w>0 ) pElem->w = w;
  if( h>0 ) pElem->h = h;

}
static void boxRender(Pik *p, PElem *pElem){
  PNum w2 = 0.5*pElem->w;
  PNum h2 = 0.5*pElem->h;
  PNum rad = pElem->rad;
  PPoint pt = pElem->ptAt;
  if( pElem->sw>0.0 ){

      pElem->rad = 0.5*pElem->w;
      break;
    case T_HEIGHT:
      pElem->w = pElem->h;
      pElem->rad = 0.5*pElem->w;
      break;
  }

}
static PPoint circleChop(Pik *p, PElem *pElem, PPoint *pPt){
  PPoint chop;
  PNum dx = pPt->x - pElem->ptAt.x;
  PNum dy = pPt->y - pElem->ptAt.y;
  PNum dist = hypot(dx,dy);
  if( dist<pElem->rad ) return pElem->ptAt;
  chop.x = pElem->ptAt.x + dx*pElem->rad/dist;
  chop.y = pElem->ptAt.y + dy*pElem->rad/dist;

  return chop;
}
static void circleFit(Pik *p, PElem *pElem, PNum w, PNum h){
  PNum mx = 0.0;
  if( w>0 ) mx = w;
  if( h>mx ) mx = h;
  if( (w*w + h*h) > mx*mx ){
    mx = hypot(w,h);
  }
  if( mx>0.0 ){
    pElem->rad = 0.5*mx;
    pElem->w = pElem->h = mx;
  }

}

static void circleRender(Pik *p, PElem *pElem){
  PNum r = pElem->rad;
  PPoint pt = pElem->ptAt;
  if( pElem->sw>0.0 ){
    pik_append_x(p,"<circle cx=\"", pt.x, "\"");

  pik_append_txt(p, pElem, 0);
}
static PPoint cylinderOffset(Pik *p, PElem *pElem, int cp){
  PPoint pt;
  PNum w2 = pElem->w*0.5;
  PNum h1 = pElem->h*0.5;
  PNum h2 = h1 - pElem->rad;
  switch( boxTranslateEndPoint(pElem,cp) ){
    case CP_C:   pt.x = 0.0;   pt.y = 0.0;    break;
    case CP_N:   pt.x = 0.0;   pt.y = h1;     break;
    case CP_NE:  pt.x = w2;    pt.y = h2;     break;
    case CP_E:   pt.x = w2;    pt.y = 0.0;    break;
    case CP_SE:  pt.x = w2;    pt.y = -h2;    break;
    case CP_S:   pt.x = 0.0;   pt.y = -h1;    break;
    case CP_SW:  pt.x = -w2;   pt.y = -h2;    break;
    case CP_W:   pt.x = -w2;   pt.y = 0.0;    break;
    case CP_NW:  pt.x = -w2;   pt.y = h2;     break;
  }

  return pt;
}

/* Methods for the "dot" class */
static void dotInit(Pik *p, PElem *pElem){
  pElem->rad = pik_value(p, "dotrad",6,0);
  pElem->h = pElem->w = pElem->rad*6;
  pElem->fill = pElem->color;
}
static void dotNumProp(Pik *p, PElem *pElem, PToken *pId){
  switch( pId->eType ){
    case T_COLOR:
      pElem->fill = pElem->color;
      break;
    case T_FILL:
      pElem->color = pElem->fill;
      break;
  }

}
static void dotCheck(Pik *p, PElem *pElem){
  pElem->w = pElem->h = 0;
  pik_bbox_addellipse(&pElem->bbox, pElem->ptAt.x, pElem->ptAt.y,
                       pElem->rad, pElem->rad);

}
static PPoint dotOffset(Pik *p, PElem *pElem, int cp){
  PPoint zero;
  zero.x = zero.y = 0;



  return zero;
}
static void dotRender(Pik *p, PElem *pElem){
  PNum r = pElem->rad;
  PPoint pt = pElem->ptAt;
  if( pElem->sw>0.0 ){
    pik_append_x(p,"<circle cx=\"", pt.x, "\"");

  if( pElem->h<=0.0 ) return pElem->ptAt;
  s = pElem->h/pElem->w;
  dq = dx*s;
  dist = hypot(dq,dy);
  if( dist<pElem->h ) return pElem->ptAt;
  chop.x = pElem->ptAt.x + 0.5*dq*pElem->h/(dist*s);
  chop.y = pElem->ptAt.y + 0.5*dy*pElem->h/dist;

  return chop;
}
static PPoint ellipseOffset(Pik *p, PElem *pElem, int cp){
  PPoint pt;
  PNum w = pElem->w*0.5;
  PNum w2 = w*0.70710678118654747608;
  PNum h = pElem->h*0.5;
  PNum h2 = h*0.70710678118654747608;
  switch( boxTranslateEndPoint(pElem,cp) ){
    case CP_C:   pt.x = 0.0;   pt.y = 0.0;    break;
    case CP_N:   pt.x = 0.0;   pt.y = h;      break;
    case CP_NE:  pt.x = w2;    pt.y = h2;     break;
    case CP_E:   pt.x = w;     pt.y = 0.0;    break;
    case CP_SE:  pt.x = w2;    pt.y = -h2;    break;
    case CP_S:   pt.x = 0.0;   pt.y = -h;     break;
    case CP_SW:  pt.x = -w2;   pt.y = -h2;    break;
    case CP_W:   pt.x = -w;    pt.y = 0.0;    break;
    case CP_NW:  pt.x = -w2;   pt.y = h2;     break;
  }

  return pt;
}
static void ellipseRender(Pik *p, PElem *pElem){
  PNum w = pElem->w;
  PNum h = pElem->h;
  PPoint pt = pElem->ptAt;
  if( pElem->sw>0.0 ){

  PNum h2 = 0.5*pElem->h;
  PNum rx = pElem->rad;
  PNum mn = w2<h2 ? w2 : h2;
  if( rx>mn ) rx = mn;
  if( rx<mn*0.25 ) rx = mn*0.25;
  pt.x = pt.y = 0.0;
  rx *= 0.5;
  switch( boxTranslateEndPoint(pElem,cp) ){
    case CP_C:   pt.x = 0.0;      pt.y = 0.0;    break;
    case CP_N:   pt.x = 0.0;      pt.y = h2;     break;
    case CP_NE:  pt.x = w2-rx;    pt.y = h2-rx;  break;
    case CP_E:   pt.x = w2;       pt.y = 0.0;    break;
    case CP_SE:  pt.x = w2;       pt.y = -h2;    break;
    case CP_S:   pt.x = 0.0;      pt.y = -h2;    break;
    case CP_SW:  pt.x = -w2;      pt.y = -h2;    break;
    case CP_W:   pt.x = -w2;      pt.y = 0.0;    break;
    case CP_NW:  pt.x = -w2;      pt.y = h2;     break;
  }

  return pt;
}
static void fileFit(Pik *p, PElem *pElem, PNum w, PNum h){
  if( w>0 ) pElem->w = w;
  if( h>0 ) pElem->h = h + 2*pElem->rad;

}
static void fileRender(Pik *p, PElem *pElem){
  PNum w2 = 0.5*pElem->w;
  PNum h2 = 0.5*pElem->h;
  PNum rad = pElem->rad;
  PPoint pt = pElem->ptAt;
  PNum mn = w2<h2 ? w2 : h2;

static void lineInit(Pik *p, PElem *pElem){
  pElem->w = pik_value(p, "linewid",7,0);
  pElem->h = pik_value(p, "lineht",6,0);
  pElem->rad = pik_value(p, "linerad",7,0);
  pElem->fill = -1.0;
}
static PPoint lineOffset(Pik *p, PElem *pElem, int cp){

#if 0
  /* In legacy PIC, the .center of an unclosed line is half way between
  ** its .start and .end. */
  if( cp==CP_C && !pElem->bClose ){
    PPoint out;
    out.x = 0.5*(pElem->ptEnter.x + pElem->ptExit.x) - pElem->ptAt.x;
    out.y = 0.5*(pElem->ptEnter.x + pElem->ptExit.y) - pElem->ptAt.y;
    return out;
  }
#endif

  return boxOffset(p,pElem,cp);
}
static void lineRender(Pik *p, PElem *pElem){
  int i;
  if( pElem->sw>0.0 ){
    const char *z = "<path d=\"M";
    int n = pElem->nPath;

  pElem->h = pElem->w;
  pElem->fill = -1.0;
  pElem->color = -1.0;
  pElem->sw = -1.0;
}
static void moveRender(Pik *p, PElem *pElem){
  /* No-op */


}

/* Methods for the "oval" class */
static void ovalInit(Pik *p, PElem *pElem){
  pElem->h = pik_value(p, "ovalht",6,0);
  pElem->w = pik_value(p, "ovalwid",7,0);
  pElem->rad = 0.5*(pElem->h<pElem->w?pElem->h:pElem->w);
}
static void ovalNumProp(Pik *p, PElem *pElem, PToken *pId){


  /* Always adjust the radius to be half of the smaller of
  ** the width and height. */
  pElem->rad = 0.5*(pElem->h<pElem->w?pElem->h:pElem->w);
}
static void ovalFit(Pik *p, PElem *pElem, PNum w, PNum h){

  if( w>0 ) pElem->w = w;
  if( h>0 ) pElem->h = h;
  if( pElem->w<pElem->h ) pElem->w = pElem->h;
}

  return boxOffset(p, pElem, cp);
}

/* 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++){
    pik_bbox_addbox(&pElem->bbox, &pList->a[i]->bbox);
  }
  pElem->w = pElem->bbox.ne.x - pElem->bbox.sw.x;
  pElem->h = pElem->bbox.ne.y - pElem->bbox.sw.y;
  pElem->ptAt.x = 0.5*(pElem->bbox.ne.x + pElem->bbox.sw.x);

   };


/*
** Reduce the length of the line segment by amt (if possible) by
** modifying the location of *t.
*/
static void pik_chop(Pik *p, PPoint *f, PPoint *t, PNum amt){
  PNum dx = t->x - f->x;
  PNum dy = t->y - f->y;
  PNum dist = hypot(dx,dy);
  PNum r;
  if( dist<=amt ){
    *t = *f;
    return;

  ddy = w*dx;
  bx = f->x + e1*dx;
  by = f->y + e1*dy;
  pik_append_xy(p,"<polygon points=\"", t->x, t->y);
  pik_append_xy(p," ",bx-ddx, by-ddy);
  pik_append_xy(p," ",bx+ddx, by+ddy);
  pik_append_clr(p,"\" style=\"fill:",pElem->color,"\"/>\n");
  pik_chop(p,f,t,h/2);
}

/*
** Compute the relative offset to an edge location from the reference for a
** an element.
*/
static PPoint pik_elem_offset(Pik *p, PElem *pElem, int cp){

/*
** Compute the vertical locations for all text items in the
** element pElem.  In other words, set every pElem->aTxt[*].eCode
** value to contain exactly one of: TP_ABOVE2, TP_ABOVE, TP_CENTER,
** TP_BELOW, or TP_BELOW2 is set.
*/
static void pik_txt_vertical_layout(Pik *p, PElem *pElem){
  int n, i;
  PToken *aTxt;
  n = pElem->nTxt;
  if( n==0 ) return;
  aTxt = pElem->aTxt;
  if( n==1 ){
    if( (aTxt[0].eCode & TP_VMASK)==0 ){

  int hasCenter = 0;

  if( p->nErr ) return;
  if( pElem->nTxt==0 ) return;
  aTxt = pElem->aTxt;
  dy = 0.5*p->charHeight;
  n = pElem->nTxt;
  pik_txt_vertical_layout(p, pElem);
  x = pElem->ptAt.x;
  for(i=0; i<n; i++){
    if( (pElem->aTxt[i].eCode & TP_CENTER)!=0 ) hasCenter = 1;
  }
  if( hasCenter ){
    dy2 = dy;
  }else if( pElem->type->isLine ){

  for(j=i; j>0 && p->zIn[j-1]!='\n'; j--){}
  iCol = i - j;
  for(nExtra=0; (c = p->zIn[i+nExtra])!=0 && c!='\n'; nExtra++){}
  pik_append(p, "<div><pre>\n", -1);
  pik_append_text(p, p->zIn, i+nExtra, 3);
  pik_append(p, "\n", 1);
  for(i=0; i<iCol; i++){ pik_append(p, " ", 1); }
  for(i=0; i<pErr->n; i++) pik_append(p, "^", 1);
  pik_append(p, "\nERROR: ", -1);
  pik_append_text(p, zMsg, -1, 0);
  pik_append(p, "\n", 1);
  pik_append(p, "\n</pre></div>\n", -1);
}

/*

**   (2)    Same as (1) but followed by a unit: "cm", "mm", "in",
**          "px", "pt", or "pc".
**   (3)    Hex integers: 0x000000
**
** This routine returns the result in inches.  If a different unit
** is specified, the conversion happens automatically.
*/
PNum pik_atof(Pik *p, PToken *num){
  char *endptr;
  PNum ans;
  if( num->n>=3 && num->z[0]=='0' && (num->z[1]=='x'||num->z[1]=='X') ){
    return (PNum)strtol(num->z+2, 0, 16);
  }
  ans = strtod(num->z, &endptr);
  if( (int)(endptr - num->z)==num->n-2 ){
    char c1 = endptr[0];
    char c2 = endptr[1];
    if( c1=='c' && c2=='m' ){
      ans /= 2.54;
    }else if( c1=='m' && c2=='m' ){
      ans /= 25.4;
    }else if( c1=='p' && c2=='x' ){

  pNew->ptExit = pNew->ptEnter = pNew->ptAt;
  return pNew;
}

/*
** Set the output direction and exit point for an element.
*/
static void pik_elem_set_exit(Pik *p, PElem *pElem, int eDir){
  assert( ValidDir(eDir) );
  pElem->outDir = eDir;
  if( !pElem->type->isLine || pElem->bClose ){
    pElem->ptExit = pElem->ptAt;
    switch( pElem->outDir ){
      default:         pElem->ptExit.x += pElem->w*0.5;  break;
      case DIR_LEFT:   pElem->ptExit.x -= pElem->w*0.5;  break;

  **      arrow; circle; down; arrow
  **
  ** You can make pikchr render the above exactly like PIC
  ** by deleting the following three lines.  But I (drh) think
  ** it works better with those lines in place.
  */
  if( p->list && p->list->n ){
    pik_elem_set_exit(p, p->list->a[p->list->n-1], eDir);
  }
}

/* Move all coordinates contained within an element (and within its
** substructure) by dx, dy
*/
static void pik_elem_move(PElem *pElem, PNum dx, PNum dy){

  }
}

/*
** If the current path information came from a "same" or "same as"
** reset it.
*/
static void pik_reset_samepath(Pik *p, PElem *pElem){
  if( p->samePath ){
    p->samePath = 0;
    p->nTPath = 1;
  }
}

  p->thenFlag = 1;
}

/* Advance to the next entry in p->aTPath.  Return its index.
*/
static int pik_next_rpath(Pik *p, PToken *pErr){
  int n = p->nTPath - 1;
  if( n+1>=count(p->aTPath) ){
    pik_error(0, pErr, "too many path elements");
    return n;
  }
  n++;
  p->nTPath++;
  p->aTPath[n] = p->aTPath[n-1];
  p->mTPath = 0;

  PElem *pElem = p->cur;
  int n;
  int dir;
  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;
  }
  pik_reset_samepath(p, pElem);
  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 ){

  PElem *pElem = p->cur;
  int n;
  PNum rDist = pDist->rAbs + pik_value(p,"linewid",7,0)*pDist->rRel;
  if( !pElem->type->isLine ){
    pik_error(p, pErr, "use with line-oriented objects only");
    return;
  }
  pik_reset_samepath(p, pElem);
  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;

static void pik_evenwith(Pik *p, PToken *pDir, PPoint *pPlace){
  PElem *pElem = p->cur;
  int n;
  if( !pElem->type->isLine ){
    pik_error(p, pDir, "use with line-oriented objects only");
    return;
  }
  pik_reset_samepath(p, pElem);
  n = p->nTPath - 1;
  if( p->thenFlag || p->mTPath==3 || n==0 ){
    n = pik_next_rpath(p, pDir);
    p->thenFlag = 0;
  }
  switch( pDir->eCode ){
    case DIR_DOWN:

    return;
  }
  if( pElem->mProp & A_AT ){
    pik_error(p, pErrTok, "location fixed by prior \"at\"");
    return;
  }
  pElem->mProp |= A_AT;
  pElem->eWith = pEdge ? boxTranslateEndPoint(pElem,pEdge->eEdge) : CP_C;
  pElem->with = *pAt;
}

/*
** Try to add a text attribute to an element
*/
static void pik_add_txt(Pik *p, PToken *pTxt, int iPos){
  PElem *pElem = p->cur;
  PToken *pT;
  if( pElem->nTxt >= count(pElem->aTxt) ){
    pik_error(p, pTxt, "too many text terms");
    return;
  }
  pT = &pElem->aTxt[pElem->nTxt++];
  *pT = *pTxt;
  pT->eCode = iPos;
}

/* Merge "text-position" flags
*/
static int pik_text_position(Pik *p, int iPrev, PToken *pFlag){
  int iRes = iPrev;
  switch( pFlag->eType ){
    case T_LJUST:    iRes = (iRes&~TP_JMASK) | TP_LJUST;  break;
    case T_RJUST:    iRes = (iRes&~TP_JMASK) | TP_RJUST;  break;
    case T_ABOVE:    iRes = (iRes&~TP_VMASK) | TP_ABOVE;  break;
    case T_CENTER:   iRes = (iRes&~TP_VMASK) | TP_CENTER; break;
    case T_BELOW:    iRes = (iRes&~TP_VMASK) | TP_BELOW;  break;

    return;
  }
  if( pElem->type->xFit==0 ) return;
  if( (pElem->mProp & A_HEIGHT)==0 ){
    int hasCenter = 0;
    int hasSingleStack = 0;
    int hasDoubleStack = 0;
    pik_txt_vertical_layout(p, pElem);
    for(i=0; i<pElem->nTxt; i++){
      if( pElem->aTxt[i].eCode & TP_CENTER ){
        hasCenter = 1;
      }else if( pElem->aTxt[i].eCode & (TP_ABOVE2|TP_BELOW2) ){
        hasDoubleStack = 1;
      }else if( pElem->aTxt[i].eCode & (TP_ABOVE|TP_BELOW) ){
        hasSingleStack = 1;

*/
static PNum pik_lookup_color(Pik *p, PToken *pId){
  int first, last, mid, c = 0;
  first = 0;
  last = count(aColor)-1;
  while( first<=last ){
    const char *zClr;
    int c1, c2, i;

    mid = (first+last)/2;
    zClr = aColor[mid].zName;
    for(i=0; i<pId->n; i++){
      c1 = zClr[i]&0x7f;
      if( isupper(c1) ) c1 = tolower(c1);
      c2 = pId->z[i]&0x7f;
      if( isupper(c2) ) c2 = tolower(c2);

  }else{
    return pElem->ptExit;
  }
}

/* Do a linear interpolation of two positions.
*/
static PPoint pik_position_between(Pik *p, PNum x, PPoint p1, PPoint p2){
  PPoint out;
  if( x<0.0 ) x = 0.0;
  if( x>1.0 ) x = 1.0;
  out.x = p2.x*x + p1.x*(1.0 - x);
  out.y = p2.y*x + p1.y*(1.0 - x);
  return out;
}

/* Compute the position that is dist away from pt at an heading angle of r
**
** The angle is a compass heading in degrees.  North is 0 (or 360).
** East is 90.  South is 180.  West is 270.  And so forth.
*/
static PPoint pik_position_at_angle(Pik *p, PNum dist, PNum r, PPoint pt){
  r *= 0.017453292519943295769;  /* degrees to radians */
  pt.x += dist*sin(r);
  pt.y += dist*cos(r);
  return pt;
}

/* Compute the position that is dist away at a compass point
*/
static PPoint pik_position_at_hdg(Pik *p, PNum dist, PToken *pD, PPoint pt){
  return pik_position_at_angle(p, dist, pik_hdg_angle[pD->eEdge], pt);
}

/* Return the coordinates for the n-th vertex of a line.
*/
static PPoint pik_nth_vertex(Pik *p, PToken *pNth, PToken *pErr, PElem *pObj){
  static const PPoint zero;
  int n;

    return zero;
  }
  return pObj->aPath[n-1];
}

/* Return the value of a property of an object.
*/
static PNum pik_property_of(Pik *p, PElem *pElem, PToken *pProp){
  PNum v = 0.0;
  switch( pProp->eType ){
    case T_HEIGHT:    v = pElem->h;            break;
    case T_WIDTH:     v = pElem->w;            break;
    case T_RADIUS:    v = pElem->rad;          break;
    case T_DIAMETER:  v = pElem->rad*2.0;      break;
    case T_THICKNESS: v = pElem->sw;           break;

  /* Compute final bounding box, entry and exit points, center
  ** point (ptAt) and path for the element
  */
  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;
      for(i=0; i<p->nTPath; i++){
        pElem->aPath[i] = p->aTPath[i];
        pik_bbox_add_xy(&pElem->bbox, pElem->aPath[i].x, pElem->aPath[i].y);
      }
    }

    /* "chop" processing:
    ** If the line goes to the center of an object with an
    ** xChop method, then use the xChop method to trim the line.
    */
    if( pElem->bChop && pElem->nPath>=2 ){
      int n = pElem->nPath;
      pik_autochop(p, &pElem->aPath[n-2], &pElem->aPath[n-1]);
      pik_autochop(p, &pElem->aPath[1], &pElem->aPath[0]);
    }

    pElem->ptEnter = p->aTPath[0];
    pElem->ptExit = p->aTPath[p->nTPath-1];

    /* Compute the center of the line based on the bounding box over
    ** the vertexes */



    pElem->ptAt.x = (pElem->bbox.ne.x + pElem->bbox.sw.x)/2.0;
    pElem->ptAt.y = (pElem->bbox.ne.y + pElem->bbox.sw.y)/2.0;

    /* Reset the width and height of the object to be the width and height
    ** of the bounding box over vertexes */
    pElem->w = pElem->bbox.ne.x - pElem->bbox.sw.x;
    pElem->h = pElem->bbox.ne.y - pElem->bbox.sw.y;

    /* If this is a polygon (if it has the "close" attribute), then
    ** adjust the exit point */
    if( pElem->bClose ){
      /* "closed" lines work like block objects */
      pik_elem_set_exit(p, pElem, pElem->inDir);
    }else{
      /* For an open line, the "center" is half way between
      ** the .start and the .end */
    }
  }else{
    PNum w2 = pElem->w/2.0;
    PNum h2 = pElem->h/2.0;

          }
          if( c2<'0' || c>'9' ){
            /* This is not an exp */
            i -= 2;
          }else{
            i++;
            isInt = 0;
            while( (c = z[i])>=0 && c<='9' ){ i++; }
          }
        }
        c2 = c ? z[i+1] : 0;
        if( isInt ){
          if( (c=='t' && c2=='h')
           || (c=='r' && c2=='d')
           || (c=='n' && c2=='d')

  }
}

/*
** Return a pointer to the next non-whitespace token after pThis.
** This is used to help form error messages.
*/
static PToken pik_next_semantic_token(Pik *p, PToken *pThis){
  PToken x;
  int sz;
  int i = pThis->n;
  memset(&x, 0, sizeof(x));
  x.z = pThis->z;
  while(1){
    x.z = pThis->z + i;

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

#line 7085 "pikchr.c"