Fossil

timeline-arrowheads:        0
timeline-circle-nodes:      1
timeline-color-graph-lines: 1
white-foreground:           1
pikchr-background:          0x1d2021

timeline-arrowheads:        1
timeline-circle-nodes:      0
timeline-color-graph-lines: 0
white-foreground:           1
pikchr-background:          0x485d7b

  if( skin_detail_boolean("white-foreground") ){
    pikFlags |= 0x02;  /* PIKCHR_DARK_MODE */
  }
  zPikVar = skin_detail("pikchr-foreground");
  if( zPikVar && zPikVar[0] ){
    blob_appendf(&bSrc, "fgcolor = %s\n", zPikVar);
  }
  zPikVar = skin_detail("pikchr-background");
  if( zPikVar && zPikVar[0] ){
    blob_appendf(&bSrc, "bgcolor = %s\n", zPikVar);
  }
  zPikVar = skin_detail("pikchr-scale");
  if( zPikVar
   && (rPikVar = atof(zPikVar))>=0.1
   && rPikVar<10.0
  ){
    blob_appendf(&bSrc, "scale = %.13g\n", rPikVar);
  }

  PNum wArrow;                 /* Width of arrowhead at the fat end */
  PNum hArrow;                 /* Ht of arrowhead - dist from tip to fat end */
  char bLayoutVars;            /* True if cache is valid */
  char thenFlag;           /* True if "then" seen */
  char samePath;           /* aTPath copied by "same" */
  const char *zClass;      /* Class name for the <svg> */
  int wSVG, hSVG;          /* Width and height of the <svg> */
  int fgcolor;             /* foreground color value, or -1 for none */
  int bgcolor;             /* background color value, or -1 for none */
  /* Paths for lines are constructed here first, then transferred into
  ** the PObj object at the end: */
  int nTPath;              /* Number of entries on aTPath[] */
  int mTPath;              /* For last entry, 1: x set,  2: y set */
  PPoint aTPath[1000];     /* Path under construction */
  /* Error contexts */
  unsigned int nCtx;       /* Number of error contexts */

static void pik_behind(Pik*,PObj*);
static PObj *pik_assert(Pik*,PNum,PToken*,PNum);
static PObj *pik_position_assert(Pik*,PPoint*,PToken*,PPoint*);
static PNum pik_dist(PPoint*,PPoint*);
static void pik_add_macro(Pik*,PToken *pId,PToken *pCode);


#line 505 "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

#define YYACTIONTYPE unsigned short int
#define pik_parserTOKENTYPE PToken
typedef union {
  int yyinit;
  pik_parserTOKENTYPE yy0;
  PObj* yy38;
  PPoint yy43;
  short int yy44;
  PList* yy119;

  PRel yy200;
  PNum yy265;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
#endif
#define pik_parserARG_SDECL

    ** 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 98: /* statement_list */
{
#line 494 "pikchr.y"
pik_elist_free(p,(yypminor->yy119));
#line 1723 "pikchr.c"
}
      break;
    case 99: /* statement */
    case 100: /* unnamed_statement */
    case 101: /* basetype */
{
#line 496 "pikchr.y"
pik_elem_free(p,(yypminor->yy38));
#line 1732 "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 528 "pikchr.y"

  pik_error(p, 0, "parser stack overflow");
#line 1953 "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 ::= statement_list */
#line 532 "pikchr.y"
{pik_render(p,yymsp[0].minor.yy119);}
#line 2433 "pikchr.c"
        break;
      case 1: /* statement_list ::= statement */
#line 535 "pikchr.y"
{ yylhsminor.yy119 = pik_elist_append(p,0,yymsp[0].minor.yy38); }
#line 2438 "pikchr.c"
  yymsp[0].minor.yy119 = yylhsminor.yy119;
        break;
      case 2: /* statement_list ::= statement_list EOL statement */
#line 537 "pikchr.y"
{ yylhsminor.yy119 = pik_elist_append(p,yymsp[-2].minor.yy119,yymsp[0].minor.yy38); }
#line 2444 "pikchr.c"
  yymsp[-2].minor.yy119 = yylhsminor.yy119;
        break;
      case 3: /* statement ::= */
#line 540 "pikchr.y"
{ yymsp[1].minor.yy38 = 0; }
#line 2450 "pikchr.c"
        break;
      case 4: /* statement ::= direction */
#line 541 "pikchr.y"
{ pik_set_direction(p,yymsp[0].minor.yy0.eCode);  yylhsminor.yy38=0; }
#line 2455 "pikchr.c"
  yymsp[0].minor.yy38 = yylhsminor.yy38;
        break;
      case 5: /* statement ::= lvalue ASSIGN rvalue */
#line 542 "pikchr.y"
{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy265,&yymsp[-1].minor.yy0); yylhsminor.yy38=0;}
#line 2461 "pikchr.c"
  yymsp[-2].minor.yy38 = yylhsminor.yy38;
        break;
      case 6: /* statement ::= PLACENAME COLON unnamed_statement */
#line 544 "pikchr.y"
{ yylhsminor.yy38 = yymsp[0].minor.yy38;  pik_elem_setname(p,yymsp[0].minor.yy38,&yymsp[-2].minor.yy0); }
#line 2467 "pikchr.c"
  yymsp[-2].minor.yy38 = yylhsminor.yy38;
        break;
      case 7: /* statement ::= PLACENAME COLON position */
#line 546 "pikchr.y"
{ yylhsminor.yy38 = pik_elem_new(p,0,0,0);
                 if(yylhsminor.yy38){ yylhsminor.yy38->ptAt = yymsp[0].minor.yy43; pik_elem_setname(p,yylhsminor.yy38,&yymsp[-2].minor.yy0); }}
#line 2474 "pikchr.c"
  yymsp[-2].minor.yy38 = yylhsminor.yy38;
        break;
      case 8: /* statement ::= unnamed_statement */
#line 548 "pikchr.y"
{yylhsminor.yy38 = yymsp[0].minor.yy38;}
#line 2480 "pikchr.c"
  yymsp[0].minor.yy38 = yylhsminor.yy38;
        break;
      case 9: /* statement ::= print prlist */
#line 549 "pikchr.y"
{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy38=0;}
#line 2486 "pikchr.c"
        break;
      case 10: /* statement ::= ASSERT LP expr EQ expr RP */
#line 554 "pikchr.y"
{yymsp[-5].minor.yy38=pik_assert(p,yymsp[-3].minor.yy265,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy265);}
#line 2491 "pikchr.c"
        break;
      case 11: /* statement ::= ASSERT LP position EQ position RP */
#line 556 "pikchr.y"
{yymsp[-5].minor.yy38=pik_position_assert(p,&yymsp[-3].minor.yy43,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy43);}
#line 2496 "pikchr.c"
        break;
      case 12: /* statement ::= DEFINE ID CODEBLOCK */
#line 557 "pikchr.y"
{yymsp[-2].minor.yy38=0; pik_add_macro(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
#line 2501 "pikchr.c"
        break;
      case 13: /* rvalue ::= PLACENAME */
#line 568 "pikchr.y"
{yylhsminor.yy265 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
#line 2506 "pikchr.c"
  yymsp[0].minor.yy265 = yylhsminor.yy265;
        break;
      case 14: /* pritem ::= FILL */
      case 15: /* pritem ::= COLOR */ yytestcase(yyruleno==15);
      case 16: /* pritem ::= THICKNESS */ yytestcase(yyruleno==16);
#line 573 "pikchr.y"
{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
#line 2514 "pikchr.c"
        break;
      case 17: /* pritem ::= rvalue */
#line 576 "pikchr.y"
{pik_append_num(p,"",yymsp[0].minor.yy265);}
#line 2519 "pikchr.c"
        break;
      case 18: /* pritem ::= STRING */
#line 577 "pikchr.y"
{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
#line 2524 "pikchr.c"
        break;
      case 19: /* prsep ::= COMMA */
#line 578 "pikchr.y"
{pik_append(p, " ", 1);}
#line 2529 "pikchr.c"
        break;
      case 20: /* unnamed_statement ::= basetype attribute_list */
#line 581 "pikchr.y"
{yylhsminor.yy38 = yymsp[-1].minor.yy38; pik_after_adding_attributes(p,yylhsminor.yy38);}
#line 2534 "pikchr.c"
  yymsp[-1].minor.yy38 = yylhsminor.yy38;
        break;
      case 21: /* basetype ::= CLASSNAME */
#line 583 "pikchr.y"
{yylhsminor.yy38 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
#line 2540 "pikchr.c"
  yymsp[0].minor.yy38 = yylhsminor.yy38;
        break;
      case 22: /* basetype ::= STRING textposition */
#line 585 "pikchr.y"
{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy44; yylhsminor.yy38 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
#line 2546 "pikchr.c"
  yymsp[-1].minor.yy38 = yylhsminor.yy38;
        break;
      case 23: /* basetype ::= LB savelist statement_list RB */
#line 587 "pikchr.y"
{ p->list = yymsp[-2].minor.yy119; yymsp[-3].minor.yy38 = pik_elem_new(p,0,0,yymsp[-1].minor.yy119); if(yymsp[-3].minor.yy38) yymsp[-3].minor.yy38->errTok = yymsp[0].minor.yy0; }
#line 2552 "pikchr.c"
        break;
      case 24: /* savelist ::= */
#line 592 "pikchr.y"
{yymsp[1].minor.yy119 = p->list; p->list = 0;}
#line 2557 "pikchr.c"
        break;
      case 25: /* relexpr ::= expr */
#line 599 "pikchr.y"
{yylhsminor.yy200.rAbs = yymsp[0].minor.yy265; yylhsminor.yy200.rRel = 0;}
#line 2562 "pikchr.c"
  yymsp[0].minor.yy200 = yylhsminor.yy200;
        break;
      case 26: /* relexpr ::= expr PERCENT */
#line 600 "pikchr.y"
{yylhsminor.yy200.rAbs = 0; yylhsminor.yy200.rRel = yymsp[-1].minor.yy265/100;}
#line 2568 "pikchr.c"
  yymsp[-1].minor.yy200 = yylhsminor.yy200;
        break;
      case 27: /* optrelexpr ::= */
#line 602 "pikchr.y"
{yymsp[1].minor.yy200.rAbs = 0; yymsp[1].minor.yy200.rRel = 1.0;}
#line 2574 "pikchr.c"
        break;
      case 28: /* attribute_list ::= relexpr alist */
#line 604 "pikchr.y"
{pik_add_direction(p,0,&yymsp[-1].minor.yy200);}
#line 2579 "pikchr.c"
        break;
      case 29: /* attribute ::= numproperty relexpr */
#line 608 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy200); }
#line 2584 "pikchr.c"
        break;
      case 30: /* attribute ::= dashproperty expr */
#line 609 "pikchr.y"
{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy265); }
#line 2589 "pikchr.c"
        break;
      case 31: /* attribute ::= dashproperty */
#line 610 "pikchr.y"
{ pik_set_dashed(p,&yymsp[0].minor.yy0,0);  }
#line 2594 "pikchr.c"
        break;
      case 32: /* attribute ::= colorproperty rvalue */
#line 611 "pikchr.y"
{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy265); }
#line 2599 "pikchr.c"
        break;
      case 33: /* attribute ::= go direction optrelexpr */
#line 612 "pikchr.y"
{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy200);}
#line 2604 "pikchr.c"
        break;
      case 34: /* attribute ::= go direction even position */
#line 613 "pikchr.y"
{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy43);}
#line 2609 "pikchr.c"
        break;
      case 35: /* attribute ::= CLOSE */
#line 614 "pikchr.y"
{ pik_close_path(p,&yymsp[0].minor.yy0); }
#line 2614 "pikchr.c"
        break;
      case 36: /* attribute ::= CHOP */
#line 615 "pikchr.y"
{ p->cur->bChop = 1; }
#line 2619 "pikchr.c"
        break;
      case 37: /* attribute ::= FROM position */
#line 616 "pikchr.y"
{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy43); }
#line 2624 "pikchr.c"
        break;
      case 38: /* attribute ::= TO position */
#line 617 "pikchr.y"
{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy43); }
#line 2629 "pikchr.c"
        break;
      case 39: /* attribute ::= THEN */
#line 618 "pikchr.y"
{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
#line 2634 "pikchr.c"
        break;
      case 40: /* attribute ::= THEN optrelexpr HEADING expr */
      case 42: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==42);
#line 620 "pikchr.y"
{pik_move_hdg(p,&yymsp[-2].minor.yy200,&yymsp[-1].minor.yy0,yymsp[0].minor.yy265,0,&yymsp[-3].minor.yy0);}
#line 2640 "pikchr.c"
        break;
      case 41: /* attribute ::= THEN optrelexpr EDGEPT */
      case 43: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==43);
#line 621 "pikchr.y"
{pik_move_hdg(p,&yymsp[-1].minor.yy200,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
#line 2646 "pikchr.c"
        break;
      case 44: /* attribute ::= AT position */
#line 626 "pikchr.y"
{ pik_set_at(p,0,&yymsp[0].minor.yy43,&yymsp[-1].minor.yy0); }
#line 2651 "pikchr.c"
        break;
      case 45: /* attribute ::= SAME */
#line 628 "pikchr.y"
{pik_same(p,0,&yymsp[0].minor.yy0);}
#line 2656 "pikchr.c"
        break;
      case 46: /* attribute ::= SAME AS object */
#line 629 "pikchr.y"
{pik_same(p,yymsp[0].minor.yy38,&yymsp[-2].minor.yy0);}
#line 2661 "pikchr.c"
        break;
      case 47: /* attribute ::= STRING textposition */
#line 630 "pikchr.y"
{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy44);}
#line 2666 "pikchr.c"
        break;
      case 48: /* attribute ::= FIT */
#line 631 "pikchr.y"
{pik_size_to_fit(p,&yymsp[0].minor.yy0,3); }
#line 2671 "pikchr.c"
        break;
      case 49: /* attribute ::= BEHIND object */
#line 632 "pikchr.y"
{pik_behind(p,yymsp[0].minor.yy38);}
#line 2676 "pikchr.c"
        break;
      case 50: /* withclause ::= DOT_E edge AT position */
      case 51: /* withclause ::= edge AT position */ yytestcase(yyruleno==51);
#line 640 "pikchr.y"
{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy43,&yymsp[-1].minor.yy0); }
#line 2682 "pikchr.c"
        break;
      case 52: /* numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
#line 644 "pikchr.y"
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
#line 2687 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 53: /* boolproperty ::= CW */
#line 655 "pikchr.y"
{p->cur->cw = 1;}
#line 2693 "pikchr.c"
        break;
      case 54: /* boolproperty ::= CCW */
#line 656 "pikchr.y"
{p->cur->cw = 0;}
#line 2698 "pikchr.c"
        break;
      case 55: /* boolproperty ::= LARROW */
#line 657 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=0; }
#line 2703 "pikchr.c"
        break;
      case 56: /* boolproperty ::= RARROW */
#line 658 "pikchr.y"
{p->cur->larrow=0; p->cur->rarrow=1; }
#line 2708 "pikchr.c"
        break;
      case 57: /* boolproperty ::= LRARROW */
#line 659 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=1; }
#line 2713 "pikchr.c"
        break;
      case 58: /* boolproperty ::= INVIS */
#line 660 "pikchr.y"
{p->cur->sw = 0.0;}
#line 2718 "pikchr.c"
        break;
      case 59: /* boolproperty ::= THICK */
#line 661 "pikchr.y"
{p->cur->sw *= 1.5;}
#line 2723 "pikchr.c"
        break;
      case 60: /* boolproperty ::= THIN */
#line 662 "pikchr.y"
{p->cur->sw *= 0.67;}
#line 2728 "pikchr.c"
        break;
      case 61: /* boolproperty ::= SOLID */
#line 663 "pikchr.y"
{p->cur->sw = pik_value(p,"thickness",9,0);
                               p->cur->dotted = p->cur->dashed = 0.0;}
#line 2734 "pikchr.c"
        break;
      case 62: /* textposition ::= */
#line 666 "pikchr.y"
{yymsp[1].minor.yy44 = 0;}
#line 2739 "pikchr.c"
        break;
      case 63: /* textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
#line 669 "pikchr.y"
{yylhsminor.yy44 = (short int)pik_text_position(yymsp[-1].minor.yy44,&yymsp[0].minor.yy0);}
#line 2744 "pikchr.c"
  yymsp[-1].minor.yy44 = yylhsminor.yy44;
        break;
      case 64: /* position ::= expr COMMA expr */
#line 672 "pikchr.y"
{yylhsminor.yy43.x=yymsp[-2].minor.yy265; yylhsminor.yy43.y=yymsp[0].minor.yy265;}
#line 2750 "pikchr.c"
  yymsp[-2].minor.yy43 = yylhsminor.yy43;
        break;
      case 65: /* position ::= place PLUS expr COMMA expr */
#line 674 "pikchr.y"
{yylhsminor.yy43.x=yymsp[-4].minor.yy43.x+yymsp[-2].minor.yy265; yylhsminor.yy43.y=yymsp[-4].minor.yy43.y+yymsp[0].minor.yy265;}
#line 2756 "pikchr.c"
  yymsp[-4].minor.yy43 = yylhsminor.yy43;
        break;
      case 66: /* position ::= place MINUS expr COMMA expr */
#line 675 "pikchr.y"
{yylhsminor.yy43.x=yymsp[-4].minor.yy43.x-yymsp[-2].minor.yy265; yylhsminor.yy43.y=yymsp[-4].minor.yy43.y-yymsp[0].minor.yy265;}
#line 2762 "pikchr.c"
  yymsp[-4].minor.yy43 = yylhsminor.yy43;
        break;
      case 67: /* position ::= place PLUS LP expr COMMA expr RP */
#line 677 "pikchr.y"
{yylhsminor.yy43.x=yymsp[-6].minor.yy43.x+yymsp[-3].minor.yy265; yylhsminor.yy43.y=yymsp[-6].minor.yy43.y+yymsp[-1].minor.yy265;}
#line 2768 "pikchr.c"
  yymsp[-6].minor.yy43 = yylhsminor.yy43;
        break;
      case 68: /* position ::= place MINUS LP expr COMMA expr RP */
#line 679 "pikchr.y"
{yylhsminor.yy43.x=yymsp[-6].minor.yy43.x-yymsp[-3].minor.yy265; yylhsminor.yy43.y=yymsp[-6].minor.yy43.y-yymsp[-1].minor.yy265;}
#line 2774 "pikchr.c"
  yymsp[-6].minor.yy43 = yylhsminor.yy43;
        break;
      case 69: /* position ::= LP position COMMA position RP */
#line 680 "pikchr.y"
{yymsp[-4].minor.yy43.x=yymsp[-3].minor.yy43.x; yymsp[-4].minor.yy43.y=yymsp[-1].minor.yy43.y;}
#line 2780 "pikchr.c"
        break;
      case 70: /* position ::= LP position RP */
#line 681 "pikchr.y"
{yymsp[-2].minor.yy43=yymsp[-1].minor.yy43;}
#line 2785 "pikchr.c"
        break;
      case 71: /* position ::= expr between position AND position */
#line 683 "pikchr.y"
{yylhsminor.yy43 = pik_position_between(yymsp[-4].minor.yy265,yymsp[-2].minor.yy43,yymsp[0].minor.yy43);}
#line 2790 "pikchr.c"
  yymsp[-4].minor.yy43 = yylhsminor.yy43;
        break;
      case 72: /* position ::= expr LT position COMMA position GT */
#line 685 "pikchr.y"
{yylhsminor.yy43 = pik_position_between(yymsp[-5].minor.yy265,yymsp[-3].minor.yy43,yymsp[-1].minor.yy43);}
#line 2796 "pikchr.c"
  yymsp[-5].minor.yy43 = yylhsminor.yy43;
        break;
      case 73: /* position ::= expr ABOVE position */
#line 686 "pikchr.y"
{yylhsminor.yy43=yymsp[0].minor.yy43; yylhsminor.yy43.y += yymsp[-2].minor.yy265;}
#line 2802 "pikchr.c"
  yymsp[-2].minor.yy43 = yylhsminor.yy43;
        break;
      case 74: /* position ::= expr BELOW position */
#line 687 "pikchr.y"
{yylhsminor.yy43=yymsp[0].minor.yy43; yylhsminor.yy43.y -= yymsp[-2].minor.yy265;}
#line 2808 "pikchr.c"
  yymsp[-2].minor.yy43 = yylhsminor.yy43;
        break;
      case 75: /* position ::= expr LEFT OF position */
#line 688 "pikchr.y"
{yylhsminor.yy43=yymsp[0].minor.yy43; yylhsminor.yy43.x -= yymsp[-3].minor.yy265;}
#line 2814 "pikchr.c"
  yymsp[-3].minor.yy43 = yylhsminor.yy43;
        break;
      case 76: /* position ::= expr RIGHT OF position */
#line 689 "pikchr.y"
{yylhsminor.yy43=yymsp[0].minor.yy43; yylhsminor.yy43.x += yymsp[-3].minor.yy265;}
#line 2820 "pikchr.c"
  yymsp[-3].minor.yy43 = yylhsminor.yy43;
        break;
      case 77: /* position ::= expr ON HEADING EDGEPT OF position */
#line 691 "pikchr.y"
{yylhsminor.yy43 = pik_position_at_hdg(yymsp[-5].minor.yy265,&yymsp[-2].minor.yy0,yymsp[0].minor.yy43);}
#line 2826 "pikchr.c"
  yymsp[-5].minor.yy43 = yylhsminor.yy43;
        break;
      case 78: /* position ::= expr HEADING EDGEPT OF position */
#line 693 "pikchr.y"
{yylhsminor.yy43 = pik_position_at_hdg(yymsp[-4].minor.yy265,&yymsp[-2].minor.yy0,yymsp[0].minor.yy43);}
#line 2832 "pikchr.c"
  yymsp[-4].minor.yy43 = yylhsminor.yy43;
        break;
      case 79: /* position ::= expr EDGEPT OF position */
#line 695 "pikchr.y"
{yylhsminor.yy43 = pik_position_at_hdg(yymsp[-3].minor.yy265,&yymsp[-2].minor.yy0,yymsp[0].minor.yy43);}
#line 2838 "pikchr.c"
  yymsp[-3].minor.yy43 = yylhsminor.yy43;
        break;
      case 80: /* position ::= expr ON HEADING expr FROM position */
#line 697 "pikchr.y"
{yylhsminor.yy43 = pik_position_at_angle(yymsp[-5].minor.yy265,yymsp[-2].minor.yy265,yymsp[0].minor.yy43);}
#line 2844 "pikchr.c"
  yymsp[-5].minor.yy43 = yylhsminor.yy43;
        break;
      case 81: /* position ::= expr HEADING expr FROM position */
#line 699 "pikchr.y"
{yylhsminor.yy43 = pik_position_at_angle(yymsp[-4].minor.yy265,yymsp[-2].minor.yy265,yymsp[0].minor.yy43);}
#line 2850 "pikchr.c"
  yymsp[-4].minor.yy43 = yylhsminor.yy43;
        break;
      case 82: /* place ::= edge OF object */
#line 711 "pikchr.y"
{yylhsminor.yy43 = pik_place_of_elem(p,yymsp[0].minor.yy38,&yymsp[-2].minor.yy0);}
#line 2856 "pikchr.c"
  yymsp[-2].minor.yy43 = yylhsminor.yy43;
        break;
      case 83: /* place2 ::= object */
#line 712 "pikchr.y"
{yylhsminor.yy43 = pik_place_of_elem(p,yymsp[0].minor.yy38,0);}
#line 2862 "pikchr.c"
  yymsp[0].minor.yy43 = yylhsminor.yy43;
        break;
      case 84: /* place2 ::= object DOT_E edge */
#line 713 "pikchr.y"
{yylhsminor.yy43 = pik_place_of_elem(p,yymsp[-2].minor.yy38,&yymsp[0].minor.yy0);}
#line 2868 "pikchr.c"
  yymsp[-2].minor.yy43 = yylhsminor.yy43;
        break;
      case 85: /* place2 ::= NTH VERTEX OF object */
#line 714 "pikchr.y"
{yylhsminor.yy43 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy38);}
#line 2874 "pikchr.c"
  yymsp[-3].minor.yy43 = yylhsminor.yy43;
        break;
      case 86: /* object ::= nth */
#line 726 "pikchr.y"
{yylhsminor.yy38 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
#line 2880 "pikchr.c"
  yymsp[0].minor.yy38 = yylhsminor.yy38;
        break;
      case 87: /* object ::= nth OF|IN object */
#line 727 "pikchr.y"
{yylhsminor.yy38 = pik_find_nth(p,yymsp[0].minor.yy38,&yymsp[-2].minor.yy0);}
#line 2886 "pikchr.c"
  yymsp[-2].minor.yy38 = yylhsminor.yy38;
        break;
      case 88: /* objectname ::= PLACENAME */
#line 729 "pikchr.y"
{yylhsminor.yy38 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
#line 2892 "pikchr.c"
  yymsp[0].minor.yy38 = yylhsminor.yy38;
        break;
      case 89: /* objectname ::= objectname DOT_U PLACENAME */
#line 731 "pikchr.y"
{yylhsminor.yy38 = pik_find_byname(p,yymsp[-2].minor.yy38,&yymsp[0].minor.yy0);}
#line 2898 "pikchr.c"
  yymsp[-2].minor.yy38 = yylhsminor.yy38;
        break;
      case 90: /* nth ::= NTH CLASSNAME */
#line 733 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
#line 2904 "pikchr.c"
  yymsp[-1].minor.yy0 = yylhsminor.yy0;
        break;
      case 91: /* nth ::= NTH LAST CLASSNAME */
#line 734 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
#line 2910 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 92: /* nth ::= LAST CLASSNAME */
#line 735 "pikchr.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
#line 2916 "pikchr.c"
        break;
      case 93: /* nth ::= LAST */
#line 736 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
#line 2921 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 94: /* nth ::= NTH LB RB */
#line 737 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
#line 2927 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 95: /* nth ::= NTH LAST LB RB */
#line 738 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
#line 2933 "pikchr.c"
  yymsp[-3].minor.yy0 = yylhsminor.yy0;
        break;
      case 96: /* nth ::= LAST LB RB */
#line 739 "pikchr.y"
{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
#line 2939 "pikchr.c"
        break;
      case 97: /* expr ::= expr PLUS expr */
#line 741 "pikchr.y"
{yylhsminor.yy265=yymsp[-2].minor.yy265+yymsp[0].minor.yy265;}
#line 2944 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 98: /* expr ::= expr MINUS expr */
#line 742 "pikchr.y"
{yylhsminor.yy265=yymsp[-2].minor.yy265-yymsp[0].minor.yy265;}
#line 2950 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 99: /* expr ::= expr STAR expr */
#line 743 "pikchr.y"
{yylhsminor.yy265=yymsp[-2].minor.yy265*yymsp[0].minor.yy265;}
#line 2956 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 100: /* expr ::= expr SLASH expr */
#line 744 "pikchr.y"
{
  if( yymsp[0].minor.yy265==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy265 = 0.0; }
  else{ yylhsminor.yy265 = yymsp[-2].minor.yy265/yymsp[0].minor.yy265; }
}
#line 2965 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 101: /* expr ::= MINUS expr */
#line 748 "pikchr.y"
{yymsp[-1].minor.yy265=-yymsp[0].minor.yy265;}
#line 2971 "pikchr.c"
        break;
      case 102: /* expr ::= PLUS expr */
#line 749 "pikchr.y"
{yymsp[-1].minor.yy265=yymsp[0].minor.yy265;}
#line 2976 "pikchr.c"
        break;
      case 103: /* expr ::= LP expr RP */
#line 750 "pikchr.y"
{yymsp[-2].minor.yy265=yymsp[-1].minor.yy265;}
#line 2981 "pikchr.c"
        break;
      case 104: /* expr ::= LP FILL|COLOR|THICKNESS RP */
#line 751 "pikchr.y"
{yymsp[-2].minor.yy265=pik_get_var(p,&yymsp[-1].minor.yy0);}
#line 2986 "pikchr.c"
        break;
      case 105: /* expr ::= NUMBER */
#line 752 "pikchr.y"
{yylhsminor.yy265=pik_atof(&yymsp[0].minor.yy0);}
#line 2991 "pikchr.c"
  yymsp[0].minor.yy265 = yylhsminor.yy265;
        break;
      case 106: /* expr ::= ID */
#line 753 "pikchr.y"
{yylhsminor.yy265=pik_get_var(p,&yymsp[0].minor.yy0);}
#line 2997 "pikchr.c"
  yymsp[0].minor.yy265 = yylhsminor.yy265;
        break;
      case 107: /* expr ::= FUNC1 LP expr RP */
#line 754 "pikchr.y"
{yylhsminor.yy265 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy265,0.0);}
#line 3003 "pikchr.c"
  yymsp[-3].minor.yy265 = yylhsminor.yy265;
        break;
      case 108: /* expr ::= FUNC2 LP expr COMMA expr RP */
#line 755 "pikchr.y"
{yylhsminor.yy265 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy265,yymsp[-1].minor.yy265);}
#line 3009 "pikchr.c"
  yymsp[-5].minor.yy265 = yylhsminor.yy265;
        break;
      case 109: /* expr ::= DIST LP position COMMA position RP */
#line 756 "pikchr.y"
{yymsp[-5].minor.yy265 = pik_dist(&yymsp[-3].minor.yy43,&yymsp[-1].minor.yy43);}
#line 3015 "pikchr.c"
        break;
      case 110: /* expr ::= place2 DOT_XY X */
#line 757 "pikchr.y"
{yylhsminor.yy265 = yymsp[-2].minor.yy43.x;}
#line 3020 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 111: /* expr ::= place2 DOT_XY Y */
#line 758 "pikchr.y"
{yylhsminor.yy265 = yymsp[-2].minor.yy43.y;}
#line 3026 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      case 112: /* expr ::= object DOT_L numproperty */
      case 113: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==113);
      case 114: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==114);
#line 759 "pikchr.y"
{yylhsminor.yy265=pik_property_of(yymsp[-2].minor.yy38,&yymsp[0].minor.yy0);}
#line 3034 "pikchr.c"
  yymsp[-2].minor.yy265 = yylhsminor.yy265;
        break;
      default:
      /* (115) lvalue ::= ID */ yytestcase(yyruleno==115);
      /* (116) lvalue ::= FILL */ yytestcase(yyruleno==116);
      /* (117) lvalue ::= COLOR */ yytestcase(yyruleno==117);
      /* (118) lvalue ::= THICKNESS */ yytestcase(yyruleno==118);

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

  if( TOKEN.z && TOKEN.z[0] ){
    pik_error(p, &TOKEN, "syntax error");
  }else{
    pik_error(p, 0, "syntax error");
  }
  UNUSED_PARAMETER(yymajor);
#line 3145 "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 764 "pikchr.y"



/* Chart of the 148 official CSS color names with their
** corresponding RGB values thru Color Module Level 4:
** https://developer.mozilla.org/en-US/docs/Web/CSS/color_value
**

**   *  The "&" character is changed into "&" if mFlags has the
**      0x02 bit set.  This is needed when generating error message text.
**
**   *  Except for the above, only "<" and ">" are escaped.
*/
static void pik_append_text(Pik *p, const char *zText, int n, int mFlags){
  int i;
  char c = 0;
  int bQSpace = mFlags & 1;
  int bQAmp = mFlags & 2;
  if( n<0 ) n = (int)strlen(zText);
  while( n>0 ){
    for(i=0; i<n; i++){
      c = zText[i];
      if( c=='<' || c=='>' ) break;

*/
static void pik_append_clr(Pik *p,const char *z1,PNum v,const char *z2,int bg){
  char buf[200];
  int x = (int)v;
  int r, g, b;
  if( x==0 && p->fgcolor>0 && !bg ){
    x = p->fgcolor;
  }else if( bg && x>=0xffffff && p->bgcolor>0 ){
    x = p->bgcolor;
  }else if( p->mFlags & PIKCHR_DARK_MODE ){
    x = pik_color_to_dark_mode(x,bg);
  }
  r = (x>>16) & 0xff;
  g = (x>>8) & 0xff;
  b = x & 0xff;
  snprintf(buf, sizeof(buf)-1, "%srgb(%d,%d,%d)%s", z1, r, g, b, z2);

      }else{
        x0 = nx+cw/2;
        y0 = y+ch;
        x1 = nx-cw/2;
        y1 = y-ch;
      }
      if( (t->eCode & TP_ALIGN)!=0 && pObj->nPath>=2 ){
        int nn = pObj->nPath;
        PNum dx = pObj->aPath[nn-1].x - pObj->aPath[0].x;
        PNum dy = pObj->aPath[nn-1].y - pObj->aPath[0].y;
        if( dx!=0 || dy!=0 ){
          PNum dist = hypot(dx,dy);
          PNum tt;
          dx /= dist;
          dy /= dist;
          tt = dx*x0 - dy*y0;
          y0 = dy*x0 - dx*y0;
          x0 = tt;
          tt = dx*x1 - dy*y1;
          y1 = dy*x1 - dx*y1;
          x1 = tt;
        }
      }
      pik_bbox_add_xy(pBox, x+x0, orig_y+y0);
      pik_bbox_add_xy(pBox, x+x1, orig_y+y1);
      continue;
    }
    nx += x;

    }
    xtraFontScale *= p->fontScale;
    if( xtraFontScale<=0.99 || xtraFontScale>=1.01 ){
      pik_append_num(p, " font-size=\"", xtraFontScale*100.0);
      pik_append(p, "%\"", 2);
    }
    if( (t->eCode & TP_ALIGN)!=0 && pObj->nPath>=2 ){
      int nn = pObj->nPath;
      PNum dx = pObj->aPath[nn-1].x - pObj->aPath[0].x;
      PNum dy = pObj->aPath[nn-1].y - pObj->aPath[0].y;
      if( dx!=0 || dy!=0 ){
        PNum ang = atan2(dy,dx)*-180/M_PI;
        pik_append_num(p, " transform=\"rotate(", ang);
        pik_append_xy(p, " ", x, orig_y);
        pik_append(p,")\"",2);
      }
    }

  }
}

/* Change the layout direction.
*/
static void pik_set_direction(Pik *p, int eDir){
  assert( ValidDir(eDir) );
  p->eDir = (unsigned char)eDir;

  /* It seems to make sense to reach back into the last object and
  ** change its exit point (its ".end") to correspond to the new
  ** direction.  Things just seem to work better this way.  However,
  ** legacy PIC does *not* do this.
  **
  ** The difference can be seen in a script like this:

  PToken *pT;
  if( pObj->nTxt >= count(pObj->aTxt) ){
    pik_error(p, pTxt, "too many text terms");
    return;
  }
  pT = &pObj->aTxt[pObj->nTxt++];
  *pT = *pTxt;
  pT->eCode = (short)iPos;
}

/* Merge "text-position" flags
*/
static int pik_text_position(int iPrev, PToken *pFlag){
  int iRes = iPrev;
  switch( pFlag->eType ){

static short int pik_nth_value(Pik *p, PToken *pNth){
  int i = atoi(pNth->z);
  if( i>1000 ){
    pik_error(p, pNth, "value too big - max '1000th'");
    i = 1;
  }
  if( i==0 && pik_token_eq(pNth,"first")==0 ) i = 1;
  return (short int)i;
}

/* Search for the NTH object.
**
** If pBasis is not NULL then it should be a [] object.  Use the
** sublist of that [] object for the search.  If pBasis is not a []
** object, then throw an error.

static PPoint pik_position_at_hdg(PNum dist, PToken *pD, PPoint pt){
  return pik_position_at_angle(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, PObj *pObj){
  static const PPoint zero = {0, 0};
  int n;
  if( p->nErr || pObj==0 ) return p->aTPath[0];
  if( !pObj->type->isLine ){
    pik_error(p, pErr, "object is not a line");
    return zero;
  }
  n = atoi(pNth->z);

    switch( pObj->inDir ){
      default:        p->aTPath[1].x += pObj->w; break;
      case DIR_DOWN:  p->aTPath[1].y -= pObj->h; break;
      case DIR_LEFT:  p->aTPath[1].x -= pObj->w; break;
      case DIR_UP:    p->aTPath[1].y += pObj->h; break;
    }
    if( pObj->type->xInit==arcInit ){
      pObj->outDir = (pObj->inDir + (pObj->cw ? 1 : 3))%4;
      p->eDir = (unsigned char)pObj->outDir;
      switch( pObj->outDir ){
        default:        p->aTPath[1].x += pObj->w; break;
        case DIR_DOWN:  p->aTPath[1].y -= pObj->h; break;
        case DIR_LEFT:  p->aTPath[1].x -= pObj->w; break;
        case DIR_UP:    p->aTPath[1].y += pObj->h; break;
      }
    }

      case DIR_LEFT:   pObj->ptExit.x -= w2;  break;
      case DIR_UP:     pObj->ptExit.y += h2;  break;
      case DIR_DOWN:   pObj->ptExit.y -= h2;  break;
    }
    pik_bbox_add_xy(&pObj->bbox, pObj->ptAt.x - w2, pObj->ptAt.y - h2);
    pik_bbox_add_xy(&pObj->bbox, pObj->ptAt.x + w2, pObj->ptAt.y + h2);
  }
  p->eDir = (unsigned char)pObj->outDir;
}

/* Show basic information about each object as a comment in the
** generated HTML.  Used for testing and debugging.  Activated
** by the (undocumented) "debug = 1;"
** command.
*/

    /* Set up rendering parameters */
    pik_compute_layout_settings(p);
    thickness = pik_value(p,"thickness",9,0);
    if( thickness<=0.01 ) thickness = 0.01;
    margin = pik_value(p,"margin",6,0);
    margin += thickness;
    wArrow = p->wArrow*thickness;
    miss = 0;
    p->fgcolor = (int)pik_value(p,"fgcolor",7,&miss);
    if( miss ){
      PToken t;
      t.z = "fgcolor";
      t.n = 7;
      p->fgcolor = (int)pik_lookup_color(0, &t);
    }
    miss = 0;
    p->bgcolor = (int)pik_value(p,"bgcolor",7,&miss);
    if( miss ){
      PToken t;
      t.z = "bgcolor";
      t.n = 7;
      p->bgcolor = (int)pik_lookup_color(0, &t);
    }

    /* Compute a bounding box over all objects so that we can know
    ** how big to declare the SVG canvas */
    pik_bbox_init(&p->bbox);
    pik_bbox_add_elist(p, pList, wArrow);

    /* Expand the bounding box slightly to account for line thickness

      pik_append(p, "\"", 1);
    }
    w = p->bbox.ne.x - p->bbox.sw.x;
    h = p->bbox.ne.y - p->bbox.sw.y;
    p->wSVG = (int)(p->rScale*w);
    p->hSVG = (int)(p->rScale*h);
    pikScale = pik_value(p,"scale",5,0);
    if( pikScale>=0.001 && pikScale<=1000.0
     && (pikScale<0.99 || pikScale>1.01)
    ){
      p->wSVG = (int)(p->wSVG*pikScale);
      p->hSVG = (int)(p->hSVG*pikScale);
      pik_append_num(p, " width=\"", p->wSVG);
      pik_append_num(p, "\" height=\"", p->hSVG);
      pik_append(p, "\"", 1);
    }
    pik_append_dis(p, " viewBox=\"0 0 ",w,"");
    pik_append_dis(p, " ",h,"\">\n");
    pik_elist_render(p, pList);

            for(i=2; (c = z[i])!=0 && isxdigit(c); i++){}
            pToken->eType = T_NUMBER;
            return i;
          }
        }else{
          isInt = 0;
          nDigit = 0;
          i = 0;
        }
        if( c=='.' ){
          isInt = 0;
          for(i++; (c = z[i])>='0' && c<='9'; i++){ nDigit++; }
        }
        if( nDigit==0 ){
          pToken->eType = T_ERROR;

#endif /* PIKCHR_FUZZ */

#if defined(PIKCHR_SHELL)
/* Print a usage comment for the shell and exit. */
static void usage(const char *argv0){
  fprintf(stderr, "usage: %s [OPTIONS] FILE ...\n", argv0);
  fprintf(stderr,
    "Convert Pikchr input files into SVG.  Filename \"-\" means stdin.\n"
    "Options:\n"
    "   --dont-stop      Process all files even if earlier files have errors\n"
    "   --svg-only       Omit raw SVG without the HTML wrapper\n"
  );
  exit(1);
}

    }else if( c=='&' ){
      printf("&");
    }else if( c==0 ){
      break;
    }
  }
}

/* Read the content of file zFilename into memory obtained from malloc()
** Return the memory.  If something goes wrong (ex: the file does not exist
** or cannot be opened) put an error message on stderr and return NULL.
**
** If the filename is "-" read stdin.
*/
static char *readFile(const char *zFilename){
  FILE *in;
  size_t n;
  size_t nUsed = 0;
  size_t nAlloc = 0;
  char *z = 0, *zNew;
  in = strcmp(zFilename,"-")==0 ? stdin : fopen(zFilename, "rb");
  if( in==0 ){
    fprintf(stderr, "cannot open \"%s\" for reading\n", zFilename);
    return 0;
  }
  while(1){
    if( nUsed+2>=nAlloc ){
      nAlloc = nAlloc*2 + 4000;
      zNew = realloc(z, nAlloc);
    }
    if( zNew==0 ){
      free(z);
      fprintf(stderr, "out of memory trying to allocate %lld bytes\n",
              (long long int)nAlloc);
      exit(1);
    }
    z = zNew;
    n = fread(z+nUsed, 1, nAlloc-nUsed-1, in);
    if( n<=0 ){
      break;
    }
    nUsed += n;
  }
  if( in!=stderr ) fclose(in);
  z[nUsed] = 0;
  return z;
}


/* Testing interface
**
** Generate HTML on standard output that displays both the original
** input text and the rendered SVG for all files named on the command
** line.
*/

    "</script>\n"
    "<meta charset=\"utf-8\">\n"
    "</head>\n"
    "<body>\n"
  ;
  if( argc<2 ) usage(argv[0]);
  for(i=1; i<argc; i++){


    char *zIn;
    char *zOut;
    int w, h;

    if( argv[i][0]=='-' && argv[i][1]!=0 ){
      char *z = argv[i];
      z++;
      if( z[0]=='-' ) z++;
      if( strcmp(z,"dont-stop")==0 ){
        bDontStop = 1;
      }else
      if( strcmp(z,"dark-mode")==0 ){

      }else
      {
        fprintf(stderr,"unknown option: \"%s\"\n", argv[i]);
        usage(argv[0]);
      }
      continue;
    }
    zIn = readFile(argv[i]);








    if( zIn==0 ) continue;







    zOut = pikchr(zIn, "pikchr", mFlags, &w, &h);
    if( w<0 ) exitCode = 1;
    if( zOut==0 ){
      fprintf(stderr, "pikchr() returns NULL.  Out of memory?\n");
      if( !bDontStop ) exit(1);
    }else if( bSvgOnly ){
      printf("%s\n", zOut);

  Tcl_Obj *CONST objv[]  /* Command arguments */
){
  int w, h;              /* Width and height of the pikchr */
  const char *zIn;       /* Source text input */
  char *zOut;            /* SVG output text */
  Tcl_Obj *pRes;         /* The result TCL object */

  (void)clientData;
  if( objc!=2 ){
    Tcl_WrongNumArgs(interp, 1, objv, "PIKCHR_SOURCE_TEXT");
    return TCL_ERROR;
  }
  zIn = Tcl_GetString(objv[1]);
  w = h = 0;
  zOut = pikchr(zIn, "pikchr", 0, &w, &h);

  return TCL_OK;
}

/* Invoke this routine to register the "pikchr" command with the interpreter
** given in the argument */
int Pikchr_Init(Tcl_Interp *interp){
  Tcl_CreateObjCommand(interp, "pikchr", pik_tcl_command, 0, 0);
  Tcl_PkgProvide (interp, PACKAGE_NAME, PACKAGE_VERSION);
  return TCL_OK;
}


#endif /* PIKCHR_TCL */


#line 7954 "pikchr.c"

**
** The following array holds the value for all known skin details.
*/
static struct SkinDetail {
  const char *zName;      /* Name of the detail */
  const char *zValue;     /* Value of the detail */
} aSkinDetail[] = {
  { "pikchr-background",          ""      },
  { "pikchr-fontscale",           ""      },
  { "pikchr-foreground",          ""      },
  { "pikchr-scale",               ""      },
  { "timeline-arrowheads",        "1"     },
  { "timeline-circle-nodes",      "0"     },
  { "timeline-color-graph-lines", "0"     },
  { "white-foreground",           "0"     },