Fossil

  ** the PElem 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 */
};












/*
** The behavior of an object class is defined by an instance of
** this structure. This is the "virtual method" table.
*/
struct PClass {
  const char *zName;                     /* Name of class */
  char isLine;                           /* True if a line class */

static PToken pik_next_semantic_token(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 477 "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 466 "pikchr.y"
pik_elist_free(p,(yypminor->yy72));
#line 1654 "pikchr.c"
}
      break;
    case 95: /* element */
    case 96: /* unnamed_element */
    case 97: /* basetype */
{
#line 468 "pikchr.y"
pik_elem_free(p,(yypminor->yy254));
#line 1663 "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 500 "pikchr.y"

  pik_error(p, 0, "parser stack overflow");
#line 1884 "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 504 "pikchr.y"
{pik_render(p,yymsp[0].minor.yy72);}
#line 2355 "pikchr.c"
        break;
      case 1: /* element_list ::= element */
#line 507 "pikchr.y"
{ yylhsminor.yy72 = pik_elist_append(p,0,yymsp[0].minor.yy254); }
#line 2360 "pikchr.c"
  yymsp[0].minor.yy72 = yylhsminor.yy72;
        break;
      case 2: /* element_list ::= element_list EOL element */
#line 509 "pikchr.y"
{ yylhsminor.yy72 = pik_elist_append(p,yymsp[-2].minor.yy72,yymsp[0].minor.yy254); }
#line 2366 "pikchr.c"
  yymsp[-2].minor.yy72 = yylhsminor.yy72;
        break;
      case 3: /* element ::= */
#line 512 "pikchr.y"
{ yymsp[1].minor.yy254 = 0; }
#line 2372 "pikchr.c"
        break;
      case 4: /* element ::= direction */
#line 513 "pikchr.y"
{ pik_set_direction(p,yymsp[0].minor.yy0.eCode);  yylhsminor.yy254=0; }
#line 2377 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 5: /* element ::= lvalue ASSIGN rvalue */
#line 514 "pikchr.y"
{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy73,&yymsp[-1].minor.yy0); yylhsminor.yy254=0;}
#line 2383 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 6: /* element ::= PLACENAME COLON unnamed_element */
#line 516 "pikchr.y"
{ yylhsminor.yy254 = yymsp[0].minor.yy254;  pik_elem_setname(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0); }
#line 2389 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 7: /* element ::= PLACENAME COLON position */
#line 518 "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 2396 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 8: /* element ::= unnamed_element */
#line 520 "pikchr.y"
{yylhsminor.yy254 = yymsp[0].minor.yy254;}
#line 2402 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 9: /* element ::= print prlist */
#line 521 "pikchr.y"
{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy254=0;}
#line 2408 "pikchr.c"
        break;
      case 10: /* element ::= ASSERT LP expr EQ expr RP */
#line 526 "pikchr.y"
{yymsp[-5].minor.yy254=pik_assert(p,yymsp[-3].minor.yy73,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy73);}
#line 2413 "pikchr.c"
        break;
      case 11: /* element ::= ASSERT LP place EQ place RP */
#line 528 "pikchr.y"
{yymsp[-5].minor.yy254=pik_place_assert(p,&yymsp[-3].minor.yy139,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy139);}
#line 2418 "pikchr.c"
        break;
      case 12: /* rvalue ::= PLACENAME */
#line 539 "pikchr.y"
{yylhsminor.yy73 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
#line 2423 "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 544 "pikchr.y"
{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
#line 2431 "pikchr.c"
        break;
      case 16: /* pritem ::= rvalue */
#line 547 "pikchr.y"
{pik_append_num(p,"",yymsp[0].minor.yy73);}
#line 2436 "pikchr.c"
        break;
      case 17: /* pritem ::= STRING */
#line 548 "pikchr.y"
{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
#line 2441 "pikchr.c"
        break;
      case 18: /* prsep ::= COMMA */
#line 549 "pikchr.y"
{pik_append(p, " ", 1);}
#line 2446 "pikchr.c"
        break;
      case 19: /* unnamed_element ::= basetype attribute_list */
#line 552 "pikchr.y"
{yylhsminor.yy254 = yymsp[-1].minor.yy254; pik_after_adding_attributes(p,yylhsminor.yy254);}
#line 2451 "pikchr.c"
  yymsp[-1].minor.yy254 = yylhsminor.yy254;
        break;
      case 20: /* basetype ::= CLASSNAME */
#line 554 "pikchr.y"
{yylhsminor.yy254 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
#line 2457 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 21: /* basetype ::= STRING textposition */
#line 556 "pikchr.y"
{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy74; yylhsminor.yy254 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
#line 2463 "pikchr.c"
  yymsp[-1].minor.yy254 = yylhsminor.yy254;
        break;
      case 22: /* basetype ::= LB savelist element_list RB */
#line 558 "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 2469 "pikchr.c"
        break;
      case 23: /* savelist ::= */
#line 563 "pikchr.y"
{yymsp[1].minor.yy72 = p->list; p->list = 0;}
#line 2474 "pikchr.c"
        break;
      case 24: /* relexpr ::= expr */
#line 570 "pikchr.y"
{yylhsminor.yy60.rAbs = yymsp[0].minor.yy73; yylhsminor.yy60.rRel = 0;}
#line 2479 "pikchr.c"
  yymsp[0].minor.yy60 = yylhsminor.yy60;
        break;
      case 25: /* relexpr ::= expr PERCENT */
#line 571 "pikchr.y"
{yylhsminor.yy60.rAbs = 0; yylhsminor.yy60.rRel = yymsp[-1].minor.yy73/100;}
#line 2485 "pikchr.c"
  yymsp[-1].minor.yy60 = yylhsminor.yy60;
        break;
      case 26: /* optrelexpr ::= */
#line 573 "pikchr.y"
{yymsp[1].minor.yy60.rAbs = 0; yymsp[1].minor.yy60.rRel = 1.0;}
#line 2491 "pikchr.c"
        break;
      case 27: /* attribute_list ::= relexpr alist */
#line 575 "pikchr.y"
{pik_add_direction(p,0,&yymsp[-1].minor.yy60);}
#line 2496 "pikchr.c"
        break;
      case 28: /* attribute ::= numproperty relexpr */
#line 579 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy60); }
#line 2501 "pikchr.c"
        break;
      case 29: /* attribute ::= dashproperty expr */
#line 580 "pikchr.y"
{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy73); }
#line 2506 "pikchr.c"
        break;
      case 30: /* attribute ::= dashproperty */
#line 581 "pikchr.y"
{ pik_set_dashed(p,&yymsp[0].minor.yy0,0);  }
#line 2511 "pikchr.c"
        break;
      case 31: /* attribute ::= colorproperty rvalue */
#line 582 "pikchr.y"
{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy73); }
#line 2516 "pikchr.c"
        break;
      case 32: /* attribute ::= go direction optrelexpr */
#line 583 "pikchr.y"
{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy60);}
#line 2521 "pikchr.c"
        break;
      case 33: /* attribute ::= go direction even position */
#line 584 "pikchr.y"
{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy139);}
#line 2526 "pikchr.c"
        break;
      case 34: /* attribute ::= CLOSE */
#line 585 "pikchr.y"
{ pik_close_path(p,&yymsp[0].minor.yy0); }
#line 2531 "pikchr.c"
        break;
      case 35: /* attribute ::= CHOP */
#line 586 "pikchr.y"
{ p->cur->bChop = 1; }
#line 2536 "pikchr.c"
        break;
      case 36: /* attribute ::= FROM position */
#line 587 "pikchr.y"
{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy139); }
#line 2541 "pikchr.c"
        break;
      case 37: /* attribute ::= TO position */
#line 588 "pikchr.y"
{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy139); }
#line 2546 "pikchr.c"
        break;
      case 38: /* attribute ::= THEN */
#line 589 "pikchr.y"
{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
#line 2551 "pikchr.c"
        break;
      case 39: /* attribute ::= THEN optrelexpr HEADING expr */
      case 41: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==41);
#line 591 "pikchr.y"
{pik_move_hdg(p,&yymsp[-2].minor.yy60,&yymsp[-1].minor.yy0,yymsp[0].minor.yy73,0,&yymsp[-3].minor.yy0);}
#line 2557 "pikchr.c"
        break;
      case 40: /* attribute ::= THEN optrelexpr EDGEPT */
      case 42: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==42);
#line 592 "pikchr.y"
{pik_move_hdg(p,&yymsp[-1].minor.yy60,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
#line 2563 "pikchr.c"
        break;
      case 43: /* attribute ::= AT position */
#line 597 "pikchr.y"
{ pik_set_at(p,0,&yymsp[0].minor.yy139,&yymsp[-1].minor.yy0); }
#line 2568 "pikchr.c"
        break;
      case 44: /* attribute ::= SAME */
#line 599 "pikchr.y"
{pik_same(p,0,&yymsp[0].minor.yy0);}
#line 2573 "pikchr.c"
        break;
      case 45: /* attribute ::= SAME AS object */
#line 600 "pikchr.y"
{pik_same(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2578 "pikchr.c"
        break;
      case 46: /* attribute ::= STRING textposition */
#line 601 "pikchr.y"
{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy74);}
#line 2583 "pikchr.c"
        break;
      case 47: /* attribute ::= FIT */
#line 602 "pikchr.y"
{pik_size_to_fit(p,&yymsp[0].minor.yy0); }
#line 2588 "pikchr.c"
        break;
      case 48: /* attribute ::= BEHIND object */
#line 603 "pikchr.y"
{pik_behind(p,yymsp[0].minor.yy254);}
#line 2593 "pikchr.c"
        break;
      case 49: /* withclause ::= DOT_E edge AT position */
      case 50: /* withclause ::= edge AT position */ yytestcase(yyruleno==50);
#line 611 "pikchr.y"
{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy139,&yymsp[-1].minor.yy0); }
#line 2599 "pikchr.c"
        break;
      case 51: /* numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
#line 615 "pikchr.y"
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
#line 2604 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 52: /* boolproperty ::= CW */
#line 626 "pikchr.y"
{p->cur->cw = 1;}
#line 2610 "pikchr.c"
        break;
      case 53: /* boolproperty ::= CCW */
#line 627 "pikchr.y"
{p->cur->cw = 0;}
#line 2615 "pikchr.c"
        break;
      case 54: /* boolproperty ::= LARROW */
#line 628 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=0; }
#line 2620 "pikchr.c"
        break;
      case 55: /* boolproperty ::= RARROW */
#line 629 "pikchr.y"
{p->cur->larrow=0; p->cur->rarrow=1; }
#line 2625 "pikchr.c"
        break;
      case 56: /* boolproperty ::= LRARROW */
#line 630 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=1; }
#line 2630 "pikchr.c"
        break;
      case 57: /* boolproperty ::= INVIS */
#line 631 "pikchr.y"
{p->cur->sw = 0.0;}
#line 2635 "pikchr.c"
        break;
      case 58: /* boolproperty ::= THICK */
#line 632 "pikchr.y"
{p->cur->sw *= 1.5;}
#line 2640 "pikchr.c"
        break;
      case 59: /* boolproperty ::= THIN */
#line 633 "pikchr.y"
{p->cur->sw *= 0.67;}
#line 2645 "pikchr.c"
        break;
      case 60: /* textposition ::= */
#line 635 "pikchr.y"
{yymsp[1].minor.yy74 = 0;}
#line 2650 "pikchr.c"
        break;
      case 61: /* textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|ALIGNED|BIG|SMALL */
#line 638 "pikchr.y"
{yylhsminor.yy74 = pik_text_position(yymsp[-1].minor.yy74,&yymsp[0].minor.yy0);}
#line 2655 "pikchr.c"
  yymsp[-1].minor.yy74 = yylhsminor.yy74;
        break;
      case 62: /* position ::= expr COMMA expr */
#line 641 "pikchr.y"
{yylhsminor.yy139.x=yymsp[-2].minor.yy73; yylhsminor.yy139.y=yymsp[0].minor.yy73;}
#line 2661 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 63: /* position ::= place PLUS expr COMMA expr */
#line 643 "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 2667 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 64: /* position ::= place MINUS expr COMMA expr */
#line 644 "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 65: /* position ::= place PLUS LP expr COMMA expr RP */
#line 646 "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 2679 "pikchr.c"
  yymsp[-6].minor.yy139 = yylhsminor.yy139;
        break;
      case 66: /* position ::= place MINUS LP expr COMMA expr RP */
#line 648 "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 67: /* position ::= LP position COMMA position RP */
#line 649 "pikchr.y"
{yymsp[-4].minor.yy139.x=yymsp[-3].minor.yy139.x; yymsp[-4].minor.yy139.y=yymsp[-1].minor.yy139.y;}
#line 2691 "pikchr.c"
        break;
      case 68: /* position ::= LP position RP */
#line 650 "pikchr.y"
{yymsp[-2].minor.yy139=yymsp[-1].minor.yy139;}
#line 2696 "pikchr.c"
        break;
      case 69: /* position ::= expr between position AND position */
#line 652 "pikchr.y"
{yylhsminor.yy139 = pik_position_between(yymsp[-4].minor.yy73,yymsp[-2].minor.yy139,yymsp[0].minor.yy139);}
#line 2701 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 70: /* position ::= expr LT position COMMA position GT */
#line 654 "pikchr.y"
{yylhsminor.yy139 = pik_position_between(yymsp[-5].minor.yy73,yymsp[-3].minor.yy139,yymsp[-1].minor.yy139);}
#line 2707 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 71: /* position ::= expr ABOVE position */
#line 655 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.y += yymsp[-2].minor.yy73;}
#line 2713 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 72: /* position ::= expr BELOW position */
#line 656 "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 73: /* position ::= expr LEFT OF position */
#line 657 "pikchr.y"
{yylhsminor.yy139=yymsp[0].minor.yy139; yylhsminor.yy139.x -= yymsp[-3].minor.yy73;}
#line 2725 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 74: /* position ::= expr RIGHT OF position */
#line 658 "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 75: /* position ::= expr ON HEADING EDGEPT OF position */
#line 660 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(yymsp[-5].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2737 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 76: /* position ::= expr HEADING EDGEPT OF position */
#line 662 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(yymsp[-4].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2743 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 77: /* position ::= expr EDGEPT OF position */
#line 664 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_hdg(yymsp[-3].minor.yy73,&yymsp[-2].minor.yy0,yymsp[0].minor.yy139);}
#line 2749 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 78: /* position ::= expr ON HEADING expr FROM position */
#line 666 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_angle(yymsp[-5].minor.yy73,yymsp[-2].minor.yy73,yymsp[0].minor.yy139);}
#line 2755 "pikchr.c"
  yymsp[-5].minor.yy139 = yylhsminor.yy139;
        break;
      case 79: /* position ::= expr HEADING expr FROM position */
#line 668 "pikchr.y"
{yylhsminor.yy139 = pik_position_at_angle(yymsp[-4].minor.yy73,yymsp[-2].minor.yy73,yymsp[0].minor.yy139);}
#line 2761 "pikchr.c"
  yymsp[-4].minor.yy139 = yylhsminor.yy139;
        break;
      case 80: /* place ::= edge OF object */
#line 680 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2767 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 81: /* place2 ::= object */
#line 681 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[0].minor.yy254,0);}
#line 2773 "pikchr.c"
  yymsp[0].minor.yy139 = yylhsminor.yy139;
        break;
      case 82: /* place2 ::= object DOT_E edge */
#line 682 "pikchr.y"
{yylhsminor.yy139 = pik_place_of_elem(p,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2779 "pikchr.c"
  yymsp[-2].minor.yy139 = yylhsminor.yy139;
        break;
      case 83: /* place2 ::= NTH VERTEX OF object */
#line 683 "pikchr.y"
{yylhsminor.yy139 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy254);}
#line 2785 "pikchr.c"
  yymsp[-3].minor.yy139 = yylhsminor.yy139;
        break;
      case 84: /* object ::= nth */
#line 695 "pikchr.y"
{yylhsminor.yy254 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
#line 2791 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 85: /* object ::= nth OF|IN object */
#line 696 "pikchr.y"
{yylhsminor.yy254 = pik_find_nth(p,yymsp[0].minor.yy254,&yymsp[-2].minor.yy0);}
#line 2797 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 86: /* objectname ::= PLACENAME */
#line 698 "pikchr.y"
{yylhsminor.yy254 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
#line 2803 "pikchr.c"
  yymsp[0].minor.yy254 = yylhsminor.yy254;
        break;
      case 87: /* objectname ::= objectname DOT_U PLACENAME */
#line 700 "pikchr.y"
{yylhsminor.yy254 = pik_find_byname(p,yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2809 "pikchr.c"
  yymsp[-2].minor.yy254 = yylhsminor.yy254;
        break;
      case 88: /* nth ::= NTH CLASSNAME */
#line 702 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
#line 2815 "pikchr.c"
  yymsp[-1].minor.yy0 = yylhsminor.yy0;
        break;
      case 89: /* nth ::= NTH LAST CLASSNAME */
#line 703 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
#line 2821 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 90: /* nth ::= LAST CLASSNAME */
#line 704 "pikchr.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
#line 2827 "pikchr.c"
        break;
      case 91: /* nth ::= LAST */
#line 705 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
#line 2832 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 92: /* nth ::= NTH LB RB */
#line 706 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
#line 2838 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 93: /* nth ::= NTH LAST LB RB */
#line 707 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
#line 2844 "pikchr.c"
  yymsp[-3].minor.yy0 = yylhsminor.yy0;
        break;
      case 94: /* nth ::= LAST LB RB */
#line 708 "pikchr.y"
{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
#line 2850 "pikchr.c"
        break;
      case 95: /* expr ::= expr PLUS expr */
#line 710 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73+yymsp[0].minor.yy73;}
#line 2855 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 96: /* expr ::= expr MINUS expr */
#line 711 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73-yymsp[0].minor.yy73;}
#line 2861 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 97: /* expr ::= expr STAR expr */
#line 712 "pikchr.y"
{yylhsminor.yy73=yymsp[-2].minor.yy73*yymsp[0].minor.yy73;}
#line 2867 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 98: /* expr ::= expr SLASH expr */
#line 713 "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 2876 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 99: /* expr ::= MINUS expr */
#line 717 "pikchr.y"
{yymsp[-1].minor.yy73=-yymsp[0].minor.yy73;}
#line 2882 "pikchr.c"
        break;
      case 100: /* expr ::= PLUS expr */
#line 718 "pikchr.y"
{yymsp[-1].minor.yy73=yymsp[0].minor.yy73;}
#line 2887 "pikchr.c"
        break;
      case 101: /* expr ::= LP expr RP */
#line 719 "pikchr.y"
{yymsp[-2].minor.yy73=yymsp[-1].minor.yy73;}
#line 2892 "pikchr.c"
        break;
      case 102: /* expr ::= NUMBER */
#line 720 "pikchr.y"
{yylhsminor.yy73=pik_atof(&yymsp[0].minor.yy0);}
#line 2897 "pikchr.c"
  yymsp[0].minor.yy73 = yylhsminor.yy73;
        break;
      case 103: /* expr ::= ID */
#line 721 "pikchr.y"
{yylhsminor.yy73=pik_get_var(p,&yymsp[0].minor.yy0);}
#line 2903 "pikchr.c"
  yymsp[0].minor.yy73 = yylhsminor.yy73;
        break;
      case 104: /* expr ::= FUNC1 LP expr RP */
#line 722 "pikchr.y"
{yylhsminor.yy73 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy73,0.0);}
#line 2909 "pikchr.c"
  yymsp[-3].minor.yy73 = yylhsminor.yy73;
        break;
      case 105: /* expr ::= FUNC2 LP expr COMMA expr RP */
#line 723 "pikchr.y"
{yylhsminor.yy73 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy73,yymsp[-1].minor.yy73);}
#line 2915 "pikchr.c"
  yymsp[-5].minor.yy73 = yylhsminor.yy73;
        break;
      case 106: /* expr ::= place2 DOT_XY X */
#line 724 "pikchr.y"
{yylhsminor.yy73 = yymsp[-2].minor.yy139.x;}
#line 2921 "pikchr.c"
  yymsp[-2].minor.yy73 = yylhsminor.yy73;
        break;
      case 107: /* expr ::= place2 DOT_XY Y */
#line 725 "pikchr.y"
{yylhsminor.yy73 = yymsp[-2].minor.yy139.y;}
#line 2927 "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 726 "pikchr.y"
{yylhsminor.yy73=pik_property_of(yymsp[-2].minor.yy254,&yymsp[0].minor.yy0);}
#line 2935 "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 492 "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 3046 "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 731 "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

    }
    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);
    pik_append_dis(p, " viewBox=\"0 0 ",w,"");
    pik_append_dis(p, " ",h,"\">\n");













    pik_elist_render(p, pEList);
    pik_append(p,"</svg>\n", -1);
  }else{
    p->wSVG = -1;
    p->hSVG = -1;
  }
  pik_elist_free(p, pEList);

  free(zIn);
  free(zOut);
  return 0;
}
#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.\n"
    "Options:\n"
    "   --svg-only       Omit raw SVG without the HTML wrapper\n"
  );
  exit(1);
}

/* Send text to standard output, but escape HTML markup */
static void print_escape_html(const char *z){
  int j;
  char c;
  while( z[0]!=0 ){
    for(j=0; (c = z[j])!=0 && c!='<' && c!='>' && c!='&'; j++){}
    if( j ) printf("%.*s", j, z);
    z += j+1;
    j = -1;
    if( c=='<' ){
      printf("&lt;");
    }else if( c=='>' ){
      printf("&gt;");
    }else if( c=='&' ){
      printf("&amp;");
    }else if( c==0 ){
      break;
    }
  }
}

/* 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.
*/
int main(int argc, char **argv){
  int i;
  int bSvgOnly = 0;            /* Output SVG only.  No HTML wrapper */
  const char *zHtmlHdr = 

    "<!DOCTYPE html>\n"
    "<html lang=\"en-US\">\n"
    "<head>\n<title>PIKCHR Test</title>\n"
    "<style>\n"
    "  .hidden {\n"
    "     position: absolute !important;\n"
    "     opacity: 0 !important;\n"
    "     pointer-events: none !important;\n"
    "     display: none !important;\n"
    "  }\n"
    "</style>\n"
    "<script>\n"
    "  function toggleHidden(id){\n"
    "    for(var c of document.getElementById(id).children){\n"
    "      c.classList.toggle('hidden');\n"
    "    }\n"
    "  }\n"
    "</script>\n"
    "<meta charset=\"utf-8\">\n"
    "</head>\n"
    "<body>\n"

  ;
  if( argc<2 ) usage(argv[0]);
  for(i=1; i<argc; i++){
    FILE *in;
    size_t sz;
    char *zIn;
    char *zOut;


    int w, h;

    if( argv[i][0]=='-' ){
      char *z = argv[i];
      z++;
      if( z[0]=='-' ) z++;
      if( strcmp(z,"svg-only")==0 ){
        if( zHtmlHdr==0 ){
          fprintf(stderr, "the \"%s\" option must come first\n",argv[i]);
          exit(1);
        }
        bSvgOnly = 1;



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

    in = fopen(argv[i], "rb");
    if( in==0 ){
      fprintf(stderr, "cannot open \"%s\" for reading\n", argv[i]);
      continue;
    }
    fseek(in, 0, SEEK_END);
    sz = ftell(in);
    rewind(in);
    zIn = malloc( sz+1 );
    if( zIn==0 ){
      fprintf(stderr, "cannot allocate space for file \"%s\"\n", argv[i]);
      fclose(in);
      continue;
    }
    sz = fread(zIn, 1, sz, in);
    fclose(in);
    zIn[sz] = 0;


    zOut = pikchr(zIn, "pikchr", 0, &w, &h);
    if( zOut==0 ){

      fprintf(stderr, "pikchr() returns NULL.  Out of memory?\n");

      exit(1);
    }
    if( bSvgOnly ){
      printf("%s\n", zOut);
    }else{

      if( zHtmlHdr ){
        printf("%s", zHtmlHdr);

        zHtmlHdr = 0;
      }

      printf("<h1>File %s</h1>\n", argv[i]);




      if( w<0 ){
        printf("<p>ERROR</p>\n%s\n", zOut);
      }else{
        printf("<div id=\"svg-%d\" onclick=\"toggleHidden('svg-%d')\">\n",i,i);

        printf("<div style='border:3px solid lightgray;max-width:%dpx;'>\n",w);
        printf("%s</div>\n", zOut);
        printf("<pre class='hidden'>");
        print_escape_html(zIn);
        printf("</pre>\n</div>\n");
      }
    }
    free(zOut);
    free(zIn);
  }

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

#line 7111 "pikchr.c"

  sqlite3_stmt *p1 = 0;
  int nCol = 0;
  int nTab = STRLEN(zTab);
  int nByte = sizeof(IdxTable) + nTab + 1;
  IdxTable *pNew = 0;
  int rc, rc2;
  char *pCsr = 0;
  int nPk = 0;

  rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_info=%Q", zTab);
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
    const char *zCol = (const char*)sqlite3_column_text(p1, 1);
    nByte += 1 + STRLEN(zCol);
    rc = sqlite3_table_column_metadata(
        db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
    );
    nByte += 1 + STRLEN(zCol);
    nCol++;
    nPk += (sqlite3_column_int(p1, 5)>0);
  }
  rc2 = sqlite3_reset(p1);
  if( rc==SQLITE_OK ) rc = rc2;

  nByte += sizeof(IdxColumn) * nCol;
  if( rc==SQLITE_OK ){
    pNew = idxMalloc(&rc, nByte);
  }
  if( rc==SQLITE_OK ){
    pNew->aCol = (IdxColumn*)&pNew[1];
    pNew->nCol = nCol;
    pCsr = (char*)&pNew->aCol[nCol];
  }

  nCol = 0;
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
    const char *zCol = (const char*)sqlite3_column_text(p1, 1);
    int nCopy = STRLEN(zCol) + 1;
    pNew->aCol[nCol].zName = pCsr;
    pNew->aCol[nCol].iPk = (sqlite3_column_int(p1, 5)==1 && nPk==1);
    memcpy(pCsr, zCol, nCopy);
    pCsr += nCopy;

    rc = sqlite3_table_column_metadata(
        db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
    );
    if( rc==SQLITE_OK ){

**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.34.0"
#define SQLITE_VERSION_NUMBER 3034000
#define SQLITE_SOURCE_ID      "2020-09-17 21:11:25 4542d194e2fef5e21e1c3679914bd9e21fab31cfb111cf640524fb3514a8afa3"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros

** parameter passed to the preupdate callback is the initial [rowid] of the
** row being modified or deleted. For an INSERT operation on a rowid table,
** or any operation on a WITHOUT ROWID table, the value of the sixth
** parameter is undefined. For an INSERT or UPDATE on a rowid table the
** seventh parameter is the final rowid value of the row being inserted
** or updated. The value of the seventh parameter passed to the callback
** function is not defined for operations on WITHOUT ROWID tables, or for
** DELETE operations on rowid tables.
**
** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()],
** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces
** provide additional information about a preupdate event. These routines
** may only be called from within a preupdate callback.  Invoking any of
** these routines from outside of a preupdate callback or with a
** [database connection] pointer that is different from the one supplied

**     SRT_Exists      Store a 1 in memory cell pDest->iSDParm if the result
**                     set is not empty.
**
**     SRT_Discard     Throw the results away.  This is used by SELECT
**                     statements within triggers whose only purpose is
**                     the side-effects of functions.
**



**     SRT_Output      Generate a row of output (using the OP_ResultRow
**                     opcode) for each row in the result set.
**
**     SRT_Mem         Only valid if the result is a single column.
**                     Store the first column of the first result row
**                     in register pDest->iSDParm then abandon the rest
**                     of the query.  This destination implies "LIMIT 1".

**                     table. (pDest->iSDParm) is the number of key columns in
**                     each index record in this case.
*/
#define SRT_Union        1  /* Store result as keys in an index */
#define SRT_Except       2  /* Remove result from a UNION index */
#define SRT_Exists       3  /* Store 1 if the result is not empty */
#define SRT_Discard      4  /* Do not save the results anywhere */
#define SRT_DistFifo     5  /* Like SRT_Fifo, but unique results only */
#define SRT_DistQueue    6  /* Like SRT_Queue, but unique results only */

/* The DISTINCT clause is ignored for all of the above.  Not that
** IgnorableDistinct() implies IgnorableOrderby() */
#define IgnorableDistinct(X) ((X->eDest)<=SRT_DistQueue)

#define SRT_Queue        7  /* Store result in an queue */
#define SRT_Fifo         8  /* Store result as data with an automatic rowid */

/* The ORDER BY clause is ignored for all of the above */
#define IgnorableOrderby(X) ((X->eDest)<=SRT_Fifo)

#define SRT_Output       9  /* Output each row of result */
#define SRT_Mem         10  /* Store result in a memory cell */
#define SRT_Set         11  /* Store results as keys in an index */
#define SRT_EphemTab    12  /* Create transient tab and store like SRT_Table */
#define SRT_Coroutine   13  /* Generate a single row of result */
#define SRT_Table       14  /* Store result as data with an automatic rowid */

      addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
        pParent = sqlite3FindTable(db, pFK->zTo, zDb);
        pIdx = 0;
        aiCols = 0;
        if( pParent ){
          x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
          assert( x==0 || db->mallocFailed );
        }
        addrOk = sqlite3VdbeMakeLabel(pParse);

        /* Generate code to read the child key values into registers
        ** regRow..regRow+n. If any of the child key values are NULL, this
        ** row cannot cause an FK violation. Jump directly to addrOk in
        ** this case. */

              sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
          sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0);
          VdbeCoverage(v);
        }else if( pParent ){
          int jmp = sqlite3VdbeCurrentAddr(v)+2;
          sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v);
          sqlite3VdbeGoto(v, addrOk);
          assert( pFK->nCol==1 || db->mallocFailed );
        }

        /* Generate code to report an FK violation to the caller. */
        if( HasRowid(pTab) ){
          sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);
        }else{
          sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1);

  }
#endif

  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_Queue );
  if( IgnorableDistinct(pDest) ){
    assert(pDest->eDest==SRT_Exists     || pDest->eDest==SRT_Union ||
           pDest->eDest==SRT_Except     || pDest->eDest==SRT_Discard ||

           pDest->eDest==SRT_DistQueue  || pDest->eDest==SRT_DistFifo );
    /* All of these destinations are also able to ignore the ORDER BY clause */

    sqlite3ExprListDelete(db, p->pOrderBy);
    p->pOrderBy = 0;
    p->selFlags &= ~SF_Distinct;
    p->selFlags |= SF_NoopOrderBy;
  }
  sqlite3SelectPrep(pParse, p, 0);
  if( pParse->nErr || db->mallocFailed ){

    sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
    sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1);
    sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
                      pLoop->u.vtab.idxStr,
                      pLoop->u.vtab.needFree ? P4_DYNAMIC : P4_STATIC);
    VdbeCoverage(v);
    pLoop->u.vtab.needFree = 0;
    /* An OOM inside of AddOp4(OP_VFilter) instruction above might have freed
    ** the u.vtab.idxStr.  NULL it out to prevent a use-after-free */
    if( db->mallocFailed ) pLoop->u.vtab.idxStr = 0;
    pLevel->p1 = iCur;
    pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext;
    pLevel->p2 = sqlite3VdbeCurrentAddr(v);
    iIn = pLevel->u.in.nIn;
    for(j=nConstraint-1; j>=0; j--){
      pTerm = pLoop->aLTerm[j];
      if( (pTerm->eOperator & WO_IN)!=0 ) iIn--;

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

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

  /* If the root node was just loaded, set pRtree->iDepth to the height
  ** of the r-tree structure. A height of zero means all data is stored on
  ** the root node. A height of one means the children of the root node
  ** are the leaves, and so on. If the depth as specified on the root node
  ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
  */
  if( pNode && rc==SQLITE_OK && iNode==1 ){
    pRtree->iDepth = readInt16(pNode->zData);
    if( pRtree->iDepth>RTREE_MAX_DEPTH ){
      rc = SQLITE_CORRUPT_VTAB;
      RTREE_IS_CORRUPT(pRtree);
    }
  }

#endif /* NDEBUG */
          return fts5yy_action[j];
        }
      }
#endif /* fts5YYWILDCARD */
      return fts5yy_default[stateno];
    }else{
      assert( i>=0 && i<(int)(sizeof(fts5yy_action)/sizeof(fts5yy_action[0])) );
      return fts5yy_action[i];
    }
  }while(1);
}

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

    p->iSzPoslist = p->nData;
    if( pHash->eDetail!=FTS5_DETAIL_NONE ){
      p->nData += 1;
      p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
    }


  }else{

    /* Appending to an existing hash-entry. Check that there is enough
    ** space to append the largest possible new entry. Worst case scenario
    ** is:
    **
    **     + 9 bytes for a new rowid,

        memset(&writer, 0, sizeof(writer));

        /* See the earlier comment in this function for an explanation of why
        ** corrupt input position lists might cause the output to consume
        ** at most 20 bytes of unexpected space. */
        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
        fts5BufferZero(&tmp);
        sqlite3Fts5BufferSize(&p->rc, &tmp,
            i1.nPoslist + i2.nPoslist + 10 + 10 + FTS5_DATA_ZERO_PADDING
        );
        if( p->rc ) break;

        sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
        sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
        assert_nc( iPos1>=0 && iPos2>=0 );

        if( iPos1<iPos2 ){

    }
    else if( i2.aPoslist ){
      fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
      fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.aEof - i2.aPoslist);
    }
    assert_nc( out.n<=(p1->n+p2->n+9) );


    fts5BufferFree(p1);
    fts5BufferFree(&tmp);
    memset(&out.p[out.n], 0, FTS5_DATA_ZERO_PADDING);
    *p1 = out;
  }
}

static void fts5SetupPrefixIter(
  Fts5Index *p,                   /* Index to read from */
  int bDesc,                      /* True for "ORDER BY rowid DESC" */
  const u8 *pToken,               /* Buffer containing prefix to match */

static void fts5SourceIdFunc(
  sqlite3_context *pCtx,          /* Function call context */
  int nArg,                       /* Number of args */
  sqlite3_value **apUnused        /* Function arguments */
){
  assert( nArg==0 );
  UNUSED_PARAM2(nArg, apUnused);
  sqlite3_result_text(pCtx, "fts5: 2020-09-17 21:11:25 4542d194e2fef5e21e1c3679914bd9e21fab31cfb111cf640524fb3514a8afa3", -1, SQLITE_TRANSIENT);
}

/*
** Return true if zName is the extension on one of the shadow tables used
** by this module.
*/
static int fts5ShadowName(const char *zName){

#endif
  return rc;
}
#endif /* SQLITE_CORE */
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */

/************** End of stmt.c ************************************************/
#if __LINE__!=230950
#undef SQLITE_SOURCE_ID
#define SQLITE_SOURCE_ID      "2020-09-17 21:11:25 4542d194e2fef5e21e1c3679914bd9e21fab31cfb111cf640524fb3514a8alt2"
#endif
/* Return the source-id for this library */
SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
/************************** End of sqlite3.c ******************************/