compat/zlib/*
setup/fossil.iss
test/th1-docs-input.txt
test/th1-hooks-input.txt
win/build32.bat
win/build64.bat
win/buildmsvc.bat

compat/openssl*
compat/tcl*
compat/zlib/contrib/ada/*
compat/zlib/doc/*
fossil
fossil.exe
win/fossil.exe
*shell-see.*
*sqlite3-see.*
bld

# syntax=docker/dockerfile:1.3
# See www/containers.md for documentation on how to use this file.

## ---------------------------------------------------------------------
## STAGE 1: Build static Fossil binary
## ---------------------------------------------------------------------

### We don't pin a more stable version of our base layer because we want
### to build with the latest tools and libraries available in case they
### fixed something that matters to us since the last build.  Everything
### below depends on this layer, and so, alas, we toss this container's
### cache on Alpine's release schedule, roughly once a month.
FROM alpine:latest AS bld
WORKDIR /fsl

### Bake the build-time userland into a base layer so it only changes
### when the upstream image is updated or we change the package set.
RUN set -x                                                             \
    && apk update                                                      \
    && apk upgrade --no-cache                                          \
    && apk add --no-cache                                              \
         gcc make                                                      \
         linux-headers musl-dev                                        \
         openssl-dev openssl-libs-static                               \
         zlib-dev zlib-static

### Build Fossil as a separate layer so we don't have to rebuild the
### userland for each iteration of Fossil's dev cycle.
###
### We must cope with a bizarre ADD misfeature here: it unpacks tarballs
### automatically when you give it a local file name but not if you give
### it a /tarball URL!  It matters because we default to a URL in case
### you're building outside a Fossil checkout, but when building via the
### container-image target, we avoid a costly hit on fossil-scm.org by
### leveraging its DVCS nature via the "tarball" command and passing the
### resulting file's name in.
ARG FSLCFG=""
ARG FSLVER="trunk"
ARG FSLURL="https://fossil-scm.org/home/tarball/src?r=${FSLVER}"
ENV FSLSTB=/fsl/src.tar.gz
ADD $FSLURL $FSLSTB
RUN set -x                                                             \
    && if [ -d $FSLSTB ] ;                                             \

# You should not need to change anything below this line
###############################################################################
#
# Automatic platform-specific options.
HOST_OS_CMD = uname -s
HOST_OS = $(HOST_OS_CMD:sh)

LIB.SunOS= -lsocket -lnsl -lrt
LIB += $(LIB.$(HOST_OS))

TCC.DragonFly += -DUSE_PREAD
TCC.FreeBSD += -DUSE_PREAD
TCC.NetBSD += -DUSE_PREAD
TCC.OpenBSD += -DUSE_PREAD
TCC += $(TCC.$(HOST_OS))

2.27

    compile-commands=0 =>
      "Check for compile_commands.json support."
}

# Update the minimum required SQLite version number here, and also
# in src/main.c near the sqlite3_libversion_number() call.  Take care
# that both places agree!
define MINIMUM_SQLITE_VERSION "3.49.0"

# This is useful for people wanting Fossil to use an external SQLite library
# to compare the one they have against the minimum required
if {[opt-bool print-minimum-sqlite-version]} {
  puts [get-define MINIMUM_SQLITE_VERSION]
  exit 0
}

# Space characters have never been allowed in either the source
# tree nor the build directory.  But the resulting error messages
# could be confusing.  The following checks make the reason for the
# failure clear.
#
if {[string first " " $autosetup(srcdir)] != -1} {
  user-error "The pathname of the source tree\
              may not contain space characters"
}
if {[string first " " $autosetup(builddir)] != -1} {
  user-error "The pathname of the build directory\
              may not contain space characters"
}

set outOfTreeBuild 0
if {![file exists fossil.1]} {
  puts "This appears to be an out-of-tree build."
  set outOfTreeBuild 1
}

# sqlite wants these types if possible
cc-with {-includes {stdint.h inttypes.h}} {
  cc-check-types uint32_t uint16_t int16_t uint8_t
}

# Use pread/pwrite system calls in place of seek + read/write if possible
define USE_PREAD [cc-check-functions pread]

# If we have cscope here, we'll use it in the "tags" target
if {[cc-check-progs cscope]} {
  define COLLECT_CSCOPE_DATA "cscope -bR $::autosetup(srcdir)/src/*.\[ch\]"
} else {
  define COLLECT_CSCOPE_DATA ""
}

# Find tclsh for the test suite.
#
# We can't use jimsh for this: the test suite uses features of Tcl that
# Jim doesn't support, either statically or due to the way it's built by
# autosetup.  For example, Jim supports `file normalize`, but only if
# you build it with HAVE_REALPATH, which won't ever be defined in this
# context because autosetup doesn't try to discover platform-specific
# details like that before it decides to build jimsh0.  Besides which,
# autosetup won't build jimsh0 at all if it can find tclsh itself.
# Ironically, this means we may right now be running under either jimsh0
# or a version of tclsh that we find unsuitable below!
cc-check-progs tclsh
set hbtd /usr/local/Cellar/tcl-tk
if {[string equal false [get-define TCLSH]]} {
  msg-result "WARNING: 'make test' will not run here."
} else {
  set v [exec sh -c "echo 'puts \$tcl_version' | tclsh"]
  if {[expr {$v >= 8.6}]} {
    msg-result "Found Tclsh version $v in the PATH."
    define TCLSH tclsh
  } elseif {[file isdirectory $hbtd]} {
    # This is a macOS system with the Homebrew version of Tcl/Tk
    # installed.  Select the newest version.  It won't normally be
    # in the PATH to avoid shadowing /usr/bin/tclsh, and even if it
    # were in the PATH, it's bad practice to put /usr/local/bin (the
    # Homebrew default) ahead of /usr/bin, especially given that
    # it's user-writeable by default with Homebrew.  Thus, we can be
    # pretty sure the only way to call it is with an absolute path.
    set v [exec ls -tr $hbtd | tail -1]
    set path "$hbtd/$v/bin/tclsh"
    define TCLSH $path
    msg-result "Using Homebrew Tcl/Tk version $path."
  } else {
    msg-result "WARNING: tclsh $v found; need >= 8.6 for 'make test'."
    define TCLSH false     ;# force "make test" failure via /usr/bin/false
  }
}

define CFLAGS [get-env CFLAGS "-g -Os"]
define EXTRA_CFLAGS "-Wall"
define EXTRA_LDFLAGS ""
define USE_SYSTEM_SQLITE 0
define USE_LINENOISE 0
define USE_MMAN_H 0
define USE_SEE 0
define SQLITE3_ORIGIN 0
# SQLITE3_ORIGIN 0 = src/sqlite3, 1=src/sqlite3-see.c, 2=client-provided
define SQLITE_OPTIONS_EXT ""
# SQLITE_OPTIONS_EXT => build-dependent CFLAGS for sqlite3.c and shell.c

# Maintain the C89/C90-style order of variable declarations before statements.
# Check if the compiler supports the respective warning flag.
if {[cctest -cflags -Wdeclaration-after-statement]} {
  define-append EXTRA_CFLAGS -Wdeclaration-after-statement
}


# This procedure is a customized version of "cc-check-function-in-lib",
# that does not modify the LIBS variable.  Its use prevents prematurely
# pulling in libraries that will be added later anyhow (e.g. "-ldl").
proc check-function-in-lib {function libs {otherlibs {}}} {
  if {[string length $otherlibs]} {
    msg-checking "Checking for $function in $libs with $otherlibs..."
  } else {
    msg-checking "Checking for $function in $libs..."
  }
  set found 0
  cc-with [list -libs $otherlibs] {
    if {[cctest_function $function]} {
      msg-result "none needed"
      define lib_$function ""
      incr found
    } else {
      foreach lib $libs {
        cc-with [list -libs -l$lib] {
          if {[cctest_function $function]} {
            msg-result -l$lib
            define lib_$function -l$lib
            incr found
            break
          }
        }
      }
    }
  }
  if {$found} {
    define [feature-define-name $function]
  } else {
    msg-result "no"
  }
  return $found
}

if {![opt-bool internal-sqlite]} {
  proc find_system_sqlite {} {

    # On some systems (slackware), libsqlite3 requires -ldl to link. So
    # search for the system SQLite once with -ldl, and once without. If

    lappend cmdline {*}[get-define LDFLAGS]
    lappend cmdline {*}[get-define LIBS]
    set sqlite-version [string cat "-D MINIMUM_SQLITE_VERSION=" [get-define MINIMUM_SQLITE_VERSION]]
    lappend cmdline {*}[set sqlite-version]
    set ok 1
    set err [catch {exec-with-stderr {*}$cmdline} result errinfo]
    if {$err} {
      configlog "Failed: [join $cmdline]"
      if {[string length $result]>0} {configlog $result}
      configlog "============"
      set ok 0
    } elseif {$::autosetup(debug)} {
      configlog "Compiled OK: [join $cmdline]"
      configlog "============"
    }
    if {!$ok} {
      user-error "unable to compile SQLite compatibility test program"
    }
    set err [catch {exec-with-stderr ./conftest__} result errinfo]
    if {[get-define build] eq [get-define host]} {
      set err [catch {exec-with-stderr ./conftest__} result errinfo]
      if {$err} {
        user-error $result
      }
    }
    file delete ./conftest__
  }
  test_system_sqlite

}

proc is_mingw {} {
  return [expr {
    [string match *mingw* [get-define host]] &&
   ![file exists "/dev/null"]
  }]
}

if {[is_mingw]} {
  define-append EXTRA_CFLAGS -DBROKEN_MINGW_CMDLINE
  define-append LIBS -lkernel32 -lws2_32
} else {
  #
  # NOTE: All platforms except MinGW should use the linenoise
  #       package.  It is currently unsupported on Win32.
  #
  define USE_LINENOISE 1
}

if {[string match *-solaris* [get-define host]]} {
  define-append EXTRA_CFLAGS {-D__EXTENSIONS__}
}

if {[opt-bool fossil-debug]} {
  define CFLAGS {-g -O0 -Wall}
  define-append CFLAGS -DFOSSIL_DEBUG
  msg-result "Debugging support enabled"
}

if {[opt-bool no-opt]} {
  define CFLAGS {-g -O0 -Wall}
  msg-result "Builting without compiler optimization"
  if {[opt-bool fossil-debug]} {
    define-append CFLAGS -DFOSSIL_DEBUG
  }
}

if {[opt-bool with-mman]} {
  define-append EXTRA_CFLAGS -DUSE_MMAN_H
  define USE_MMAN_H 1
  msg-result "Enabling \"sys/mman.h\" support"
}

if {[opt-bool with-see]} {
  define-append EXTRA_CFLAGS -DUSE_SEE
  define USE_SEE 1
  define SQLITE3_ORIGIN 1
  msg-result "Enabling encryption support"
}

if {[opt-bool json]} {
  # Reminder/FIXME (stephan): FOSSIL_ENABLE_JSON
  # is required in the CFLAGS because json*.c
  # have #ifdef guards around the whole file without
  # reading config.h first.
  define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_JSON
  define FOSSIL_ENABLE_JSON
  msg-result "JSON support enabled"
}

if {[opt-bool with-exec-rel-paths]} {
  define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_EXEC_REL_PATHS
  define FOSSIL_ENABLE_EXEC_REL_PATHS
  msg-result "Relative paths in external diff/gdiff enabled"
}

if {[opt-bool with-th1-docs]} {
  define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_TH1_DOCS
  define FOSSIL_ENABLE_TH1_DOCS
  msg-result "TH1 embedded documentation support enabled"
}

if {[opt-bool with-th1-hooks]} {
  define-append EXTRA_CFLAGS -DFOSSIL_ENABLE_TH1_HOOKS
  define FOSSIL_ENABLE_TH1_HOOKS
  msg-result "TH1 hooks support enabled"
}

#if {[opt-bool markdown]} {
#    # no-op.  Markdown is now enabled by default.
#    msg-result "Markdown support enabled"
#}

if {[opt-bool static]} {
  # XXX: This will not work on all systems.
  define-append EXTRA_LDFLAGS -static
  msg-result "Trying to link statically"
} else {
  define-append EXTRA_CFLAGS -DFOSSIL_DYNAMIC_BUILD=1
  define FOSSIL_DYNAMIC_BUILD
}

# Check for libraries that need to be sorted out early
cc-check-function-in-lib iconv iconv

cc-check-function-in-lib sin m
cc-check-function-in-lib dlopen dl

# Helper for OpenSSL checking
proc check-for-openssl {msg {cflags {}} {libs {-lssl -lcrypto -lpthread}}} {
  msg-checking "Checking for $msg..."
  set rc 0
  if {[is_mingw]} {
    lappend libs -lgdi32 -lwsock32 -lcrypt32
  }
  if {[info exists ::zlib_lib]} {
    lappend libs $::zlib_lib
  }
  msg-quiet cc-with [list -cflags $cflags -libs $libs] {
    if {[cc-check-includes openssl/ssl.h] && \
          [cc-check-functions SSL_new]} {
      incr rc
    }
  }
  if {!$rc && ![is_mingw]} {
    # On some systems, OpenSSL appears to require -ldl to link.
    lappend libs -ldl
    msg-quiet cc-with [list -cflags $cflags -libs $libs] {
      if {[cc-check-includes openssl/ssl.h] && \
            [cc-check-functions SSL_new]} {
        incr rc
      }
    }
  }
  if {$rc} {
    msg-result "ok"
    return 1
  } else {
    msg-result "no"
    return 0
  }
}

#
# Check for zlib, using the given location if specified
#
proc handle-zlib {} {
  set ::zlibpath [opt-val with-zlib]; # used by downstream tcl tests
  if {$::zlibpath eq "tree"} {
    set ::zlibdir [file dirname $::autosetup(dir)]/compat/zlib
    if {![file isdirectory $::zlibdir]} {
      user-error "The zlib in source tree directory does not exist"
    } elseif { ([llength [glob -nocomplain -directory $::zlibdir libz*]] == 0) } {
      user-error "With --with-zlib=tree, $::zlibdir must be configured and built first."
    }
    cc-with [list -cflags "-I$::zlibdir -L$::zlibdir"]
    define-append EXTRA_CFLAGS -I$::zlibdir
    define-append LIBS $::zlibdir/libz.a
    set ::zlib_lib $::zlibdir/libz.a
    msg-result "Using zlib in source tree"
  } else {
    set cftry {""}
    set ldtry {""}
    if {$::zlibpath ni {auto ""}} {
      lappend cftry "-I$::zlibpath"
      lappend cftry "-I$::zlibpath/include"
      lappend ldtry "-L$::zlibpath"
      lappend ldtry "-L$::zlibpath/lib"
    }

    # Reverse the list of tests so we check most-specific to least, else
    # platform devel files will shadow local --with-zlib overrides.
    foreach c [lreverse $cftry] {
      if {[cc-with [list -cflags $c] {cc-check-includes zlib.h}]} {
        if {$c eq ""} {
          msg-result "Found zlib.h in default include path"
        } else {
          define-append EXTRA_CFLAGS "$c"
          msg-result "Found zlib.h via $c"
        }
        set cfound $c
        break
      }
    }
    if {![info exists cfound]} {
      user-error "zlib.h not found; either install it or specify its location via --with-zlib"
    }
    foreach lcheck [lreverse $ldtry] {
      if {[cc-with [list -cflags "$cfound $lcheck"] {check-function-in-lib inflateEnd z}]} {
        if {$lcheck eq ""} {
          msg-result "Linked to zlib via default library path"
        } else {
          define-append EXTRA_LDFLAGS "$lcheck"
          msg-result "Linked to zlib via $lcheck"
        }
        if {![check-function-in-lib compressBound z]} {
          puts "Notice: disabling zlib compression in the SQL shell"
          define-append SQLITE_OPTIONS_EXT {-USQLITE_HAVE_ZLIB}
        }
        break
      }
    }
    set ::zlib_lib -lz
  }
}; # handle-zlib
handle-zlib

#
# Handle the --with-openssl flag and, incidentally, update @LIBS@ for
# zlib if openssl is _not_ used (if it is, we get zlib via libssl).
#
# This function should be called as late as possible in the configure
# script to avoid that its updates to @LIBS@ break tests which follow
# it when a custom local build of openssl is used, as discussed in
# <https://fossil-scm.org/forum/forumpost/15e3d9cdc137030c>.
#
proc handle-with-openssl {} {
  set ssldirs [opt-val with-openssl]
  if {$ssldirs ne "none"} {
    set found 0
    if {$ssldirs eq "tree"} {
      set ssldir [file dirname $::autosetup(dir)]/compat/openssl
      if {![file isdirectory $ssldir]} {
        user-error "The OpenSSL in source tree directory does not exist"
      }
      set msg "openssl in $ssldir"
      set cflags "-I$ssldir/include"
      set ldflags "-L$ssldir"
      set ssllibs "$ssldir/libssl.a $ssldir/libcrypto.a -lpthread"
      set found [check-for-openssl "openssl in source tree" "$cflags $ldflags" $ssllibs]
    } else {
      if {$ssldirs in {auto ""}} {
        catch {
          # TODO?: use autosetup's pkg-config support
          set cflags [exec pkg-config openssl --cflags-only-I]
          set ldflags [exec pkg-config openssl --libs-only-L]
          set found [check-for-openssl "ssl via pkg-config" "$cflags $ldflags"]
        } msg
        if {!$found} {
          set ssldirs "{} /usr/sfw /usr/local/ssl /usr/lib/ssl /usr/ssl \
                             /usr/pkg /usr/local /usr /usr/local/opt/openssl \
                             /opt/homebrew/opt/openssl"
        }
      }
      if {!$found} {
        foreach dir $ssldirs {
          if {$dir eq ""} {
            set msg "system openssl"
            set cflags ""
            set ldflags ""
          } else {
            set msg "openssl in $dir"
            set cflags "-I$dir/include"
            if {[file readable $dir/libssl.a]} {
              set ldflags -L$dir
            } elseif {[file readable $dir/lib/libssl.a]} {
              set ldflags -L$dir/lib
            } elseif {[file isdir $dir/lib]} {
              set ldflags "-L$dir -L$dir/lib"
            } else {
              set ldflags -L$dir
            }
          }
          if {[check-for-openssl $msg "$cflags $ldflags"]} {
            incr found
            break
          }
          if {$dir ne ""} {
            set ldflags ""
            set msg "static build of openssl in $dir"
            set ssllibs "$dir/libssl.a $dir/libcrypto.a -lpthread"
            if {[check-for-openssl $msg "$cflags $ldflags" $ssllibs]} {
              incr found
              break
            }
            # This test should arguably fail here if --with-openssl=X
            # points to an invalid X.
          }
        }
      }
    }
    if {$found} {
      define FOSSIL_ENABLE_SSL
      define-append EXTRA_CFLAGS $cflags
      define-append EXTRA_LDFLAGS $ldflags


      if {[info exists ssllibs]} {
        define-append LIBS $ssllibs
      } else {
        define-append LIBS -lssl -lcrypto
      }
      if {[info exists ::zlib_lib]} {
        define-append LIBS $::zlib_lib
      }
      if {[is_mingw]} {
        define-append LIBS -lgdi32 -lwsock32 -lcrypt32
      }
      msg-result "HTTPS support enabled"

      # Silence OpenSSL deprecation warnings on Mac OS X 10.7.
      if {[string match *-darwin* [get-define host]]} {
        if {[cctest -cflags {-Wdeprecated-declarations}]} {
          define-append EXTRA_CFLAGS -Wdeprecated-declarations
        }
      }
    } else {
      user-error "OpenSSL not found. Consider --with-openssl=none to disable HTTPS support"
    }
  } else {
    if {[info exists ::zlib_lib]} {
      define-append LIBS $::zlib_lib
    }
  }
}; # handle-with-openssl

#
# CFLAGS_INCLUDE is ONLY for -I... flags and their order is
# significant so that --with-sqlite=PATH's header can shadow our
# own. <s>One caveat with this is that we cannot point
# --with-sqlite=PATH to the root of sqlite3's own build tree because
# that dir has a config.h which ends up shadowing src/config.h,
# breaking our build.</s> (That is no longer true: that that config.h
# was renamed to sqlite_cfg.h at some point.)
#
define CFLAGS_INCLUDE {}

########################################################################
# --with-sqlite=PATH checks for the first it finds of the following...
# - PATH/sqlite3.c and PATH/sqlite3.h
# - PATH/sqlite3.o (and assumes sqlite3.h is with it)
# - PATH/lib/libsqlite3* and PATH/include/sqlite3.h


proc handle-with-sqlite {} {



  set sq3path [opt-val with-sqlite]
  define SQLITE3_SRC.2 {}
  define SQLITE3_OBJ.2 {}
  define SQLITE3_SHELL_SRC.2 {$(SQLITE3_SHELL_SRC.0)}
  if {$sq3path in {tree ""}} {
    msg-result "Using sqlite3.c from this source tree."
  } else {
    # SQLITE3_ORIGIN:
    #   0 = local source tree
    #   1 = use external lib or sqlite3.o
    #   2 = use external sqlite3.c and (if found) shell.c
    define USE_SYSTEM_SQLITE 1
    define SQLITE3_ORIGIN 2
    if {$sq3path != "auto"} {
      if {([file exists $sq3path/sqlite3.c]) &&
          ([file exists $sq3path/sqlite3.h]) } {
        # Prefer sqlite3.[ch] if found.
        define SQLITE3_SRC.2 $sq3path/sqlite3.c
        define SQLITE3_OBJ.2 {$(SQLITE3_OBJ.0)}
        define USE_SYSTEM_SQLITE 2
        define SQLITE3_ORIGIN 2
        if {[file exists $sq3path/shell.c]} {
          define SQLITE3_SHELL_SRC.2 $sq3path/shell.c
        }
        define-append CFLAGS_INCLUDE -I$sq3path
        define-append EXTRA_LDFLAGS -lpthread
        # ^^^ additional -lXXX flags are conservative estimates
        msg-result "Using sqlite3.c and sqlite3.h from $sq3path"
      } elseif {[file exists $sq3path/sqlite3.o]} {
        # Use sqlite3.o if found.
        define SQLITE3_OBJ.2 $sq3path/sqlite3.o
        define-append CFLAGS_INCLUDE -I$sq3path
        define-append EXTRA_LDFLAGS $sq3path/sqlite3.o -lpthread
        # ^^^ additional -lXXX flags are conservative estimates
        msg-result "Using sqlite3.o from $sq3path"
      } elseif { ([llength [glob -nocomplain -directory $sq3path/lib libsqlite3*]] != 0) \
                   && ([file exists $sq3path/include/sqlite3.h]) } {
        # e.g. --with-sqlite=/usr/local. Try $sq3path/lib/libsqlite3*
        # and $sq3path/include/sqlite3.h
        define-append CFLAGS_INCLUDE -I$sq3path/include
        define-append EXTRA_LDFLAGS -L$sq3path/lib -lsqlite3 -lpthread
        # ^^^ additional -lXXX flags are conservative estimates
        msg-result "Using -lsqlite3 from $sq3path"
      } else {
        # Assume $sq3path holds both the lib and header
        cc-with [list -cflags "-I$sq3path -L$sq3path"]
        define-append CFLAGS_INCLUDE -I$sq3path
        define-append EXTRA_LDFLAGS -L$sq3path -lsqlite3 -lpthread
        # ^^^ additional -lXXX flags are conservative estimates
        msg-result "Using -lsqlite3 from $sq3path"
      }
    } elseif {![cc-check-includes sqlite3.h] || ![check-function-in-lib sqlite3_open_v2 sqlite3]} {
      user-error "libsqlite3 not found please install it or specify the location with --with-sqlite"
    }
  }
}; # handle-with-sqlite
handle-with-sqlite
define-append CFLAGS_INCLUDE {-I. -I$(SRCDIR) -I$(SRCDIR_extsrc)}; # must be after handle-with-sqlite

#
# Handle the --with-tcl flag.
#
proc handle-with-tcl {} {
  set tclpath [opt-val with-tcl]
  if {$tclpath eq ""} {
    return
  }
  set tclprivatestubs [opt-bool with-tcl-private-stubs]
  # Note parse-tclconfig-sh is in autosetup/local.tcl
  if {$tclpath eq "1"} {
    set tcldir [file dirname $::autosetup(dir)]/compat/tcl-8.6
    if {$tclprivatestubs} {
      set tclconfig(TCL_INCLUDE_SPEC) -I$tcldir/generic
      set tclconfig(TCL_VERSION) {Private Stubs}
      set tclconfig(TCL_PATCH_LEVEL) {}
      set tclconfig(TCL_PREFIX) $tcldir
      set tclconfig(TCL_LD_FLAGS) { }
    } else {
      # Use the system Tcl. Look in some likely places.
      array set tclconfig [parse-tclconfig-sh \
                             $tcldir/unix $tcldir/win \
                             /usr /usr/local /usr/share /opt/local]
      set msg "on your system"
    }
  } else {
    array set tclconfig [parse-tclconfig-sh $tclpath]
    set msg "at $tclpath"
  }
  if {[opt-bool static]} {
    set tclconfig(TCL_LD_FLAGS) { }
  }
  if {![info exists tclconfig(TCL_INCLUDE_SPEC)]} {
    user-error "Cannot find Tcl $msg"
  }
  set tclstubs [opt-bool with-tcl-stubs]
  if {$tclprivatestubs} {
    define FOSSIL_ENABLE_TCL_PRIVATE_STUBS
    define USE_TCL_STUBS
  } elseif {$tclstubs && $tclconfig(TCL_SUPPORTS_STUBS)} {
    set libs "$tclconfig(TCL_STUB_LIB_SPEC)"
    define FOSSIL_ENABLE_TCL_STUBS
    define USE_TCL_STUBS
  } else {
    set libs "$tclconfig(TCL_LIB_SPEC) $tclconfig(TCL_LIBS)"
  }
  set cflags $tclconfig(TCL_INCLUDE_SPEC)
  if {!$tclprivatestubs} {
    set foundtcl 0; # Did we find a working Tcl library?
    cc-with [list -cflags $cflags -libs $libs] {
      if {$tclstubs} {
        if {[cc-check-functions Tcl_InitStubs]} {
          set foundtcl 1
        }
      } else {
        if {[cc-check-functions Tcl_CreateInterp]} {
          set foundtcl 1
        }
      }
    }
    if {!$foundtcl && [string match *-lieee* $libs]} {
      # On some systems, using "-lieee" from TCL_LIB_SPEC appears
      # to cause issues.
      msg-result "Removing \"-lieee\" and retrying for Tcl..."
      set libs [string map [list -lieee ""] $libs]
      cc-with [list -cflags $cflags -libs $libs] {
        if {$tclstubs} {
          if {[cc-check-functions Tcl_InitStubs]} {
            set foundtcl 1
          }
        } else {
          if {[cc-check-functions Tcl_CreateInterp]} {
            set foundtcl 1
          }
        }
      }
    }
    if {!$foundtcl && ![string match *-lpthread* $libs]} {
      # On some systems, TCL_LIB_SPEC appears to be missing
      # "-lpthread".  Try adding it.
      msg-result "Adding \"-lpthread\" and retrying for Tcl..."
      set libs "$libs -lpthread"
      cc-with [list -cflags $cflags -libs $libs] {
        if {$tclstubs} {
          if {[cc-check-functions Tcl_InitStubs]} {
            set foundtcl 1
          }
        } else {
          if {[cc-check-functions Tcl_CreateInterp]} {
            set foundtcl 1
          }
        }
      }
    }
    if {!$foundtcl} {
      if {$tclstubs} {
        user-error "Cannot find a usable Tcl stubs library $msg"
      } else {
        user-error "Cannot find a usable Tcl library $msg"
      }
    }
  }
  set version $tclconfig(TCL_VERSION)$tclconfig(TCL_PATCH_LEVEL)
  msg-result "Found Tcl $version at $tclconfig(TCL_PREFIX)"
  if {!$tclprivatestubs} {
    define-append LIBS $libs
  }
  define-append EXTRA_CFLAGS $cflags
  define-append CFLAGS $cflags
  if {[info exists ::zlibpath] && $::zlibpath eq "tree"} {
    #
    # NOTE: When using zlib in the source tree, prevent Tcl from
    #       pulling in the system one.
    #
    set tclconfig(TCL_LD_FLAGS) [string map [list -lz ""] \
                                   $tclconfig(TCL_LD_FLAGS)]
  }
  #
  # NOTE: Remove "-ldl" from the TCL_LD_FLAGS because it will be
  #       be checked for near the bottom of this file.
  #
  set tclconfig(TCL_LD_FLAGS) [string map [list -ldl ""] \
                                 $tclconfig(TCL_LD_FLAGS)]
  define-append EXTRA_LDFLAGS $tclconfig(TCL_LD_FLAGS)
  define FOSSIL_ENABLE_TCL

}; # handle-with-tcl




handle-with-tcl






















# Network functions require libraries on some systems
cc-check-function-in-lib gethostbyname nsl
if {![cc-check-function-in-lib socket {socket network}]} {
  # Last resort, may be Windows
  if {[is_mingw]} {
    define-append LIBS -lwsock32
  }
}

# Some systems (ex: SunOS) require -lrt in order to use nanosleep
cc-check-function-in-lib nanosleep rt

# The SMTP module requires special libraries and headers for MX DNS
# record lookups and such.
cc-check-includes arpa/nameser.h
cc-include-needs bind/resolv.h netinet/in.h
cc-check-includes bind/resolv.h
cc-check-includes resolv.h
if {    !(([cc-check-function-in-lib dn_expand resolv] ||
           [cc-check-function-in-lib   ns_name_uncompress {bind resolv}] ||
           [cc-check-function-in-lib __ns_name_uncompress {bind resolv}]) &&
          ([cc-check-function-in-lib   ns_parserr {bind resolv}] ||
           [cc-check-function-in-lib __ns_parserr {bind resolv}]) &&
          ([cc-check-function-in-lib   res_query {bind resolv}] ||
           [cc-check-function-in-lib __res_query {bind resolv}]))} {
  msg-result "WARNING: SMTP feature will not be able to look up local MX."
}
cc-check-function-in-lib res_9_ns_initparse resolv

# Other nonstandard function checks
cc-check-functions utime
cc-check-functions usleep
cc-check-functions strchrnul
cc-check-functions pledge
cc-check-functions backtrace

# Termux on Android adds "getpass(char *)" to unistd.h, so check this so we
# guard against including it again; use cctest as cc-check-functions and
# cctest_function check for "getpass()" with no args and fail
if {[cctest -link 1 -includes {unistd.h} -code "getpass(0);"]} {
  define FOSSIL_HAVE_GETPASS 1
  msg-result "Found getpass() with unistd.h"
}

# Check for getloadavg(), and if it doesn't exist, define FOSSIL_OMIT_LOAD_AVERAGE
if {![cc-check-functions getloadavg] ||
    ![cctest -link 1 -includes {unistd.h} -code "double a\[3\]; getloadavg(a,3);"]} {
  define FOSSIL_OMIT_LOAD_AVERAGE 1
  msg-result "Load average support unavailable"
}

# Check for getpassphrase() for Solaris 10 where getpass() truncates to 10 chars
if {![cc-check-functions getpassphrase]} {
  # Haiku needs this
  cc-check-function-in-lib getpass bsd
}


# Check for the FuseFS library
if {[opt-bool fusefs]} {
  if {[opt-bool static]} {
    msg-result "FuseFS support disabled due to -static"
  } elseif {[cc-check-function-in-lib fuse_mount fuse]} {
    define-append EXTRA_CFLAGS -DFOSSIL_HAVE_FUSEFS
    define FOSSIL_HAVE_FUSEFS 1
    msg-result "FuseFS support enabled"
  }
}

########################################################################
# Checks the compiler for compile_commands.json support.
#
# Returns 1 if supported, else 0. Defines MAKE_COMPILATION_DB to "yes"
# if supported, "no" if not.
proc check-compile-commands {} {
  msg-checking "compile_commands.json support... "
  if {[cctest -lang c -cflags {/dev/null -MJ} -source {}]} {
    # This test reportedly incorrectly succeeds on one of
    # Martin G.'s older systems.
    msg-result "compiler supports compile_commands.json"
    define MAKE_COMPILATION_DB yes
    return 1
  } else {
    msg-result "compiler does not support compile_commands.json"
    define MAKE_COMPILATION_DB no
    return 0
  }
}

define MAKE_COMPILATION_DB no
if {!$outOfTreeBuild} {
  if {[opt-bool compile-commands]} {
    check-compile-commands
  } else {
    puts "Use --compile-commands to enable check for compile-commands-capable compiler."
  }
} else {
  puts "Disabling compile_commands.json check for out-of-tree build."
  # This is an attempt to resolve the problem reported at
  # https://fossil-scm.org/forum/forumpost/d19061d09a8179d0
}

# Add -fsanitize compile and link options late: we don't want the C
# checks above to run with those sanitizers enabled.  It can not only
# be pointless, it can actually break correct tests.
set fsan [opt-val with-sanitizer]
if {[string length $fsan]} {
  define-append  EXTRA_CFLAGS -fsanitize=$fsan
  define-append EXTRA_LDFLAGS -fsanitize=$fsan
  if {[string first "undefined" $fsan] != -1} {
    # We need to link with libubsan if we're compiling under
    # GCC with -fsanitize=undefined.
    cc-check-function-in-lib __ubsan_handle_add_overflow ubsan
  }
}

########################################################################

# @proj-check-emsdk
#
# Emscripten is used for doing in-tree builds of web-based WASM stuff,
# as opposed to WASI-based WASM or WASM binaries we import from other
# places. This is only set up for Unix-style OSes and is untested
# anywhere but Linux. Requires that the --with-emsdk flag be
# registered with autosetup.
#
# It looks for the SDK in the location specified by --with-emsdk.
# Values of "" or "auto" mean to check for the environment var EMSDK
# (which gets set by the emsdk_env.sh script from the SDK) or that
# same var passed to configure.
#
# If the given directory is found, it expects to find emsdk_env.sh in
# that directory, as well as the emcc compiler somewhere under there.
#
# If the --with-emsdk flag is explicitly provided and the SDK is not
# found then a fatal error is generated, otherwise failure to find the
# SDK is not fatal.
#
# Defines the following:
#
# - EMSDK_HOME = top dir of the emsdk or "".
# - EMSDK_ENV_SH = path to EMSDK_HOME/emsdk_env.sh or ""
# - BIN_EMCC = $EMSDK_HOME/upstream/emscripten/emcc or ""
# - HAVE_EMSDK = 0 or 1 (this function's return value)
#
# Returns 1 if EMSDK_ENV_SH is found, else 0.  If EMSDK_HOME is not empty
# but BIN_EMCC is then emcc was not found in the EMSDK_HOME, in which
# case we have to rely on the fact that sourcing $EMSDK_ENV_SH from a
# shell will add emcc to the $PATH.
proc proj-check-emsdk {} {
  set emsdkHome [opt-val with-emsdk]
  define EMSDK_HOME ""
  define EMSDK_ENV_SH ""
  define BIN_EMCC ""
  set hadValue [llength $emsdkHome]
  msg-checking "Emscripten SDK? "
  if {$emsdkHome in {"" "auto"}} {
    # Check the environment. $EMSDK gets set by sourcing emsdk_env.sh.
    set emsdkHome [get-env EMSDK ""]
  }
  set rc 0
  if {$emsdkHome ne ""} {
    define EMSDK_HOME $emsdkHome
    set emsdkEnv "$emsdkHome/emsdk_env.sh"
    if {[file exists $emsdkEnv]} {

      msg-result "$emsdkHome"
      define EMSDK_ENV_SH $emsdkEnv
      set rc 1
      set emcc "$emsdkHome/upstream/emscripten/emcc"
      if {[file exists $emcc]} {
        define BIN_EMCC $emcc
      }
    } else {
      msg-result "emsdk_env.sh not found in $emsdkHome"
    }
  } else {
    msg-result "not found"
  }
  if {$hadValue && 0 == $rc} {
    # Fail if it was explicitly requested but not found
    proj-fatal "Cannot find the Emscripten SDK"
  }
  define HAVE_EMSDK $rc
  return $rc
}

if {[proj-check-emsdk]} {
  define EMCC_WRAPPER $::autosetup(dir)/../tools/emcc.sh
  define EMCC_OPT [get-env EMCC_OPT "-Oz"]; # optional flags to pass to emcc
  make-template tools/emcc.sh.in
  catch {exec chmod u+x tools/emcc.sh}
} else {
  define EMCC_WRAPPER ""
  define EMCC_OPT ""
  catch {exec rm -f tools/emcc.sh}
}

handle-with-openssl

# Finally, append libraries that must be last. This matters more on some
# OSes than others, but is most broadly required for static linking.
if {[opt-bool static]} {
  # Linux can only infer the dependency on pthread from OpenSSL when
  # doing dynamic linkage.
  define-append LIBS -lpthread
}

apply {{} {
  # This started out as a workaround for getting the ordering of -ldl
  # correct in conjunction with openssl in some environments. Then it
  # evolved into a more generic preemptive portability workaround to
  # ensure that certain libraries are always appended to the global
  # LIBS list if they exist on the system. Based on a /chat discussion
  # on 2025-02-27 in the context of check-in [8d3b9bf4d4].
  #
  # Note that [move-lib-to-end] and [lib-actually-exists] are in
  # autosetup/local.tcl.
  set libs [get-define LIBS]
  #puts "**** 1 LIBS: $libs"
  foreach ll {-ldl -lpthread -lm} {
    if {![move-lib-to-end $ll $libs libs]} {
      # $ll was not in the list
      if {[lib-actually-exists $ll]} {
        # Add it to the list "just in case." This will be a no-op on
        # systems where the lib is not actually used.
        lappend libs $ll
      }
    }
  }
  #puts "**** 2 LIBS: $libs"
  define LIBS [join $libs " "]
}}

# Tag container builds with a prefix of the checkin ID of the version
# of Fossil each one contains.  This not only allows multiple images
# to coexist and multiple containers to be created unamgiguosly from
# them, it also changes the URL we fetch the source tarball from, so
# repeated builds of a given version generate and fetch the source
# tarball once only, keeping it in the local Docker/Podman cache.
set ci [readfile "$::autosetup(srcdir)/manifest.uuid"]
define FOSSIL_CI_PFX [string range $ci 0 11]

make-template Makefile.in
make-config-header autoconfig.h -auto {USE_* FOSSIL_*}

		if {[regexp {^(TCL_[^=]*)=(.*)$} $line -> name value]} {
			set value [regsub -all {\$\{.*\}} $value ""]
			set tclconfig($name) [string trim $value ']
		}
	}
	return [array get tclconfig]
}

#
# Given a library link flag, e.g. -lfoo, returns 1 if that library can
# actually be linked to, else returns 0.
proc lib-actually-exists {linkFlag} {
  cctest -link 1 -code "void libActuallyExists(void){}" -libs $linkFlag
}

#
# Given a library flag, e.g. -lfoo, a list of libs, e.g. {-lfoo -lbar
# -lbaz}, and a target variable name, this function appends all
# entries of $libList which do not match $flag to $tgtVar, then
# appends $flag to the end of $tgtVar. Returns the number of matches
# found.
proc move-lib-to-end {flag libList tgtVar} {
  upvar $tgtVar tgt
  set tgt {}
  set found 0
  foreach e $libList {
    if {$flag eq $e} {
      incr found
    } else {
      lappend tgt $e
    }
  }
  if {$found} {
    lappend tgt $flag
  }
  return $found
}

/* this code is not standalone
 * it is included into linenoise.c
 * for windows.
 * It is deliberately kept separate so that
 * applications that have no need for windows
 * support can omit this
 */
static DWORD orig_consolemode = 0;

static int flushOutput(struct current *current);
static void outputNewline(struct current *current);

static void refreshStart(struct current *current)
{
    (void)current;
}

static void refreshEnd(struct current *current)
{
    (void)current;
}

static void refreshStartChars(struct current *current)
{
    assert(current->output == NULL);
    /* We accumulate all output here */
    current->output = sb_alloc();
#ifdef USE_UTF8
    current->ubuflen = 0;
#endif
}

static void refreshNewline(struct current *current)
{
    DRL("<nl>");
    outputNewline(current);
}

static void refreshEndChars(struct current *current)
{
    assert(current->output);
    flushOutput(current);
    sb_free(current->output);
    current->output = NULL;
}

static int enableRawMode(struct current *current) {
    DWORD n;
    INPUT_RECORD irec;

    current->outh = GetStdHandle(STD_OUTPUT_HANDLE);
    current->inh = GetStdHandle(STD_INPUT_HANDLE);

    if (!PeekConsoleInput(current->inh, &irec, 1, &n)) {
        return -1;
    }
    if (getWindowSize(current) != 0) {
        return -1;
    }
    if (GetConsoleMode(current->inh, &orig_consolemode)) {
        SetConsoleMode(current->inh, ENABLE_PROCESSED_INPUT);
    }
#ifdef USE_UTF8
    /* XXX is this the right thing to do? */
    SetConsoleCP(65001);
#endif
    return 0;
}

static void disableRawMode(struct current *current)
{
    SetConsoleMode(current->inh, orig_consolemode);
}

void linenoiseClearScreen(void)
{
    /* XXX: This is ugly. Should just have the caller pass a handle */
    struct current current;

    current.outh = GetStdHandle(STD_OUTPUT_HANDLE);

    if (getWindowSize(&current) == 0) {
        COORD topleft = { 0, 0 };
        DWORD n;

        FillConsoleOutputCharacter(current.outh, ' ',
            current.cols * current.rows, topleft, &n);
        FillConsoleOutputAttribute(current.outh,
            FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN,
            current.cols * current.rows, topleft, &n);
        SetConsoleCursorPosition(current.outh, topleft);
    }
}

static void cursorToLeft(struct current *current)
{
    COORD pos;
    DWORD n;

    pos.X = 0;
    pos.Y = (SHORT)current->y;

    FillConsoleOutputAttribute(current->outh,
        FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN, current->cols, pos, &n);
    current->x = 0;
}

#ifdef USE_UTF8
static void flush_ubuf(struct current *current)
{
    COORD pos;
    DWORD nwritten;
    pos.Y = (SHORT)current->y;
    pos.X = (SHORT)current->x;
    SetConsoleCursorPosition(current->outh, pos);
    WriteConsoleW(current->outh, current->ubuf, current->ubuflen, &nwritten, 0);
    current->x += current->ubufcols;
    current->ubuflen = 0;
    current->ubufcols = 0;
}

static void add_ubuf(struct current *current, int ch)
{
    /* This code originally by: Author: Mark E. Davis, 1994. */
    static const int halfShift  = 10; /* used for shifting by 10 bits */

    static const DWORD halfBase = 0x0010000UL;
    static const DWORD halfMask = 0x3FFUL;

    #define UNI_SUR_HIGH_START  0xD800
    #define UNI_SUR_HIGH_END    0xDBFF
    #define UNI_SUR_LOW_START   0xDC00
    #define UNI_SUR_LOW_END     0xDFFF

    #define UNI_MAX_BMP 0x0000FFFF

    if (ch > UNI_MAX_BMP) {
        /* convert from unicode to utf16 surrogate pairs
         * There is always space for one extra word in ubuf
         */
        ch -= halfBase;
        current->ubuf[current->ubuflen++] = (WORD)((ch >> halfShift) + UNI_SUR_HIGH_START);
        current->ubuf[current->ubuflen++] = (WORD)((ch & halfMask) + UNI_SUR_LOW_START);
    }
    else {
        current->ubuf[current->ubuflen++] = ch;
    }
    current->ubufcols += utf8_width(ch);
    if (current->ubuflen >= UBUF_MAX_CHARS) {
        flush_ubuf(current);
    }
}
#endif

static int flushOutput(struct current *current)
{
    const char *pt = sb_str(current->output);
    int len = sb_len(current->output);

#ifdef USE_UTF8
    /* convert utf8 in current->output into utf16 in current->ubuf
     */
    while (len) {
        int ch;
        int n = utf8_tounicode(pt, &ch);

        pt += n;
        len -= n;

        add_ubuf(current, ch);
    }
    flush_ubuf(current);
#else
    DWORD nwritten;
    COORD pos;

    pos.Y = (SHORT)current->y;
    pos.X = (SHORT)current->x;

    SetConsoleCursorPosition(current->outh, pos);
    WriteConsoleA(current->outh, pt, len, &nwritten, 0);

    current->x += len;
#endif

    sb_clear(current->output);

    return 0;
}

static int outputChars(struct current *current, const char *buf, int len)
{
    if (len < 0) {
        len = strlen(buf);
    }
    assert(current->output);

    sb_append_len(current->output, buf, len);

    return 0;
}

static void outputNewline(struct current *current)
{
    /* On the last row output a newline to force a scroll */
    if (current->y + 1 == current->rows) {
        outputChars(current, "\n", 1);
    }
    flushOutput(current);
    current->x = 0;
    current->y++;
}

static void setOutputHighlight(struct current *current, const int *props, int nprops)
{
    int colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN;
    int bold = 0;
    int reverse = 0;
    int i;

    for (i = 0; i < nprops; i++) {
        switch (props[i]) {
            case 0:
               colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN;
               bold = 0;
               reverse = 0;
               break;
            case 1:
               bold = FOREGROUND_INTENSITY;
               break;
            case 7:
               reverse = 1;
               break;
            case 30:
               colour = 0;
               break;
            case 31:
               colour = FOREGROUND_RED;
               break;
            case 32:
               colour = FOREGROUND_GREEN;
               break;
            case 33:
               colour = FOREGROUND_RED | FOREGROUND_GREEN;
               break;
            case 34:
               colour = FOREGROUND_BLUE;
               break;
            case 35:
               colour = FOREGROUND_RED | FOREGROUND_BLUE;
               break;
            case 36:
               colour = FOREGROUND_BLUE | FOREGROUND_GREEN;
               break;
            case 37:
               colour = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN;
               break;
        }
    }

    flushOutput(current);

    if (reverse) {
        SetConsoleTextAttribute(current->outh, BACKGROUND_INTENSITY);
    }
    else {
        SetConsoleTextAttribute(current->outh, colour | bold);
    }
}

static void eraseEol(struct current *current)
{
    COORD pos;
    DWORD n;

    pos.X = (SHORT) current->x;
    pos.Y = (SHORT) current->y;

    FillConsoleOutputCharacter(current->outh, ' ', current->cols - current->x, pos, &n);
}

static void setCursorXY(struct current *current)
{
    COORD pos;

    pos.X = (SHORT) current->x;
    pos.Y = (SHORT) current->y;

    SetConsoleCursorPosition(current->outh, pos);
}


static void setCursorPos(struct current *current, int x)
{
    current->x = x;
    setCursorXY(current);
}

static void cursorUp(struct current *current, int n)
{
    current->y -= n;
    setCursorXY(current);
}

static void cursorDown(struct current *current, int n)
{
    current->y += n;
    setCursorXY(current);
}

static int fd_read(struct current *current)
{
    while (1) {
        INPUT_RECORD irec;
        DWORD n;
        if (WaitForSingleObject(current->inh, INFINITE) != WAIT_OBJECT_0) {
            break;
        }
        if (!ReadConsoleInputW(current->inh, &irec, 1, &n)) {
            break;
        }
        if (irec.EventType == KEY_EVENT) {
            KEY_EVENT_RECORD *k = &irec.Event.KeyEvent;
            if (k->bKeyDown || k->wVirtualKeyCode == VK_MENU) {
                if (k->dwControlKeyState & ENHANCED_KEY) {
                    switch (k->wVirtualKeyCode) {
                     case VK_LEFT:
                        return SPECIAL_LEFT;
                     case VK_RIGHT:
                        return SPECIAL_RIGHT;
                     case VK_UP:
                        return SPECIAL_UP;
                     case VK_DOWN:
                        return SPECIAL_DOWN;
                     case VK_INSERT:
                        return SPECIAL_INSERT;
                     case VK_DELETE:
                        return SPECIAL_DELETE;
                     case VK_HOME:
                        return SPECIAL_HOME;
                     case VK_END:
                        return SPECIAL_END;
                     case VK_PRIOR:
                        return SPECIAL_PAGE_UP;
                     case VK_NEXT:
                        return SPECIAL_PAGE_DOWN;
                     case VK_RETURN:
                        return k->uChar.UnicodeChar;
                    }
                }
                /* Note that control characters are already translated in AsciiChar */
                else if (k->wVirtualKeyCode == VK_CONTROL)
                    continue;
                else {
                    return k->uChar.UnicodeChar;
                }
            }
        }
    }
    return -1;
}

static int getWindowSize(struct current *current)
{
    CONSOLE_SCREEN_BUFFER_INFO info;
    if (!GetConsoleScreenBufferInfo(current->outh, &info)) {
        return -1;
    }
    current->cols = info.dwSize.X;
    current->rows = info.dwSize.Y;
    if (current->cols <= 0 || current->rows <= 0) {
        current->cols = 80;
        return -1;
    }
    current->y = info.dwCursorPosition.Y;
    current->x = info.dwCursorPosition.X;
    return 0;
}

    int colsright; /* refreshLine() cached cols for insert_char() optimisation */
    int colsleft;  /* refreshLine() cached cols for remove_char() optimisation */
    const char *prompt;
    stringbuf *capture; /* capture buffer, or NULL for none. Always null terminated */
    stringbuf *output;  /* used only during refreshLine() - output accumulator */
#if defined(USE_TERMIOS)
    int fd;     /* Terminal fd */
    int pending; /* pending char fd_read_char() */
#elif defined(USE_WINCONSOLE)
    HANDLE outh; /* Console output handle */
    HANDLE inh; /* Console input handle */
    int rows;   /* Screen rows */
    int x;      /* Current column during output */
    int y;      /* Current row */
#ifdef USE_UTF8

    /* local modes - choing off, canonical off, no extended functions,
     * no signal chars (^Z,^C) */
    raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* control chars - set return condition: min number of bytes and timer.
     * We want read to return every single byte, without timeout. */
    raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

    /* put terminal in raw mode. Because we aren't changing any output
     * settings we don't need to use TCSADRAIN and I have seen that hang on
     * OpenBSD when running under a pty
     */
    if (tcsetattr(current->fd,TCSANOW,&raw) < 0) {
        goto fatal;
    }
    rawmode = 1;
    return 0;
}

static void disableRawMode(struct current *current) {
    /* Don't even check the return value as it's too late. */
    if (rawmode && tcsetattr(current->fd,TCSANOW,&orig_termios) != -1)
        rawmode = 0;
}

/* At exit we'll try to fix the terminal to the initial conditions. */
static void linenoiseAtExit(void) {
    if (rawmode) {
        tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios);
    }
    linenoiseHistoryFree();
}

/* gcc/glibc insists that we care about the return code of write!
 * Clarification: This means that a void-cast like "(void) (EXPR)"
 * does not work.

void linenoiseClearScreen(void)
{
    IGNORE_RC(write(STDOUT_FILENO, "\x1b[H\x1b[2J", 7));
}

/**
 * Reads a char from 'current->fd', waiting at most 'timeout' milliseconds.
 *
 * A timeout of -1 means to wait forever.
 *
 * Returns -1 if no char is received within the time or an error occurs.
 */
static int fd_read_char(struct current *current, int timeout)
{
    struct pollfd p;
    unsigned char c;

    if (current->pending) {
        c = current->pending;
        current->pending = 0;
        return c;
    }

    p.fd = current->fd;
    p.events = POLLIN;

    if (poll(&p, 1, timeout) == 0) {
        /* timeout */
        return -1;
    }
    if (read(current->fd, &c, 1) != 1) {
        return -1;
    }
    return c;
}

/**
 * Reads a complete utf-8 character
 * and returns the unicode value, or -1 on error.
 */
static int fd_read(struct current *current)
{
#ifdef USE_UTF8
    char buf[MAX_UTF8_LEN];
    int n;
    int i;
    int c;

    if (current->pending) {
        buf[0] = current->pending;
        current->pending = 0;
    }
    else if (read(current->fd, &buf[0], 1) != 1) {
        return -1;
    }
    n = utf8_charlen(buf[0]);
    if (n < 1) {
        return -1;
    }
    for (i = 1; i < n; i++) {
        if (read(current->fd, &buf[i], 1) != 1) {
            return -1;
        }
    }
    /* decode and return the character */
    utf8_tounicode(buf, &c);
    return c;
#else
    return fd_read_char(current, -1);
#endif
}


/**
 * Stores the current cursor column in '*cols'.
 * Returns 1 if OK, or 0 if failed to determine cursor pos.
 */
static int queryCursor(struct current *current, int* cols)
{
    struct esc_parser parser;
    int ch;
    /* Unfortunately we don't have any persistent state, so assume
     * a process will only ever interact with one terminal at a time.
     */
    static int query_cursor_failed;

    if (query_cursor_failed) {
        /* If it ever fails, don't try again */
        return 0;
    }

    /* Should not be buffering this output, it needs to go immediately */
    assert(current->output == NULL);

    /* control sequence - report cursor location */
    outputChars(current, "\x1b[6n", -1);

    /* Parse the response: ESC [ rows ; cols R */
    initParseEscapeSeq(&parser, 'R');
    while ((ch = fd_read_char(current, 100)) > 0) {
        switch (parseEscapeSequence(&parser, ch)) {
            default:
                continue;
            case EP_END:
                if (parser.numprops == 2 && parser.props[1] < 1000) {
                    *cols = parser.props[1];
                    return 1;
                }
                break;
            case EP_ERROR:
                /* Push back the character that caused the error */
                current->pending = ch;
                break;
        }
        /* failed */
        break;
    }
    query_cursor_failed = 1;
    return 0;
}

/**
 * Updates current->cols with the current window size (width)
 */
static int getWindowSize(struct current *current)

 * chars to determine if this is a known special key.
 *
 * Returns SPECIAL_NONE if unrecognised, or -1 if EOF.
 *
 * If no additional char is received within a short time,
 * CHAR_ESCAPE is returned.
 */
static int check_special(struct current *current)
{
    int c = fd_read_char(current, 50);
    int c2;

    if (c < 0) {
        return CHAR_ESCAPE;
    }
    else if (c >= 'a' && c <= 'z') {
        /* esc-a => meta-a */
        return meta(c);
    }

    c2 = fd_read_char(current, 50);
    if (c2 < 0) {
        return c2;
    }
    if (c == '[' || c == 'O') {
        /* Potential arrow key */
        switch (c2) {
            case 'A':

                return SPECIAL_END;
            case 'H':
                return SPECIAL_HOME;
        }
    }
    if (c == '[' && c2 >= '1' && c2 <= '8') {
        /* extended escape */
        c = fd_read_char(current, 50);
        if (c == '~') {
            switch (c2) {
                case '2':
                    return SPECIAL_INSERT;
                case '3':
                    return SPECIAL_DELETE;
                case '5':
                    return SPECIAL_PAGE_UP;
                case '6':
                    return SPECIAL_PAGE_DOWN;
                case '7':
                    return SPECIAL_HOME;
                case '8':
                    return SPECIAL_END;
            }
        }
        while (c != -1 && c != '~') {
            /* .e.g \e[12~ or '\e[11;2~   discard the complete sequence */
            c = fd_read_char(current, 50);
        }
    }

    return SPECIAL_NONE;
}
#endif

                rbuf[p_ind] = 0;
                rlen = strlen(rbuf);
            }
            continue;
        }
#ifdef USE_TERMIOS
        if (c == CHAR_ESCAPE) {
            c = check_special(current);
        }
#endif
        if (c == ctrl('R')) {
            /* Search for the previous (earlier) match */
            if (searchpos > 0) {
                searchpos--;
            }

            /* reverse incremental search will provide an alternative keycode or 0 for none */
            c = reverseIncrementalSearch(current);
            /* go on to process the returned char normally */
        }

#ifdef USE_TERMIOS
        if (c == CHAR_ESCAPE) {   /* escape sequence */
            c = check_special(current);
        }
#endif
        if (c == -1) {
            /* Return on errors */
            return sb_len(current->buf);
        }

  {
    pikchr: source code for the pikchr,
    darkMode: boolean true to adjust colors for a dark color scheme,
    cssClass: CSS class name to add to the SVG
  }

  Workers-to-Main message types:

  - stdout, stderr: indicate stdout/stderr output from the wasm
  layer. The data property is the string of the output, noting
  that the emscripten binding emits these one line at a time. Thus,
  if a C-side puts() emits multiple lines in a single call, the JS
  side will see that as multiple calls. Example:

  {type:'stdout', data: 'Hi, world.'}

  - module: Status text. This is intended to alert the main thread
  about module loading status so that, e.g., the main thread can
  update a progress widget and DTRT when the module is finished
  loading and available for work. Status messages come in the form

  {type:'module', data:{
  type:'status',
  data: {text:string|null, step:1-based-integer}
  }

  with an incrementing step value for each subsequent message. When
  the module loading is complete, a message with a text value of
  null is posted.

  - pikchr:

  {type: 'pikchr',
    data:{
      pikchr: input text,
      result: rendered result (SVG on success, HTML on error),
      isError: bool, true if .pikchr holds an error report,
      flags: integer: flags used to configure the pikchr rendering,

            pikchrModule.stackRestore(stack);
            wMsg('working','end');
          }
          return;
    };
    console.warn("Unknown pikchr-worker message type:",ev);
  };

  /**
     emscripten module for use with build mode -sMODULARIZE.
  */
  const pikchrModule = {
    print: function(){wMsg('stdout', Array.prototype.slice.call(arguments));},
    printErr: stderr,
    /**

      wMsg('module',{
        type:'status',
        data:{step: ++f.last.step, text: text||null}
      });
    }
  };

  importScripts('pikchr-v2813665466.js');
  /**
     initPikchrModule() is installed via pikchr.js due to
     building with:

     emcc ... -sMODULARIZE=1 -sEXPORT_NAME=initPikchrModule
  */
  initPikchrModule(pikchrModule).then(function(thisModule){
    //globalThis.M = pikchrModule; console.warn("pikchrModule=globalThis.M=",globalThis.M);
    wMsg('pikchr-ready', pikchrModule.ccall('pikchr_version','string'));
  });
})();

/* This file is automatically generated by Lemon from input grammar
** source file "pikchr.y".
*/
/*
** 2000-05-29
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** Driver template for the LEMON parser generator.
**
** The "lemon" program processes an LALR(1) input grammar file, then uses
** this template to construct a parser.  The "lemon" program inserts text
** at each "%%" line.  Also, any "P-a-r-s-e" identifier prefix (without the
** interstitial "-" characters) contained in this template is changed into
** the value of the %name directive from the grammar.  Otherwise, the content
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
/************ Begin %include sections from the grammar ************************/
#line 1 "VERSION.h"
#define MANIFEST_UUID "8a43b020141f772a0ac45291a7fd73041d2efba5e3665c6bd2f334ad9b2e9845"
#define MANIFEST_VERSION "[8a43b02014]"
#define MANIFEST_DATE "2025-03-19 16:19:43"
#define MANIFEST_YEAR "2025"
#define MANIFEST_ISODATE "20250319161943"
#define MANIFEST_NUMERIC_DATE 20250319
#define MANIFEST_NUMERIC_TIME 161943
#define RELEASE_VERSION "1.0"
#define RELEASE_VERSION_NUMBER 10000
#define RELEASE_RESOURCE_VERSION 1,0,0,0
#define COMPILER "gcc-13.3.0"
#line 2 "pikchr.y"

/*
** Zero-Clause BSD license:
**
** Copyright (C) 2020-09-01 by D. Richard Hipp <drh@sqlite.org>
**
** Permission to use, copy, modify, and/or distribute this software for
** any purpose with or without fee is hereby granted.

#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

/*
** Typesafe version of ctype.h macros.  Cygwin requires this, I'm told.
*/
#define IsUpper(X)  isupper((unsigned char)(X))
#define IsLower(X)  islower((unsigned char)(X))
#define ToLower(X)  tolower((unsigned char)(X))
#define IsDigit(X)  isdigit((unsigned char)(X))
#define IsXDigit(X) isxdigit((unsigned char)(X))
#define IsSpace(X)  isspace((unsigned char)(X))
#define IsAlnum(X)  isalnum((unsigned char)(X))


/* Limit the number of tokens in a single script to avoid run-away
** macro expansion attacks.  See forum post
**    https://pikchr.org/home/forumpost/ef8684c6955a411a
*/
#ifndef PIKCHR_TOKEN_LIMIT
# define PIKCHR_TOKEN_LIMIT 100000

static int pik_bbox_contains_point(PBox*,PPoint*);
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, const int isMonospace);
static void pik_size_to_fit(Pik*,PObj*,PToken*,int);
static int pik_text_position(int,PToken*);
static PNum pik_property_of(PObj*,PToken*);
static PNum pik_func(Pik*,PToken*,PNum,PNum);
static PPoint pik_position_between(PNum x, PPoint p1, PPoint p2);
static PPoint pik_position_at_angle(PNum dist, PNum r, PPoint pt);
static PPoint pik_position_at_hdg(PNum dist, PToken *pD, PPoint pt);
static void pik_same(Pik *p, PObj*, PToken*);
static PPoint pik_nth_vertex(Pik *p, PToken *pNth, PToken *pErr, PObj *pObj);
static PToken pik_next_semantic_token(PToken *pThis);
static void pik_compute_layout_settings(Pik*);
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 549 "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 T_CODEBLOCK                      19
#define T_FILL                           20
#define T_COLOR                          21
#define T_THICKNESS                      22
#define T_PRINT                          23
#define T_STRING                         24
#define T_COMMA                          25
#define T_ISODATE                        26
#define T_CLASSNAME                      27
#define T_LB                             28
#define T_RB                             29
#define T_UP                             30
#define T_DOWN                           31
#define T_LEFT                           32
#define T_RIGHT                          33
#define T_CLOSE                          34
#define T_CHOP                           35
#define T_FROM                           36
#define T_TO                             37
#define T_THEN                           38
#define T_HEADING                        39
#define T_GO                             40
#define T_AT                             41
#define T_WITH                           42
#define T_SAME                           43
#define T_AS                             44
#define T_FIT                            45
#define T_BEHIND                         46
#define T_UNTIL                          47
#define T_EVEN                           48
#define T_DOT_E                          49
#define T_HEIGHT                         50
#define T_WIDTH                          51
#define T_RADIUS                         52
#define T_DIAMETER                       53
#define T_DOTTED                         54
#define T_DASHED                         55
#define T_CW                             56
#define T_CCW                            57
#define T_LARROW                         58
#define T_RARROW                         59
#define T_LRARROW                        60
#define T_INVIS                          61
#define T_THICK                          62
#define T_THIN                           63
#define T_SOLID                          64
#define T_CENTER                         65
#define T_LJUST                          66
#define T_RJUST                          67
#define T_ABOVE                          68
#define T_BELOW                          69
#define T_ITALIC                         70
#define T_BOLD                           71
#define T_MONO                           72
#define T_ALIGNED                        73
#define T_BIG                            74
#define T_SMALL                          75
#define T_AND                            76
#define T_LT                             77
#define T_GT                             78
#define T_ON                             79
#define T_WAY                            80
#define T_BETWEEN                        81
#define T_THE                            82
#define T_NTH                            83
#define T_VERTEX                         84
#define T_TOP                            85
#define T_BOTTOM                         86
#define T_START                          87
#define T_END                            88
#define T_IN                             89
#define T_THIS                           90
#define T_DOT_U                          91
#define T_LAST                           92
#define T_NUMBER                         93
#define T_FUNC1                          94
#define T_FUNC2                          95
#define T_DIST                           96
#define T_DOT_XY                         97
#define T_X                              98
#define T_Y                              99
#define T_DOT_L                          100
#endif
/**************** End token definitions ***************************************/

/* The next sections is a series of control #defines.
** various aspects of the generated parser.
**    YYCODETYPE         is the data type used to store the integer codes
**                       that represent terminal and non-terminal symbols.

**    YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
*/
#ifndef INTERFACE
# define INTERFACE 1
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned char
#define YYNOCODE 138
#define YYACTIONTYPE unsigned short int
#define pik_parserTOKENTYPE PToken
typedef union {
  int yyinit;
  pik_parserTOKENTYPE yy0;
  PList* yy23;

  PRel yy28;
  PObj* yy54;
  PNum yy129;
  PPoint yy187;
  short int yy272;

} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 100
#endif
#define pik_parserARG_SDECL
#define pik_parserARG_PDECL
#define pik_parserARG_PARAM

#define pik_parserCTX_PARAM ,p
#define pik_parserCTX_FETCH Pik *p=yypParser->p;
#define pik_parserCTX_STORE yypParser->p=p;
#define YYFALLBACK 1
#define YYNSTATE             164
#define YYNRULE              156
#define YYNRULE_WITH_ACTION  116
#define YYNTOKEN             101
#define YY_MAX_SHIFT         163
#define YY_MIN_SHIFTREDUCE   287
#define YY_MAX_SHIFTREDUCE   442
#define YY_ERROR_ACTION      443
#define YY_ACCEPT_ACTION     444
#define YY_NO_ACTION         445
#define YY_MIN_REDUCE        446
#define YY_MAX_REDUCE        601
#define YY_MIN_DSTRCTR       101
#define YY_MAX_DSTRCTR       104
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

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

**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (1305)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   575,  495,  161,  119,   25,  452,   29,   74,  129,  148,
 /*    10 */   575,   64,   63,   62,   61,  453,  113,  120,  161,  119,
 /*    20 */   427,  428,  339,  357,   81,  121,  447,  454,   29,  575,
 /*    30 */   530,   13,   50,  450,  322,  323,    9,    8,   33,  149,
 /*    40 */    32,    7,   71,  127,  163,  335,   66,   28,  444,   27,
 /*    50 */   339,  339,  339,  339,  425,  426,  340,  341,  342,  343,
 /*    60 */   344,  345,  346,  347,  348,  474,   64,   63,   62,   61,
 /*    70 */    54,   51,   73,  306,  148,  474,  492,  161,  119,  297,
 /*    80 */   112,  113,  120,  161,  119,  427,  428,  339,   30,   81,
 /*    90 */   109,  447,  454,   29,  474,  528,  161,  119,  450,  322,
 /*   100 */   323,    9,    8,   33,  149,   32,    7,   71,  127,  163,
 /*   110 */   335,   66,  535,   36,   27,  339,  339,  339,  339,  425,
 /*   120 */   426,  340,  341,  342,  343,  344,  345,  346,  347,  348,
 /*   130 */   394,  435,  310,   59,   60,   64,   63,   62,   61,  313,
 /*   140 */    74,  376,  148,   69,    2,  533,  161,  119,  124,  113,
 /*   150 */   120,  161,  119,   80,  535,   31,  308,   79,   83,  107,
 /*   160 */   535,  441,  440,  535,  394,  435,  299,   59,   60,  120,
 /*   170 */   161,  119,  149,  463,  376,  376,  330,   84,    2,  122,
 /*   180 */    78,   78,   38,  156,  156,  156,   48,   37,  559,  328,
 /*   190 */   128,  152,  560,  561,  434,  441,  440,  350,  350,  350,
 /*   200 */   350,  350,  350,  350,  350,  350,  350,  350,  577,   77,


 /*   210 */   577,   35,  106,   46,  436,  437,  438,  439,  579,  375,
 /*   220 */   298,  117,  393,  155,  154,  153,   47,    4,  434,   69,
 /*   230 */   394,  435,    3,   59,   60,  411,  412,  413,  414,  398,
 /*   240 */   399,  376,   62,   61,    2,  108,  106,    5,  436,  437,
 /*   250 */   438,  439,  375,  375,  117,  117,  393,  155,  154,  153,
 /*   260 */    76,  441,  440,   67,    6,  142,  140,   64,   63,   62,
 /*   270 */    61,  380,  157,  424,  427,  428,  339,  379,  159,   45,
 /*   280 */   423,   72,  131,  148,  531,  161,  119,    1,   55,  125,
 /*   290 */   113,  120,  161,  119,  434,  147,  146,   64,   63,   62,
 /*   300 */    61,  397,   43,   11,  339,  339,  339,  339,  425,  426,
 /*   310 */   355,   65,  106,  149,  436,  437,  438,  439,   74,  375,
 /*   320 */   148,  117,  393,  155,  154,  153,  497,  113,  120,  161,
 /*   330 */   119,   22,   21,   12,  142,  140,   64,   63,   62,   61,

 /*   340 */    24,  356,  145,  141,  431,   64,   63,   62,   61,  391,
 /*   350 */   149,  448,  454,   29,  378,  158,   85,   55,  450,  394,
 /*   360 */   432,  138,   59,   60,  147,  146,  120,  161,  119,  163,
 /*   370 */   102,   43,  139,   42,   27,  430,   14,   15,  301,  302,
 /*   380 */   303,  446,  305,   16,   44,   74,   18,  148,  152,   19,
 /*   390 */    20,   36,   68,  496,  113,  120,  161,  119,  114,  359,
 /*   400 */    22,   21,   23,  142,  140,   64,   63,   62,   61,   24,
 /*   410 */   107,  145,  141,  431,   26,   57,  377,  149,   58,  118,
 /*   420 */   120,  161,  119,  392,  463,  384,   55,   64,   63,   62,
 /*   430 */    61,  382,  569,  147,  146,  160,  383,  435,   39,   70,
 /*   440 */    43,  106,  152,  445,  445,   88,  445,  445,  375,  445,
 /*   450 */   117,  393,  155,  154,  153,  120,  161,  119,  445,   17,
 /*   460 */   445,   10,  479,  479,  445,  445,  435,  441,  440,   22,
 /*   470 */    21,  445,  403,   64,   63,   62,   61,  152,   24,  445,
 /*   480 */   145,  141,  431,  133,   75,  126,  354,  445,  445,  123,
 /*   490 */   445,  404,  405,  406,  408,   80,  441,  440,  308,   79,
 /*   500 */   434,  411,  412,  413,  414,  394,  445,  445,   59,   60,
 /*   510 */    64,   63,   62,   61,  445,  445,  376,  445,  445,   42,
 /*   520 */   436,  437,  438,  439,  156,  156,  156,  394,  445,  434,
 /*   530 */    59,   60,   64,   63,   62,   61,  445,  445,  376,  445,
 /*   540 */   445,   42,  445,  394,  473,  391,   59,   60,  445,  436,
 /*   550 */   437,  438,  439,   49,  376,  445,   74,   42,  148,  445,
 /*   560 */    88,  445,  445,  445,  490,  113,  120,  161,  119,  445,
 /*   570 */   120,  161,  119,  132,  130,  394,  143,  475,   59,   60,
 /*   580 */   445,  473,   64,   63,   62,   61,  376,  106,  149,   42,
 /*   590 */   445,  445,  152,  445,  375,  391,  117,  393,  155,  154,
 /*   600 */   153,  394,  144,   52,   59,   60,  445,  445,  445,  106,
 /*   610 */   445,  445,  376,  445,  445,   42,  375,  445,  117,  393,
 /*   620 */   155,  154,  153,  445,  445,  106,   64,   63,   62,   61,
 /*   630 */   445,  445,  375,  445,  117,  393,  155,  154,  153,  394,
 /*   640 */   445,  445,   59,   60,   88,  445,  445,   53,  445,  445,
 /*   650 */   376,  445,  445,   42,  120,  161,  119,  106,  445,  445,

 /*   660 */   445,  110,  110,  445,  375,  445,  117,  393,  155,  154,
 /*   670 */   153,  394,  445,  445,   59,   60,  152,  107,  445,  445,
 /*   680 */   445,  445,  102,  106,  445,   42,  445,  120,  161,  119,
 /*   690 */   375,  451,  117,  393,  155,  154,  153,  394,  445,  445,
 /*   700 */    59,   60,   64,   63,   62,   61,  445,  445,  376,  152,
 /*   710 */   445,   40,  445,  394,  445,  396,   59,   60,  445,  445,
 /*   720 */   445,  106,  445,  445,  376,   88,  445,   41,  375,  445,
 /*   730 */   117,  393,  155,  154,  153,  120,  161,  119,   74,  445,
 /*   740 */   148,  445,  111,  111,  107,  445,  484,  113,  120,  161,
 /*   750 */   119,  445,  445,  106,  120,  161,  119,  152,  478,  445,
 /*   760 */   375,   86,  117,  393,  155,  154,  153,  445,  445,  445,
 /*   770 */   149,  120,  161,  119,  445,  445,  152,  445,  445,  106,
 /*   780 */   445,   64,   63,   62,   61,  445,  375,  445,  117,  393,
 /*   790 */   155,  154,  153,  152,  395,  106,   64,   63,   62,   61,
 /*   800 */    98,  445,  375,  445,  117,  393,  155,  154,  153,  445,
 /*   810 */   120,  161,  119,  445,   74,  445,  148,   56,  445,   74,
 /*   820 */   445,  148,  483,  113,  120,  161,  119,  480,  113,  120,
 /*   830 */   161,  119,  152,   74,  445,  148,  445,   89,  445,  445,
 /*   840 */   445,  134,  113,  120,  161,  119,  149,  120,  161,  119,
 /*   850 */   445,  149,   74,  445,  148,  445,  445,  445,  378,  158,

 /*   860 */   517,  113,  120,  161,  119,  149,   74,  445,  148,  152,

 /*   870 */   445,   74,  445,  148,  137,  113,  120,  161,  119,  525,
 /*   880 */   113,  120,  161,  119,  149,   74,  445,  148,   64,   63,
 /*   890 */    62,   61,  445,  527,  113,  120,  161,  119,  149,  445,

 /*   900 */   445,  391,  445,  149,  445,  445,  445,  445,  445,  445,
 /*   910 */    74,  445,  148,  445,  445,  162,  445,  149,  524,  113,
 /*   920 */   120,  161,  119,  118,  445,   74,  445,  148,  445,  445,
 /*   930 */   445,  445,  445,  526,  113,  120,  161,  119,  445,   74,

 /*   940 */   445,  148,  149,  445,  445,  445,  445,  523,  113,  120,
 /*   950 */   161,  119,   74,  445,  148,  445,  445,  149,  445,  445,
 /*   960 */   522,  113,  120,  161,  119,  445,   74,  445,  148,  445,
 /*   970 */   445,  149,  445,  445,  521,  113,  120,  161,  119,   74,
 /*   980 */   445,  148,  445,  445,  149,  445,  445,  520,  113,  120,
 /*   990 */   161,  119,  445,   74,  445,  148,  445,  445,  149,  445,
 /*  1000 */   445,  519,  113,  120,  161,  119,  445,  445,  445,  445,
 /*  1010 */   445,  149,  445,  445,  445,  445,  445,  445,   74,  445,
 /*  1020 */   148,  445,  445,  445,  445,  149,  150,  113,  120,  161,
 /*  1030 */   119,   74,  445,  148,  445,  445,  445,  445,  445,  151,
 /*  1040 */   113,  120,  161,  119,  445,   74,  445,  148,  445,  445,
 /*  1050 */   149,  445,  445,  136,  113,  120,  161,  119,   74,  445,
 /*  1060 */   148,  445,  445,  149,  445,  445,  135,  113,  120,  161,

 /*  1070 */   119,  445,   88,  445,  445,  445,  445,  149,  445,  445,
 /*  1080 */   445,   90,  120,  161,  119,  445,  445,  445,  445,   82,
 /*  1090 */   149,  120,  161,  119,  445,   87,  466,  445,   34,   99,
 /*  1100 */   445,  445,  445,  445,  152,  120,  161,  119,  100,  120,
 /*  1110 */   161,  119,  445,  152,  445,  445,  445,  445,  120,  161,
 /*  1120 */   119,  445,  445,  445,  101,  445,  445,  152,  445,  445,
 /*  1130 */   445,  152,   91,  445,  120,  161,  119,  103,  445,  445,
 /*  1140 */   152,  445,  120,  161,  119,  445,  445,  120,  161,  119,
 /*  1150 */   445,   92,  445,  445,  445,  445,  152,  445,  445,  445,
 /*  1160 */    93,  120,  161,  119,  152,  445,  104,  445,  445,  152,
 /*  1170 */   120,  161,  119,  445,   94,  445,  120,  161,  119,  445,
 /*  1180 */   445,  445,  445,  152,  120,  161,  119,  445,  445,  105,
 /*  1190 */   445,  445,  152,  445,  445,  445,  445,   95,  152,  120,
 /*  1200 */   161,  119,   96,  445,  445,   97,  152,  120,  161,  119,
 /*  1210 */   445,  445,  120,  161,  119,  120,  161,  119,  445,  445,
 /*  1220 */   445,  152,  445,  445,  445,  445,  445,  445,  445,  152,
 /*  1230 */   549,  445,  445,  548,  152,  445,  445,  152,  547,  445,
 /*  1240 */   120,  161,  119,  120,  161,  119,  546,  445,  120,  161,
 /*  1250 */   119,  445,  445,  445,  445,  445,  120,  161,  119,  445,
 /*  1260 */   445,  445,  152,  445,  445,  152,  445,  445,  445,  115,

 /*  1270 */   152,  445,  116,  445,  445,  445,  445,  445,  152,  120,
 /*  1280 */   161,  119,  120,  161,  119,  445,  445,  445,  445,  445,
 /*  1290 */   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
 /*  1300 */   445,  152,  445,  445,  152,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */     0,  115,  116,  117,  136,  103,  104,  105,  107,  107,
 /*    10 */    10,    4,    5,    6,    7,  113,  114,  115,  116,  117,
 /*    20 */    20,   21,   22,   17,   24,  101,  102,  103,  104,   29,
 /*    30 */   107,   25,   25,  109,   34,   35,   36,   37,   38,  137,
 /*    40 */    40,   41,   42,   43,  120,   45,   46,  109,  124,  125,
 /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   59,
 /*    60 */    60,   61,   62,   63,   64,    0,    4,    5,    6,    7,
 /*    70 */     4,    5,  105,   25,  107,   10,  115,  116,  117,   17,
 /*    80 */   113,  114,  115,  116,  117,   20,   21,   22,  128,   24,
 /*    90 */   101,  102,  103,  104,   29,  115,  116,  117,  109,   34,
 /*   100 */    35,   36,   37,   38,  137,   40,   41,   42,   43,  120,
 /*   110 */    45,   46,   49,   10,  125,   50,   51,   52,   53,   54,
 /*   120 */    55,   56,   57,   58,   59,   60,   61,   62,   63,   64,
 /*   130 */     1,    2,   29,    4,    5,    4,    5,    6,    7,    8,
 /*   140 */   105,   12,  107,    3,   15,  115,  116,  117,  113,  114,
 /*   150 */   115,  116,  117,   24,   91,  130,   27,   28,  118,  105,
 /*   160 */    97,   32,   33,  100,    1,    2,   19,    4,    5,  115,
 /*   170 */   116,  117,  137,  119,   12,   12,    2,  118,   15,    1,
 /*   180 */   126,  127,  106,   20,   21,   22,  110,  111,  106,    2,
 /*   190 */   107,  137,  110,  111,   65,   32,   33,   65,   66,   67,
 /*   200 */    68,   69,   70,   71,   72,   73,   74,   75,  132,  133,
 /*   210 */   134,  131,   83,   39,   85,   86,   87,   88,  135,   90,
 /*   220 */    17,   92,   93,   94,   95,   96,   39,   15,   65,   89,
 /*   230 */     1,    2,   16,    4,    5,   30,   31,   32,   33,   98,
 /*   240 */    99,   12,    6,    7,   15,   83,   83,   41,   85,   86,
 /*   250 */    87,   88,   90,   90,   92,   92,   93,   94,   95,   96,
 /*   260 */    49,   32,   33,   44,   41,    2,    3,    4,    5,    6,
 /*   270 */     7,   27,   28,   42,   20,   21,   22,   27,   28,   16,
 /*   280 */    42,  105,   48,  107,  115,  116,  117,   13,   25,  113,
 /*   290 */   114,  115,  116,  117,   65,   32,   33,    4,    5,    6,
 /*   300 */     7,   17,   39,   25,   50,   51,   52,   53,   54,   55,
 /*   310 */    17,  100,   83,  137,   85,   86,   87,   88,  105,   90,
 /*   320 */   107,   92,   93,   94,   95,   96,  113,  114,  115,  116,
 /*   330 */   117,   68,   69,   76,    2,    3,    4,    5,    6,    7,

 /*   340 */    77,   17,   79,   80,   81,    4,    5,    6,    7,   17,
 /*   350 */   137,  102,  103,  104,   27,   28,  105,   25,  109,    1,
 /*   360 */    81,   80,    4,    5,   32,   33,  115,  116,  117,  120,
 /*   370 */    12,   39,   82,   15,  125,   81,    3,   36,   20,   21,
 /*   380 */    22,    0,   24,    3,   39,  105,    3,  107,  137,    3,
 /*   390 */     3,   10,    3,  113,  114,  115,  116,  117,   97,   78,
 /*   400 */    68,   69,   25,    2,    3,    4,    5,    6,    7,   77,

 /*   410 */   105,   79,   80,   81,   15,   15,   12,  137,   15,   92,
 /*   420 */   115,  116,  117,   17,  119,   29,   25,    4,    5,    6,
 /*   430 */     7,   29,  127,   32,   33,   91,   29,    2,   11,    3,
 /*   440 */    39,   83,  137,  138,  138,  105,  138,  138,   90,  138,
 /*   450 */    92,   93,   94,   95,   96,  115,  116,  117,  138,   36,
 /*   460 */   138,  121,  122,  123,  138,  138,    2,   32,   33,   68,
 /*   470 */    69,  138,    1,    4,    5,    6,    7,  137,   77,  138,
 /*   480 */    79,   80,   81,   12,   49,   14,   17,  138,  138,   18,
 /*   490 */   138,   20,   21,   22,   23,   24,   32,   33,   27,   28,
 /*   500 */    65,   30,   31,   32,   33,    1,  138,  138,    4,    5,
 /*   510 */     4,    5,    6,    7,  138,  138,   12,  138,  138,   15,
 /*   520 */    85,   86,   87,   88,   20,   21,   22,    1,  138,   65,
 /*   530 */     4,    5,    4,    5,    6,    7,  138,  138,   12,  138,
 /*   540 */   138,   15,  138,    1,    2,   17,    4,    5,  138,   85,
 /*   550 */    86,   87,   88,   25,   12,  138,  105,   15,  107,  138,
 /*   560 */   105,  138,  138,  138,  113,  114,  115,  116,  117,  138,
 /*   570 */   115,  116,  117,   47,   48,    1,    2,  122,    4,    5,
 /*   580 */   138,   39,    4,    5,    6,    7,   12,   83,  137,   15,
 /*   590 */   138,  138,  137,  138,   90,   17,   92,   93,   94,   95,
 /*   600 */    96,    1,    2,   25,    4,    5,  138,  138,  138,   83,
 /*   610 */   138,  138,   12,  138,  138,   15,   90,  138,   92,   93,
 /*   620 */    94,   95,   96,  138,  138,   83,    4,    5,    6,    7,
 /*   630 */   138,  138,   90,  138,   92,   93,   94,   95,   96,    1,
 /*   640 */   138,  138,    4,    5,  105,  138,  138,   25,  138,  138,
 /*   650 */    12,  138,  138,   15,  115,  116,  117,   83,  138,  138,
 /*   660 */   138,  122,  123,  138,   90,  138,   92,   93,   94,   95,
 /*   670 */    96,    1,  138,  138,    4,    5,  137,  105,  138,  138,
 /*   680 */   138,  138,   12,   83,  138,   15,  138,  115,  116,  117,
 /*   690 */    90,  119,   92,   93,   94,   95,   96,    1,  138,  138,
 /*   700 */     4,    5,    4,    5,    6,    7,  138,  138,   12,  137,
 /*   710 */   138,   15,  138,    1,  138,   17,    4,    5,  138,  138,
 /*   720 */   138,   83,  138,  138,   12,  105,  138,   15,   90,  138,
 /*   730 */    92,   93,   94,   95,   96,  115,  116,  117,  105,  138,
 /*   740 */   107,  138,  122,  123,  105,  138,  113,  114,  115,  116,
 /*   750 */   117,  138,  138,   83,  115,  116,  117,  137,  119,  138,
 /*   760 */    90,  105,   92,   93,   94,   95,   96,  138,  138,  138,
 /*   770 */   137,  115,  116,  117,  138,  138,  137,  138,  138,   83,
 /*   780 */   138,    4,    5,    6,    7,  138,   90,  138,   92,   93,
 /*   790 */    94,   95,   96,  137,   17,   83,    4,    5,    6,    7,
 /*   800 */   105,  138,   90,  138,   92,   93,   94,   95,   96,  138,
 /*   810 */   115,  116,  117,  138,  105,  138,  107,   25,  138,  105,
 /*   820 */   138,  107,  113,  114,  115,  116,  117,  113,  114,  115,
 /*   830 */   116,  117,  137,  105,  138,  107,  138,  105,  138,  138,
 /*   840 */   138,  113,  114,  115,  116,  117,  137,  115,  116,  117,
 /*   850 */   138,  137,  105,  138,  107,  138,  138,  138,   27,   28,
 /*   860 */   113,  114,  115,  116,  117,  137,  105,  138,  107,  137,
 /*   870 */   138,  105,  138,  107,  113,  114,  115,  116,  117,  113,
 /*   880 */   114,  115,  116,  117,  137,  105,  138,  107,    4,    5,
 /*   890 */     6,    7,  138,  113,  114,  115,  116,  117,  137,  138,
 /*   900 */   138,   17,  138,  137,  138,  138,  138,  138,  138,  138,
 /*   910 */   105,  138,  107,  138,  138,   84,  138,  137,  113,  114,
 /*   920 */   115,  116,  117,   92,  138,  105,  138,  107,  138,  138,
 /*   930 */   138,  138,  138,  113,  114,  115,  116,  117,  138,  105,
 /*   940 */   138,  107,  137,  138,  138,  138,  138,  113,  114,  115,
 /*   950 */   116,  117,  105,  138,  107,  138,  138,  137,  138,  138,
 /*   960 */   113,  114,  115,  116,  117,  138,  105,  138,  107,  138,
 /*   970 */   138,  137,  138,  138,  113,  114,  115,  116,  117,  105,
 /*   980 */   138,  107,  138,  138,  137,  138,  138,  113,  114,  115,
 /*   990 */   116,  117,  138,  105,  138,  107,  138,  138,  137,  138,
 /*  1000 */   138,  113,  114,  115,  116,  117,  138,  138,  138,  138,
 /*  1010 */   138,  137,  138,  138,  138,  138,  138,  138,  105,  138,
 /*  1020 */   107,  138,  138,  138,  138,  137,  113,  114,  115,  116,
 /*  1030 */   117,  105,  138,  107,  138,  138,  138,  138,  138,  113,
 /*  1040 */   114,  115,  116,  117,  138,  105,  138,  107,  138,  138,
 /*  1050 */   137,  138,  138,  113,  114,  115,  116,  117,  105,  138,
 /*  1060 */   107,  138,  138,  137,  138,  138,  113,  114,  115,  116,
 /*  1070 */   117,  138,  105,  138,  138,  138,  138,  137,  138,  138,
 /*  1080 */   138,  105,  115,  116,  117,  138,  138,  138,  138,  122,
 /*  1090 */   137,  115,  116,  117,  138,  105,  129,  138,  131,  105,
 /*  1100 */   138,  138,  138,  138,  137,  115,  116,  117,  105,  115,
 /*  1110 */   116,  117,  138,  137,  138,  138,  138,  138,  115,  116,
 /*  1120 */   117,  138,  138,  138,  105,  138,  138,  137,  138,  138,
 /*  1130 */   138,  137,  105,  138,  115,  116,  117,  105,  138,  138,
 /*  1140 */   137,  138,  115,  116,  117,  138,  138,  115,  116,  117,
 /*  1150 */   138,  105,  138,  138,  138,  138,  137,  138,  138,  138,
 /*  1160 */   105,  115,  116,  117,  137,  138,  105,  138,  138,  137,
 /*  1170 */   115,  116,  117,  138,  105,  138,  115,  116,  117,  138,
 /*  1180 */   138,  138,  138,  137,  115,  116,  117,  138,  138,  105,
 /*  1190 */   138,  138,  137,  138,  138,  138,  138,  105,  137,  115,
 /*  1200 */   116,  117,  105,  138,  138,  105,  137,  115,  116,  117,
 /*  1210 */   138,  138,  115,  116,  117,  115,  116,  117,  138,  138,
 /*  1220 */   138,  137,  138,  138,  138,  138,  138,  138,  138,  137,
 /*  1230 */   105,  138,  138,  105,  137,  138,  138,  137,  105,  138,
 /*  1240 */   115,  116,  117,  115,  116,  117,  105,  138,  115,  116,
 /*  1250 */   117,  138,  138,  138,  138,  138,  115,  116,  117,  138,
 /*  1260 */   138,  138,  137,  138,  138,  137,  138,  138,  138,  105,
 /*  1270 */   137,  138,  105,  138,  138,  138,  138,  138,  137,  115,
 /*  1280 */   116,  117,  115,  116,  117,  138,  138,  138,  138,  138,
 /*  1290 */   138,  138,  138,  138,  138,  138,  138,  138,  138,  138,
 /*  1300 */   138,  137,  138,  138,  137,  101,  101,  101,  101,  101,
 /*  1310 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1320 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1330 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1340 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1350 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1360 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1370 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1380 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1390 */   101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
 /*  1400 */   101,  101,  101,  101,  101,  101,

};
#define YY_SHIFT_COUNT    (163)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (884)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */   471,  129,  163,  229,  229,  229,  229,  229,  229,  229,
 /*    10 */   229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
 /*    20 */   229,  229,  229,  229,  229,  229,  229,  358,  526,  638,
 /*    30 */   358,  471,  542,  542,    0,   65,  471,  670,  638,  670,
 /*    40 */   504,  504,  504,  574,  600,  638,  638,  638,  638,  638,
 /*    50 */   638,  696,  638,  638,  712,  638,  638,  638,  638,  638,
 /*    60 */   638,  638,  638,  638,  638,  254,  162,  162,  162,  162,
 /*    70 */   162,  435,  263,  332,  401,  464,  464,  205,   48, 1305,
 /*    80 */  1305, 1305, 1305,  132,  132,  528,  578,   62,  131,  341,
 /*    90 */   423,  293,    7,  469,  622,  698,  792,  777,  884,  506,
 /*   100 */   506,  506,   63,  506,  506,  506,  831,  506,  327,  103,
 /*   110 */   174,  187,    6,   66,  141,  236,  236,  244,  250,  140,
 /*   120 */   211,  381,  147,  178,  203,  216,  212,  219,  206,  223,
 /*   130 */   231,  238,  234,  274,  284,  278,  257,  324,  279,  281,
 /*   140 */   290,  294,  373,  380,  383,  345,  386,  387,  389,  301,
 /*   150 */   321,  377,  301,  399,  400,  403,  406,  396,  402,  407,
 /*   160 */   404,  344,  436,  427,
};
#define YY_REDUCE_COUNT (82)
#define YY_REDUCE_MIN   (-132)
#define YY_REDUCE_MAX   (1167)
static const short yy_reduce_ofst[] = {
 /*     0 */   -76,  -98,  -33,   35,  176,  213,  280,  451,  633,  709,
 /*    10 */   714,  728,  747,  761,  766,  780,  805,  820,  834,  847,
 /*    20 */   861,  874,  888,  913,  926,  940,  953,   54,  340,  967,
 /*    30 */   305,  -11,  539,  620,   76,   76,  249,  639,  455,  572,
 /*    40 */   251,  656,  695,  732,  976,  990,  994, 1003, 1019, 1027,
 /*    50 */  1032, 1046, 1055, 1061, 1069, 1084, 1092, 1097, 1100, 1125,
 /*    60 */  1128, 1133, 1141, 1164, 1167,   82, -114,  -39,  -20,   30,
 /*    70 */   169,   83, -132, -132, -132,  -99,  -77,  -62,  -40,   25,
 /*    80 */    40,   59,   80,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   449,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 /*    10 */   443,  443,  443,  443,  443,  443,  443,  443,  443,  443,
 /*    20 */   443,  443,  443,  443,  443,  443,  443,  443,  473,  576,
 /*    30 */   443,  449,  580,  485,  581,  581,  449,  443,  443,  443,
 /*    40 */   443,  443,  443,  443,  443,  443,  443,  443,  477,  443,

    0,  /*  CODEBLOCK => nothing */
    0,  /*       FILL => nothing */
    0,  /*      COLOR => nothing */
    0,  /*  THICKNESS => nothing */
    0,  /*      PRINT => nothing */
    0,  /*     STRING => nothing */
    0,  /*      COMMA => nothing */
    0,  /*    ISODATE => nothing */
    0,  /*  CLASSNAME => nothing */
    0,  /*         LB => nothing */
    0,  /*         RB => nothing */
    0,  /*         UP => nothing */
    0,  /*       DOWN => nothing */
    0,  /*       LEFT => nothing */
    0,  /*      RIGHT => nothing */

  /*   19 */ "CODEBLOCK",
  /*   20 */ "FILL",
  /*   21 */ "COLOR",
  /*   22 */ "THICKNESS",
  /*   23 */ "PRINT",
  /*   24 */ "STRING",
  /*   25 */ "COMMA",
  /*   26 */ "ISODATE",
  /*   27 */ "CLASSNAME",
  /*   28 */ "LB",
  /*   29 */ "RB",
  /*   30 */ "UP",
  /*   31 */ "DOWN",
  /*   32 */ "LEFT",
  /*   33 */ "RIGHT",
  /*   34 */ "CLOSE",
  /*   35 */ "CHOP",
  /*   36 */ "FROM",
  /*   37 */ "TO",
  /*   38 */ "THEN",
  /*   39 */ "HEADING",
  /*   40 */ "GO",
  /*   41 */ "AT",
  /*   42 */ "WITH",
  /*   43 */ "SAME",
  /*   44 */ "AS",
  /*   45 */ "FIT",
  /*   46 */ "BEHIND",
  /*   47 */ "UNTIL",
  /*   48 */ "EVEN",
  /*   49 */ "DOT_E",
  /*   50 */ "HEIGHT",
  /*   51 */ "WIDTH",
  /*   52 */ "RADIUS",
  /*   53 */ "DIAMETER",
  /*   54 */ "DOTTED",
  /*   55 */ "DASHED",
  /*   56 */ "CW",
  /*   57 */ "CCW",
  /*   58 */ "LARROW",
  /*   59 */ "RARROW",
  /*   60 */ "LRARROW",
  /*   61 */ "INVIS",
  /*   62 */ "THICK",
  /*   63 */ "THIN",
  /*   64 */ "SOLID",
  /*   65 */ "CENTER",
  /*   66 */ "LJUST",
  /*   67 */ "RJUST",
  /*   68 */ "ABOVE",
  /*   69 */ "BELOW",
  /*   70 */ "ITALIC",
  /*   71 */ "BOLD",
  /*   72 */ "MONO",
  /*   73 */ "ALIGNED",
  /*   74 */ "BIG",
  /*   75 */ "SMALL",
  /*   76 */ "AND",
  /*   77 */ "LT",
  /*   78 */ "GT",
  /*   79 */ "ON",
  /*   80 */ "WAY",
  /*   81 */ "BETWEEN",
  /*   82 */ "THE",
  /*   83 */ "NTH",
  /*   84 */ "VERTEX",
  /*   85 */ "TOP",
  /*   86 */ "BOTTOM",
  /*   87 */ "START",
  /*   88 */ "END",
  /*   89 */ "IN",
  /*   90 */ "THIS",
  /*   91 */ "DOT_U",
  /*   92 */ "LAST",
  /*   93 */ "NUMBER",
  /*   94 */ "FUNC1",
  /*   95 */ "FUNC2",
  /*   96 */ "DIST",
  /*   97 */ "DOT_XY",
  /*   98 */ "X",
  /*   99 */ "Y",
  /*  100 */ "DOT_L",
  /*  101 */ "statement_list",
  /*  102 */ "statement",
  /*  103 */ "unnamed_statement",
  /*  104 */ "basetype",
  /*  105 */ "expr",
  /*  106 */ "numproperty",
  /*  107 */ "edge",
  /*  108 */ "isodate",
  /*  109 */ "direction",
  /*  110 */ "dashproperty",


  /*  111 */ "colorproperty",
  /*  112 */ "locproperty",
  /*  113 */ "position",
  /*  114 */ "place",
  /*  115 */ "object",
  /*  116 */ "objectname",
  /*  117 */ "nth",
  /*  118 */ "textposition",
  /*  119 */ "rvalue",
  /*  120 */ "lvalue",
  /*  121 */ "even",
  /*  122 */ "relexpr",
  /*  123 */ "optrelexpr",
  /*  124 */ "document",
  /*  125 */ "print",
  /*  126 */ "prlist",
  /*  127 */ "pritem",
  /*  128 */ "prsep",
  /*  129 */ "attribute_list",
  /*  130 */ "savelist",
  /*  131 */ "alist",
  /*  132 */ "attribute",
  /*  133 */ "go",
  /*  134 */ "boolproperty",
  /*  135 */ "withclause",
  /*  136 */ "between",
  /*  137 */ "place2",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */

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

    ** being destroyed before it is finished parsing.
    **
    ** 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 101: /* statement_list */
{
#line 524 "pikchr.y"
pik_elist_free(p,(yypminor->yy23));
#line 1805 "pikchr.c"
}
      break;
    case 102: /* statement */
    case 103: /* unnamed_statement */
    case 104: /* basetype */
{
#line 526 "pikchr.y"
pik_elem_free(p,(yypminor->yy54));
#line 1814 "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 559 "pikchr.y"

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

/*
** Print tracing information for a SHIFT action

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

/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
** of that rule */
static const YYCODETYPE yyRuleInfoLhs[] = {
   124,  /* (0) document ::= statement_list */
   101,  /* (1) statement_list ::= statement */
   101,  /* (2) statement_list ::= statement_list EOL statement */
   102,  /* (3) statement ::= */
   102,  /* (4) statement ::= direction */
   102,  /* (5) statement ::= lvalue ASSIGN rvalue */
   102,  /* (6) statement ::= PLACENAME COLON unnamed_statement */
   102,  /* (7) statement ::= PLACENAME COLON position */
   102,  /* (8) statement ::= unnamed_statement */
   102,  /* (9) statement ::= print prlist */
   102,  /* (10) statement ::= ASSERT LP expr EQ expr RP */
   102,  /* (11) statement ::= ASSERT LP position EQ position RP */
   102,  /* (12) statement ::= DEFINE ID CODEBLOCK */
   119,  /* (13) rvalue ::= PLACENAME */
   127,  /* (14) pritem ::= FILL */
   127,  /* (15) pritem ::= COLOR */
   127,  /* (16) pritem ::= THICKNESS */
   127,  /* (17) pritem ::= rvalue */
   127,  /* (18) pritem ::= STRING */
   128,  /* (19) prsep ::= COMMA */
   103,  /* (20) unnamed_statement ::= basetype attribute_list */
   104,  /* (21) basetype ::= CLASSNAME */
   104,  /* (22) basetype ::= STRING textposition */
   104,  /* (23) basetype ::= LB savelist statement_list RB */
   130,  /* (24) savelist ::= */
   122,  /* (25) relexpr ::= expr */
   122,  /* (26) relexpr ::= expr PERCENT */
   123,  /* (27) optrelexpr ::= */
   129,  /* (28) attribute_list ::= relexpr alist */
   132,  /* (29) attribute ::= numproperty relexpr */
   132,  /* (30) attribute ::= dashproperty expr */
   132,  /* (31) attribute ::= dashproperty */
   132,  /* (32) attribute ::= colorproperty rvalue */
   132,  /* (33) attribute ::= go direction optrelexpr */
   132,  /* (34) attribute ::= go direction even position */
   132,  /* (35) attribute ::= CLOSE */
   132,  /* (36) attribute ::= CHOP */
   132,  /* (37) attribute ::= FROM position */
   132,  /* (38) attribute ::= TO position */
   132,  /* (39) attribute ::= THEN */
   132,  /* (40) attribute ::= THEN optrelexpr HEADING expr */
   132,  /* (41) attribute ::= THEN optrelexpr EDGEPT */
   132,  /* (42) attribute ::= GO optrelexpr HEADING expr */
   132,  /* (43) attribute ::= GO optrelexpr EDGEPT */
   132,  /* (44) attribute ::= AT position */
   132,  /* (45) attribute ::= SAME */
   132,  /* (46) attribute ::= SAME AS object */
   132,  /* (47) attribute ::= STRING textposition */
   132,  /* (48) attribute ::= FIT */
   132,  /* (49) attribute ::= BEHIND object */
   135,  /* (50) withclause ::= DOT_E edge AT position */
   135,  /* (51) withclause ::= edge AT position */
   106,  /* (52) numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
   134,  /* (53) boolproperty ::= CW */
   134,  /* (54) boolproperty ::= CCW */
   134,  /* (55) boolproperty ::= LARROW */
   134,  /* (56) boolproperty ::= RARROW */
   134,  /* (57) boolproperty ::= LRARROW */
   134,  /* (58) boolproperty ::= INVIS */
   134,  /* (59) boolproperty ::= THICK */
   134,  /* (60) boolproperty ::= THIN */
   134,  /* (61) boolproperty ::= SOLID */
   118,  /* (62) textposition ::= */
   118,  /* (63) textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|MONO|ALIGNED|BIG|SMALL */
   113,  /* (64) position ::= expr COMMA expr */
   113,  /* (65) position ::= place PLUS expr COMMA expr */
   113,  /* (66) position ::= place MINUS expr COMMA expr */
   113,  /* (67) position ::= place PLUS LP expr COMMA expr RP */
   113,  /* (68) position ::= place MINUS LP expr COMMA expr RP */
   113,  /* (69) position ::= LP position COMMA position RP */
   113,  /* (70) position ::= LP position RP */
   113,  /* (71) position ::= expr between position AND position */
   113,  /* (72) position ::= expr LT position COMMA position GT */
   113,  /* (73) position ::= expr ABOVE position */
   113,  /* (74) position ::= expr BELOW position */
   113,  /* (75) position ::= expr LEFT OF position */
   113,  /* (76) position ::= expr RIGHT OF position */
   113,  /* (77) position ::= expr ON HEADING EDGEPT OF position */
   113,  /* (78) position ::= expr HEADING EDGEPT OF position */
   113,  /* (79) position ::= expr EDGEPT OF position */
   113,  /* (80) position ::= expr ON HEADING expr FROM position */
   113,  /* (81) position ::= expr HEADING expr FROM position */
   114,  /* (82) place ::= edge OF object */
   137,  /* (83) place2 ::= object */
   137,  /* (84) place2 ::= object DOT_E edge */
   137,  /* (85) place2 ::= NTH VERTEX OF object */
   115,  /* (86) object ::= nth */
   115,  /* (87) object ::= nth OF|IN object */
   116,  /* (88) objectname ::= THIS */
   116,  /* (89) objectname ::= PLACENAME */
   116,  /* (90) objectname ::= objectname DOT_U PLACENAME */
   117,  /* (91) nth ::= NTH CLASSNAME */
   117,  /* (92) nth ::= NTH LAST CLASSNAME */
   117,  /* (93) nth ::= LAST CLASSNAME */
   117,  /* (94) nth ::= LAST */
   117,  /* (95) nth ::= NTH LB RB */
   117,  /* (96) nth ::= NTH LAST LB RB */
   117,  /* (97) nth ::= LAST LB RB */
   105,  /* (98) expr ::= expr PLUS expr */
   105,  /* (99) expr ::= expr MINUS expr */
   105,  /* (100) expr ::= expr STAR expr */
   105,  /* (101) expr ::= expr SLASH expr */
   105,  /* (102) expr ::= MINUS expr */
   105,  /* (103) expr ::= PLUS expr */
   105,  /* (104) expr ::= LP expr RP */
   105,  /* (105) expr ::= LP FILL|COLOR|THICKNESS RP */
   105,  /* (106) expr ::= NUMBER */
   105,  /* (107) expr ::= ID */
   105,  /* (108) expr ::= FUNC1 LP expr RP */
   105,  /* (109) expr ::= FUNC2 LP expr COMMA expr RP */
   105,  /* (110) expr ::= DIST LP position COMMA position RP */
   105,  /* (111) expr ::= place2 DOT_XY X */
   105,  /* (112) expr ::= place2 DOT_XY Y */
   105,  /* (113) expr ::= object DOT_L numproperty */
   105,  /* (114) expr ::= object DOT_L dashproperty */
   105,  /* (115) expr ::= object DOT_L colorproperty */
   120,  /* (116) lvalue ::= ID */
   120,  /* (117) lvalue ::= FILL */
   120,  /* (118) lvalue ::= COLOR */
   120,  /* (119) lvalue ::= THICKNESS */
   119,  /* (120) rvalue ::= expr */
   125,  /* (121) print ::= PRINT */
   126,  /* (122) prlist ::= pritem */
   126,  /* (123) prlist ::= prlist prsep pritem */
   109,  /* (124) direction ::= UP */
   109,  /* (125) direction ::= DOWN */
   109,  /* (126) direction ::= LEFT */
   109,  /* (127) direction ::= RIGHT */
   123,  /* (128) optrelexpr ::= relexpr */
   129,  /* (129) attribute_list ::= alist */
   131,  /* (130) alist ::= */
   131,  /* (131) alist ::= alist attribute */
   132,  /* (132) attribute ::= boolproperty */
   132,  /* (133) attribute ::= WITH withclause */
   133,  /* (134) go ::= GO */
   133,  /* (135) go ::= */
   121,  /* (136) even ::= UNTIL EVEN WITH */
   121,  /* (137) even ::= EVEN WITH */
   110,  /* (138) dashproperty ::= DOTTED */
   110,  /* (139) dashproperty ::= DASHED */
   111,  /* (140) colorproperty ::= FILL */
   111,  /* (141) colorproperty ::= COLOR */
   113,  /* (142) position ::= place */
   136,  /* (143) between ::= WAY BETWEEN */
   136,  /* (144) between ::= BETWEEN */
   136,  /* (145) between ::= OF THE WAY BETWEEN */
   114,  /* (146) place ::= place2 */
   107,  /* (147) edge ::= CENTER */
   107,  /* (148) edge ::= EDGEPT */
   107,  /* (149) edge ::= TOP */
   107,  /* (150) edge ::= BOTTOM */
   107,  /* (151) edge ::= START */
   107,  /* (152) edge ::= END */
   107,  /* (153) edge ::= RIGHT */
   107,  /* (154) edge ::= LEFT */
   115,  /* (155) object ::= objectname */
};

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

  **     { ... }           // User supplied code
  **  #line <lineno> <thisfile>
  **     break;
  */
/********** Begin reduce actions **********************************************/
        YYMINORTYPE yylhsminor;
      case 0: /* document ::= statement_list */
#line 563 "pikchr.y"
{pik_render(p,yymsp[0].minor.yy23);}
#line 2479 "pikchr.c"
        break;
      case 1: /* statement_list ::= statement */
#line 566 "pikchr.y"
{ yylhsminor.yy23 = pik_elist_append(p,0,yymsp[0].minor.yy54); }
#line 2484 "pikchr.c"
  yymsp[0].minor.yy23 = yylhsminor.yy23;
        break;
      case 2: /* statement_list ::= statement_list EOL statement */
#line 568 "pikchr.y"
{ yylhsminor.yy23 = pik_elist_append(p,yymsp[-2].minor.yy23,yymsp[0].minor.yy54); }
#line 2490 "pikchr.c"
  yymsp[-2].minor.yy23 = yylhsminor.yy23;
        break;
      case 3: /* statement ::= */
#line 571 "pikchr.y"
{ yymsp[1].minor.yy54 = 0; }
#line 2496 "pikchr.c"
        break;
      case 4: /* statement ::= direction */
#line 572 "pikchr.y"
{ pik_set_direction(p,yymsp[0].minor.yy0.eCode);  yylhsminor.yy54=0; }
#line 2501 "pikchr.c"
  yymsp[0].minor.yy54 = yylhsminor.yy54;
        break;
      case 5: /* statement ::= lvalue ASSIGN rvalue */
#line 573 "pikchr.y"
{pik_set_var(p,&yymsp[-2].minor.yy0,yymsp[0].minor.yy129,&yymsp[-1].minor.yy0); yylhsminor.yy54=0;}
#line 2507 "pikchr.c"
  yymsp[-2].minor.yy54 = yylhsminor.yy54;
        break;
      case 6: /* statement ::= PLACENAME COLON unnamed_statement */
#line 575 "pikchr.y"
{ yylhsminor.yy54 = yymsp[0].minor.yy54;  pik_elem_setname(p,yymsp[0].minor.yy54,&yymsp[-2].minor.yy0); }
#line 2513 "pikchr.c"
  yymsp[-2].minor.yy54 = yylhsminor.yy54;
        break;
      case 7: /* statement ::= PLACENAME COLON position */
#line 577 "pikchr.y"
{ yylhsminor.yy54 = pik_elem_new(p,0,0,0);
                 if(yylhsminor.yy54){ yylhsminor.yy54->ptAt = yymsp[0].minor.yy187; pik_elem_setname(p,yylhsminor.yy54,&yymsp[-2].minor.yy0); }}
#line 2520 "pikchr.c"
  yymsp[-2].minor.yy54 = yylhsminor.yy54;
        break;
      case 8: /* statement ::= unnamed_statement */
#line 579 "pikchr.y"
{yylhsminor.yy54 = yymsp[0].minor.yy54;}
#line 2526 "pikchr.c"
  yymsp[0].minor.yy54 = yylhsminor.yy54;
        break;
      case 9: /* statement ::= print prlist */
#line 580 "pikchr.y"
{pik_append(p,"<br>\n",5); yymsp[-1].minor.yy54=0;}
#line 2532 "pikchr.c"
        break;
      case 10: /* statement ::= ASSERT LP expr EQ expr RP */
#line 585 "pikchr.y"
{yymsp[-5].minor.yy54=pik_assert(p,yymsp[-3].minor.yy129,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy129);}
#line 2537 "pikchr.c"
        break;
      case 11: /* statement ::= ASSERT LP position EQ position RP */
#line 587 "pikchr.y"
{yymsp[-5].minor.yy54=pik_position_assert(p,&yymsp[-3].minor.yy187,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy187);}
#line 2542 "pikchr.c"
        break;
      case 12: /* statement ::= DEFINE ID CODEBLOCK */
#line 588 "pikchr.y"
{yymsp[-2].minor.yy54=0; pik_add_macro(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
#line 2547 "pikchr.c"
        break;
      case 13: /* rvalue ::= PLACENAME */
#line 599 "pikchr.y"
{yylhsminor.yy129 = pik_lookup_color(p,&yymsp[0].minor.yy0);}
#line 2552 "pikchr.c"
  yymsp[0].minor.yy129 = yylhsminor.yy129;
        break;
      case 14: /* pritem ::= FILL */
      case 15: /* pritem ::= COLOR */ yytestcase(yyruleno==15);
      case 16: /* pritem ::= THICKNESS */ yytestcase(yyruleno==16);
#line 604 "pikchr.y"
{pik_append_num(p,"",pik_value(p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.n,0));}
#line 2560 "pikchr.c"
        break;
      case 17: /* pritem ::= rvalue */
#line 607 "pikchr.y"
{pik_append_num(p,"",yymsp[0].minor.yy129);}
#line 2565 "pikchr.c"
        break;
      case 18: /* pritem ::= STRING */
#line 608 "pikchr.y"
{pik_append_text(p,yymsp[0].minor.yy0.z+1,yymsp[0].minor.yy0.n-2,0);}
#line 2570 "pikchr.c"
        break;
      case 19: /* prsep ::= COMMA */
#line 609 "pikchr.y"
{pik_append(p, " ", 1);}
#line 2575 "pikchr.c"
        break;
      case 20: /* unnamed_statement ::= basetype attribute_list */
#line 614 "pikchr.y"
{yylhsminor.yy54 = yymsp[-1].minor.yy54; pik_after_adding_attributes(p,yylhsminor.yy54);}
#line 2580 "pikchr.c"
  yymsp[-1].minor.yy54 = yylhsminor.yy54;
        break;
      case 21: /* basetype ::= CLASSNAME */
#line 616 "pikchr.y"
{yylhsminor.yy54 = pik_elem_new(p,&yymsp[0].minor.yy0,0,0); }
#line 2586 "pikchr.c"
  yymsp[0].minor.yy54 = yylhsminor.yy54;
        break;
      case 22: /* basetype ::= STRING textposition */
#line 618 "pikchr.y"
{yymsp[-1].minor.yy0.eCode = yymsp[0].minor.yy272; yylhsminor.yy54 = pik_elem_new(p,0,&yymsp[-1].minor.yy0,0); }
#line 2592 "pikchr.c"
  yymsp[-1].minor.yy54 = yylhsminor.yy54;
        break;
      case 23: /* basetype ::= LB savelist statement_list RB */
#line 620 "pikchr.y"
{ p->list = yymsp[-2].minor.yy23; yymsp[-3].minor.yy54 = pik_elem_new(p,0,0,yymsp[-1].minor.yy23); if(yymsp[-3].minor.yy54) yymsp[-3].minor.yy54->errTok = yymsp[0].minor.yy0; }
#line 2598 "pikchr.c"
        break;
      case 24: /* savelist ::= */
#line 625 "pikchr.y"
{yymsp[1].minor.yy23 = p->list; p->list = 0;}
#line 2603 "pikchr.c"
        break;
      case 25: /* relexpr ::= expr */
#line 632 "pikchr.y"
{yylhsminor.yy28.rAbs = yymsp[0].minor.yy129; yylhsminor.yy28.rRel = 0;}
#line 2608 "pikchr.c"
  yymsp[0].minor.yy28 = yylhsminor.yy28;
        break;
      case 26: /* relexpr ::= expr PERCENT */
#line 633 "pikchr.y"
{yylhsminor.yy28.rAbs = 0; yylhsminor.yy28.rRel = yymsp[-1].minor.yy129/100;}
#line 2614 "pikchr.c"
  yymsp[-1].minor.yy28 = yylhsminor.yy28;
        break;
      case 27: /* optrelexpr ::= */
#line 635 "pikchr.y"
{yymsp[1].minor.yy28.rAbs = 0; yymsp[1].minor.yy28.rRel = 1.0;}
#line 2620 "pikchr.c"
        break;
      case 28: /* attribute_list ::= relexpr alist */
#line 637 "pikchr.y"
{pik_add_direction(p,0,&yymsp[-1].minor.yy28);}
#line 2625 "pikchr.c"
        break;
      case 29: /* attribute ::= numproperty relexpr */
#line 641 "pikchr.y"
{ pik_set_numprop(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy28); }
#line 2630 "pikchr.c"
        break;
      case 30: /* attribute ::= dashproperty expr */
#line 642 "pikchr.y"
{ pik_set_dashed(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy129); }
#line 2635 "pikchr.c"
        break;
      case 31: /* attribute ::= dashproperty */
#line 643 "pikchr.y"
{ pik_set_dashed(p,&yymsp[0].minor.yy0,0);  }
#line 2640 "pikchr.c"
        break;
      case 32: /* attribute ::= colorproperty rvalue */
#line 644 "pikchr.y"
{ pik_set_clrprop(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy129); }
#line 2645 "pikchr.c"
        break;
      case 33: /* attribute ::= go direction optrelexpr */
#line 645 "pikchr.y"
{ pik_add_direction(p,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy28);}
#line 2650 "pikchr.c"
        break;
      case 34: /* attribute ::= go direction even position */
#line 646 "pikchr.y"
{pik_evenwith(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy187);}
#line 2655 "pikchr.c"
        break;
      case 35: /* attribute ::= CLOSE */
#line 647 "pikchr.y"
{ pik_close_path(p,&yymsp[0].minor.yy0); }
#line 2660 "pikchr.c"
        break;
      case 36: /* attribute ::= CHOP */
#line 648 "pikchr.y"
{ p->cur->bChop = 1; }
#line 2665 "pikchr.c"
        break;
      case 37: /* attribute ::= FROM position */
#line 649 "pikchr.y"
{ pik_set_from(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy187); }
#line 2670 "pikchr.c"
        break;
      case 38: /* attribute ::= TO position */
#line 650 "pikchr.y"
{ pik_add_to(p,p->cur,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy187); }
#line 2675 "pikchr.c"
        break;
      case 39: /* attribute ::= THEN */
#line 651 "pikchr.y"
{ pik_then(p, &yymsp[0].minor.yy0, p->cur); }
#line 2680 "pikchr.c"
        break;
      case 40: /* attribute ::= THEN optrelexpr HEADING expr */
      case 42: /* attribute ::= GO optrelexpr HEADING expr */ yytestcase(yyruleno==42);
#line 653 "pikchr.y"
{pik_move_hdg(p,&yymsp[-2].minor.yy28,&yymsp[-1].minor.yy0,yymsp[0].minor.yy129,0,&yymsp[-3].minor.yy0);}
#line 2686 "pikchr.c"
        break;
      case 41: /* attribute ::= THEN optrelexpr EDGEPT */
      case 43: /* attribute ::= GO optrelexpr EDGEPT */ yytestcase(yyruleno==43);
#line 654 "pikchr.y"
{pik_move_hdg(p,&yymsp[-1].minor.yy28,0,0,&yymsp[0].minor.yy0,&yymsp[-2].minor.yy0);}
#line 2692 "pikchr.c"
        break;
      case 44: /* attribute ::= AT position */
#line 659 "pikchr.y"
{ pik_set_at(p,0,&yymsp[0].minor.yy187,&yymsp[-1].minor.yy0); }
#line 2697 "pikchr.c"
        break;
      case 45: /* attribute ::= SAME */
#line 661 "pikchr.y"
{pik_same(p,0,&yymsp[0].minor.yy0);}
#line 2702 "pikchr.c"
        break;
      case 46: /* attribute ::= SAME AS object */
#line 662 "pikchr.y"
{pik_same(p,yymsp[0].minor.yy54,&yymsp[-2].minor.yy0);}
#line 2707 "pikchr.c"
        break;
      case 47: /* attribute ::= STRING textposition */
#line 663 "pikchr.y"
{pik_add_txt(p,&yymsp[-1].minor.yy0,yymsp[0].minor.yy272);}
#line 2712 "pikchr.c"
        break;
      case 48: /* attribute ::= FIT */
#line 664 "pikchr.y"
{pik_size_to_fit(p,0,&yymsp[0].minor.yy0,3); }
#line 2717 "pikchr.c"
        break;
      case 49: /* attribute ::= BEHIND object */
#line 665 "pikchr.y"
{pik_behind(p,yymsp[0].minor.yy54);}
#line 2722 "pikchr.c"
        break;
      case 50: /* withclause ::= DOT_E edge AT position */
      case 51: /* withclause ::= edge AT position */ yytestcase(yyruleno==51);
#line 673 "pikchr.y"
{ pik_set_at(p,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy187,&yymsp[-1].minor.yy0); }
#line 2728 "pikchr.c"
        break;
      case 52: /* numproperty ::= HEIGHT|WIDTH|RADIUS|DIAMETER|THICKNESS */
#line 677 "pikchr.y"
{yylhsminor.yy0 = yymsp[0].minor.yy0;}
#line 2733 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 53: /* boolproperty ::= CW */
#line 688 "pikchr.y"
{p->cur->cw = 1;}
#line 2739 "pikchr.c"
        break;
      case 54: /* boolproperty ::= CCW */
#line 689 "pikchr.y"
{p->cur->cw = 0;}
#line 2744 "pikchr.c"
        break;
      case 55: /* boolproperty ::= LARROW */
#line 690 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=0; }
#line 2749 "pikchr.c"
        break;
      case 56: /* boolproperty ::= RARROW */
#line 691 "pikchr.y"
{p->cur->larrow=0; p->cur->rarrow=1; }
#line 2754 "pikchr.c"
        break;
      case 57: /* boolproperty ::= LRARROW */
#line 692 "pikchr.y"
{p->cur->larrow=1; p->cur->rarrow=1; }
#line 2759 "pikchr.c"
        break;
      case 58: /* boolproperty ::= INVIS */
#line 693 "pikchr.y"
{p->cur->sw = -0.00001;}
#line 2764 "pikchr.c"
        break;
      case 59: /* boolproperty ::= THICK */
#line 694 "pikchr.y"
{p->cur->sw *= 1.5;}
#line 2769 "pikchr.c"
        break;
      case 60: /* boolproperty ::= THIN */
#line 695 "pikchr.y"
{p->cur->sw *= 0.67;}
#line 2774 "pikchr.c"
        break;
      case 61: /* boolproperty ::= SOLID */
#line 696 "pikchr.y"
{p->cur->sw = pik_value(p,"thickness",9,0);
                               p->cur->dotted = p->cur->dashed = 0.0;}
#line 2780 "pikchr.c"
        break;
      case 62: /* textposition ::= */
#line 699 "pikchr.y"
{yymsp[1].minor.yy272 = 0;}
#line 2785 "pikchr.c"
        break;
      case 63: /* textposition ::= textposition CENTER|LJUST|RJUST|ABOVE|BELOW|ITALIC|BOLD|MONO|ALIGNED|BIG|SMALL */
#line 702 "pikchr.y"
{yylhsminor.yy272 = (short int)pik_text_position(yymsp[-1].minor.yy272,&yymsp[0].minor.yy0);}
#line 2790 "pikchr.c"
  yymsp[-1].minor.yy272 = yylhsminor.yy272;
        break;
      case 64: /* position ::= expr COMMA expr */
#line 705 "pikchr.y"
{yylhsminor.yy187.x=yymsp[-2].minor.yy129; yylhsminor.yy187.y=yymsp[0].minor.yy129;}
#line 2796 "pikchr.c"
  yymsp[-2].minor.yy187 = yylhsminor.yy187;
        break;
      case 65: /* position ::= place PLUS expr COMMA expr */
#line 707 "pikchr.y"
{yylhsminor.yy187.x=yymsp[-4].minor.yy187.x+yymsp[-2].minor.yy129; yylhsminor.yy187.y=yymsp[-4].minor.yy187.y+yymsp[0].minor.yy129;}
#line 2802 "pikchr.c"
  yymsp[-4].minor.yy187 = yylhsminor.yy187;
        break;
      case 66: /* position ::= place MINUS expr COMMA expr */
#line 708 "pikchr.y"
{yylhsminor.yy187.x=yymsp[-4].minor.yy187.x-yymsp[-2].minor.yy129; yylhsminor.yy187.y=yymsp[-4].minor.yy187.y-yymsp[0].minor.yy129;}
#line 2808 "pikchr.c"
  yymsp[-4].minor.yy187 = yylhsminor.yy187;
        break;
      case 67: /* position ::= place PLUS LP expr COMMA expr RP */
#line 710 "pikchr.y"
{yylhsminor.yy187.x=yymsp[-6].minor.yy187.x+yymsp[-3].minor.yy129; yylhsminor.yy187.y=yymsp[-6].minor.yy187.y+yymsp[-1].minor.yy129;}
#line 2814 "pikchr.c"
  yymsp[-6].minor.yy187 = yylhsminor.yy187;
        break;
      case 68: /* position ::= place MINUS LP expr COMMA expr RP */
#line 712 "pikchr.y"
{yylhsminor.yy187.x=yymsp[-6].minor.yy187.x-yymsp[-3].minor.yy129; yylhsminor.yy187.y=yymsp[-6].minor.yy187.y-yymsp[-1].minor.yy129;}
#line 2820 "pikchr.c"
  yymsp[-6].minor.yy187 = yylhsminor.yy187;
        break;
      case 69: /* position ::= LP position COMMA position RP */
#line 713 "pikchr.y"
{yymsp[-4].minor.yy187.x=yymsp[-3].minor.yy187.x; yymsp[-4].minor.yy187.y=yymsp[-1].minor.yy187.y;}
#line 2826 "pikchr.c"
        break;
      case 70: /* position ::= LP position RP */
#line 714 "pikchr.y"
{yymsp[-2].minor.yy187=yymsp[-1].minor.yy187;}
#line 2831 "pikchr.c"
        break;
      case 71: /* position ::= expr between position AND position */
#line 716 "pikchr.y"
{yylhsminor.yy187 = pik_position_between(yymsp[-4].minor.yy129,yymsp[-2].minor.yy187,yymsp[0].minor.yy187);}
#line 2836 "pikchr.c"
  yymsp[-4].minor.yy187 = yylhsminor.yy187;
        break;
      case 72: /* position ::= expr LT position COMMA position GT */
#line 718 "pikchr.y"
{yylhsminor.yy187 = pik_position_between(yymsp[-5].minor.yy129,yymsp[-3].minor.yy187,yymsp[-1].minor.yy187);}
#line 2842 "pikchr.c"
  yymsp[-5].minor.yy187 = yylhsminor.yy187;
        break;
      case 73: /* position ::= expr ABOVE position */
#line 719 "pikchr.y"
{yylhsminor.yy187=yymsp[0].minor.yy187; yylhsminor.yy187.y += yymsp[-2].minor.yy129;}
#line 2848 "pikchr.c"
  yymsp[-2].minor.yy187 = yylhsminor.yy187;
        break;
      case 74: /* position ::= expr BELOW position */
#line 720 "pikchr.y"
{yylhsminor.yy187=yymsp[0].minor.yy187; yylhsminor.yy187.y -= yymsp[-2].minor.yy129;}
#line 2854 "pikchr.c"
  yymsp[-2].minor.yy187 = yylhsminor.yy187;
        break;
      case 75: /* position ::= expr LEFT OF position */
#line 721 "pikchr.y"
{yylhsminor.yy187=yymsp[0].minor.yy187; yylhsminor.yy187.x -= yymsp[-3].minor.yy129;}
#line 2860 "pikchr.c"
  yymsp[-3].minor.yy187 = yylhsminor.yy187;
        break;
      case 76: /* position ::= expr RIGHT OF position */
#line 722 "pikchr.y"
{yylhsminor.yy187=yymsp[0].minor.yy187; yylhsminor.yy187.x += yymsp[-3].minor.yy129;}
#line 2866 "pikchr.c"
  yymsp[-3].minor.yy187 = yylhsminor.yy187;
        break;
      case 77: /* position ::= expr ON HEADING EDGEPT OF position */
#line 724 "pikchr.y"
{yylhsminor.yy187 = pik_position_at_hdg(yymsp[-5].minor.yy129,&yymsp[-2].minor.yy0,yymsp[0].minor.yy187);}
#line 2872 "pikchr.c"
  yymsp[-5].minor.yy187 = yylhsminor.yy187;
        break;
      case 78: /* position ::= expr HEADING EDGEPT OF position */
#line 726 "pikchr.y"
{yylhsminor.yy187 = pik_position_at_hdg(yymsp[-4].minor.yy129,&yymsp[-2].minor.yy0,yymsp[0].minor.yy187);}
#line 2878 "pikchr.c"
  yymsp[-4].minor.yy187 = yylhsminor.yy187;
        break;
      case 79: /* position ::= expr EDGEPT OF position */
#line 728 "pikchr.y"
{yylhsminor.yy187 = pik_position_at_hdg(yymsp[-3].minor.yy129,&yymsp[-2].minor.yy0,yymsp[0].minor.yy187);}
#line 2884 "pikchr.c"
  yymsp[-3].minor.yy187 = yylhsminor.yy187;
        break;
      case 80: /* position ::= expr ON HEADING expr FROM position */
#line 730 "pikchr.y"
{yylhsminor.yy187 = pik_position_at_angle(yymsp[-5].minor.yy129,yymsp[-2].minor.yy129,yymsp[0].minor.yy187);}
#line 2890 "pikchr.c"
  yymsp[-5].minor.yy187 = yylhsminor.yy187;
        break;
      case 81: /* position ::= expr HEADING expr FROM position */
#line 732 "pikchr.y"
{yylhsminor.yy187 = pik_position_at_angle(yymsp[-4].minor.yy129,yymsp[-2].minor.yy129,yymsp[0].minor.yy187);}
#line 2896 "pikchr.c"
  yymsp[-4].minor.yy187 = yylhsminor.yy187;
        break;
      case 82: /* place ::= edge OF object */
#line 744 "pikchr.y"
{yylhsminor.yy187 = pik_place_of_elem(p,yymsp[0].minor.yy54,&yymsp[-2].minor.yy0);}
#line 2902 "pikchr.c"
  yymsp[-2].minor.yy187 = yylhsminor.yy187;
        break;
      case 83: /* place2 ::= object */
#line 745 "pikchr.y"
{yylhsminor.yy187 = pik_place_of_elem(p,yymsp[0].minor.yy54,0);}
#line 2908 "pikchr.c"
  yymsp[0].minor.yy187 = yylhsminor.yy187;
        break;
      case 84: /* place2 ::= object DOT_E edge */
#line 746 "pikchr.y"
{yylhsminor.yy187 = pik_place_of_elem(p,yymsp[-2].minor.yy54,&yymsp[0].minor.yy0);}
#line 2914 "pikchr.c"
  yymsp[-2].minor.yy187 = yylhsminor.yy187;
        break;
      case 85: /* place2 ::= NTH VERTEX OF object */
#line 747 "pikchr.y"
{yylhsminor.yy187 = pik_nth_vertex(p,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,yymsp[0].minor.yy54);}
#line 2920 "pikchr.c"
  yymsp[-3].minor.yy187 = yylhsminor.yy187;
        break;
      case 86: /* object ::= nth */
#line 759 "pikchr.y"
{yylhsminor.yy54 = pik_find_nth(p,0,&yymsp[0].minor.yy0);}
#line 2926 "pikchr.c"
  yymsp[0].minor.yy54 = yylhsminor.yy54;
        break;
      case 87: /* object ::= nth OF|IN object */
#line 760 "pikchr.y"
{yylhsminor.yy54 = pik_find_nth(p,yymsp[0].minor.yy54,&yymsp[-2].minor.yy0);}
#line 2932 "pikchr.c"
  yymsp[-2].minor.yy54 = yylhsminor.yy54;
        break;
      case 88: /* objectname ::= THIS */
#line 762 "pikchr.y"
{yymsp[0].minor.yy54 = p->cur;}
#line 2938 "pikchr.c"
        break;
      case 89: /* objectname ::= PLACENAME */
#line 763 "pikchr.y"
{yylhsminor.yy54 = pik_find_byname(p,0,&yymsp[0].minor.yy0);}
#line 2943 "pikchr.c"
  yymsp[0].minor.yy54 = yylhsminor.yy54;
        break;
      case 90: /* objectname ::= objectname DOT_U PLACENAME */
#line 765 "pikchr.y"
{yylhsminor.yy54 = pik_find_byname(p,yymsp[-2].minor.yy54,&yymsp[0].minor.yy0);}
#line 2949 "pikchr.c"
  yymsp[-2].minor.yy54 = yylhsminor.yy54;
        break;
      case 91: /* nth ::= NTH CLASSNAME */
#line 767 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-1].minor.yy0); }
#line 2955 "pikchr.c"
  yymsp[-1].minor.yy0 = yylhsminor.yy0;
        break;
      case 92: /* nth ::= NTH LAST CLASSNAME */
#line 768 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-2].minor.yy0); }
#line 2961 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 93: /* nth ::= LAST CLASSNAME */
#line 769 "pikchr.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.eCode = -1;}
#line 2967 "pikchr.c"
        break;
      case 94: /* nth ::= LAST */
#line 770 "pikchr.y"
{yylhsminor.yy0=yymsp[0].minor.yy0; yylhsminor.yy0.eCode = -1;}
#line 2972 "pikchr.c"
  yymsp[0].minor.yy0 = yylhsminor.yy0;
        break;
      case 95: /* nth ::= NTH LB RB */
#line 771 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = pik_nth_value(p,&yymsp[-2].minor.yy0);}
#line 2978 "pikchr.c"
  yymsp[-2].minor.yy0 = yylhsminor.yy0;
        break;
      case 96: /* nth ::= NTH LAST LB RB */
#line 772 "pikchr.y"
{yylhsminor.yy0=yymsp[-1].minor.yy0; yylhsminor.yy0.eCode = -pik_nth_value(p,&yymsp[-3].minor.yy0);}
#line 2984 "pikchr.c"
  yymsp[-3].minor.yy0 = yylhsminor.yy0;
        break;
      case 97: /* nth ::= LAST LB RB */
#line 773 "pikchr.y"
{yymsp[-2].minor.yy0=yymsp[-1].minor.yy0; yymsp[-2].minor.yy0.eCode = -1; }
#line 2990 "pikchr.c"
        break;
      case 98: /* expr ::= expr PLUS expr */
#line 775 "pikchr.y"
{yylhsminor.yy129=yymsp[-2].minor.yy129+yymsp[0].minor.yy129;}
#line 2995 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 99: /* expr ::= expr MINUS expr */
#line 776 "pikchr.y"
{yylhsminor.yy129=yymsp[-2].minor.yy129-yymsp[0].minor.yy129;}
#line 3001 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 100: /* expr ::= expr STAR expr */
#line 777 "pikchr.y"
{yylhsminor.yy129=yymsp[-2].minor.yy129*yymsp[0].minor.yy129;}
#line 3007 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 101: /* expr ::= expr SLASH expr */
#line 778 "pikchr.y"
{
  if( yymsp[0].minor.yy129==0.0 ){ pik_error(p, &yymsp[-1].minor.yy0, "division by zero"); yylhsminor.yy129 = 0.0; }
  else{ yylhsminor.yy129 = yymsp[-2].minor.yy129/yymsp[0].minor.yy129; }
}
#line 3016 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 102: /* expr ::= MINUS expr */
#line 782 "pikchr.y"
{yymsp[-1].minor.yy129=-yymsp[0].minor.yy129;}
#line 3022 "pikchr.c"
        break;
      case 103: /* expr ::= PLUS expr */
#line 783 "pikchr.y"
{yymsp[-1].minor.yy129=yymsp[0].minor.yy129;}
#line 3027 "pikchr.c"
        break;
      case 104: /* expr ::= LP expr RP */
#line 784 "pikchr.y"
{yymsp[-2].minor.yy129=yymsp[-1].minor.yy129;}
#line 3032 "pikchr.c"
        break;
      case 105: /* expr ::= LP FILL|COLOR|THICKNESS RP */
#line 785 "pikchr.y"
{yymsp[-2].minor.yy129=pik_get_var(p,&yymsp[-1].minor.yy0);}
#line 3037 "pikchr.c"
        break;
      case 106: /* expr ::= NUMBER */
#line 786 "pikchr.y"
{yylhsminor.yy129=pik_atof(&yymsp[0].minor.yy0);}
#line 3042 "pikchr.c"
  yymsp[0].minor.yy129 = yylhsminor.yy129;
        break;
      case 107: /* expr ::= ID */
#line 787 "pikchr.y"
{yylhsminor.yy129=pik_get_var(p,&yymsp[0].minor.yy0);}
#line 3048 "pikchr.c"
  yymsp[0].minor.yy129 = yylhsminor.yy129;
        break;
      case 108: /* expr ::= FUNC1 LP expr RP */
#line 788 "pikchr.y"
{yylhsminor.yy129 = pik_func(p,&yymsp[-3].minor.yy0,yymsp[-1].minor.yy129,0.0);}
#line 3054 "pikchr.c"
  yymsp[-3].minor.yy129 = yylhsminor.yy129;
        break;
      case 109: /* expr ::= FUNC2 LP expr COMMA expr RP */
#line 789 "pikchr.y"
{yylhsminor.yy129 = pik_func(p,&yymsp[-5].minor.yy0,yymsp[-3].minor.yy129,yymsp[-1].minor.yy129);}
#line 3060 "pikchr.c"
  yymsp[-5].minor.yy129 = yylhsminor.yy129;
        break;
      case 110: /* expr ::= DIST LP position COMMA position RP */
#line 790 "pikchr.y"
{yymsp[-5].minor.yy129 = pik_dist(&yymsp[-3].minor.yy187,&yymsp[-1].minor.yy187);}
#line 3066 "pikchr.c"
        break;
      case 111: /* expr ::= place2 DOT_XY X */
#line 791 "pikchr.y"
{yylhsminor.yy129 = yymsp[-2].minor.yy187.x;}
#line 3071 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 112: /* expr ::= place2 DOT_XY Y */
#line 792 "pikchr.y"
{yylhsminor.yy129 = yymsp[-2].minor.yy187.y;}
#line 3077 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      case 113: /* expr ::= object DOT_L numproperty */
      case 114: /* expr ::= object DOT_L dashproperty */ yytestcase(yyruleno==114);
      case 115: /* expr ::= object DOT_L colorproperty */ yytestcase(yyruleno==115);
#line 793 "pikchr.y"
{yylhsminor.yy129=pik_property_of(yymsp[-2].minor.yy54,&yymsp[0].minor.yy0);}
#line 3085 "pikchr.c"
  yymsp[-2].minor.yy129 = yylhsminor.yy129;
        break;
      default:
      /* (116) lvalue ::= ID */ yytestcase(yyruleno==116);
      /* (117) lvalue ::= FILL */ yytestcase(yyruleno==117);
      /* (118) lvalue ::= COLOR */ yytestcase(yyruleno==118);
      /* (119) lvalue ::= THICKNESS */ yytestcase(yyruleno==119);
      /* (120) rvalue ::= expr */ yytestcase(yyruleno==120);

  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 551 "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 3196 "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 798 "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
**

}
/* Hack: Arcs are here rendered as quadratic Bezier curves rather
** than true arcs.  Multiple reasons: (1) the legacy-PIC parameters
** that control arcs are obscure and I could not figure out what they
** mean based on available documentation.  (2) Arcs are rarely used,
** and so do not seem that important.
*/
static PPoint arcControlPoint(int cw, PPoint f, PPoint t){
  PPoint m;
  PNum dx, dy;
  m.x = 0.5*(f.x+t.x);
  m.y = 0.5*(f.y+t.y);
  dx = t.x - f.x;
  dy = t.y - f.y;
  if( cw ){
    m.x -= 0.5*dy;
    m.y += 0.5*dx;
  }else{
    m.x += 0.5*dy;
    m.y -= 0.5*dx;
  }
  return m;
}
static void arcCheck(Pik *p, PObj *pObj){
  PPoint f, m, t;
  PNum sw;
  int i;
  if( p->nTPath>2 ){
    pik_error(p, &pObj->errTok, "arc geometry error");
    return;
  }
  f = p->aTPath[0];
  t = p->aTPath[1];
  m = arcControlPoint(pObj->cw, f, t);
  sw = pObj->sw;
  for(i=1; i<16; i++){
    PNum t1, t2, a, b, c, x, y;
    t1 = 0.0625*i;
    t2 = 1.0 - t1;
    a = t2*t2;
    b = 2*t1*t2;
    c = t1*t1;
    x = a*f.x + b*m.x + c*t.x;
    y = a*f.y + b*m.y + c*t.y;
    pik_bbox_addellipse(&pObj->bbox, x, y, sw, sw);
  }
}
static void arcRender(Pik *p, PObj *pObj){
  PPoint f, m, t;
  if( pObj->nPath<2 ) return;
  if( pObj->sw<0.0 ) return;
  f = pObj->aPath[0];
  t = pObj->aPath[1];
  m = arcControlPoint(pObj->cw,f,t);
  if( pObj->larrow ){
    pik_draw_arrowhead(p,&m,&f,pObj);
  }
  if( pObj->rarrow ){
    pik_draw_arrowhead(p,&m,&t,pObj);
  }
  pik_append_xy(p,"<path d=\"M", f.x, f.y);

  pObj->sw = 0.0;
}
static PPoint textOffset(Pik *p, PObj *pObj, int cp){
  /* Automatically slim-down the width and height of text
  ** statements so that the bounding box tightly encloses the text,
  ** then get boxOffset() to do the offset computation.
  */
  pik_size_to_fit(p, pObj, &pObj->errTok,3);
  return boxOffset(p, pObj, cp);
}
static void textRender(Pik *p, PObj *pObj){
  pik_append_txt(p, pObj, 0);
}

**
** The eWhich parameter is:
**
**    1:   Fit horizontally only
**    2:   Fit vertically only
**    3:   Fit both ways
*/
static void pik_size_to_fit(Pik *p, PObj *pObj, PToken *pFit, int eWhich){

  PNum w, h;
  PBox bbox;
  if( p->nErr ) return;
  if( pObj==0 ) pObj = p->cur;

  if( pObj->nTxt==0 ){
    pik_error(0, pFit, "no text to fit to");
    return;
  }
  if( pObj->type->xFit==0 ) return;
  pik_bbox_init(&bbox);

    const char *zClr;
    int c1, c2;
    unsigned int 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);
      c = c2 - c1;
      if( c ) break;
    }
    if( c==0 && aColor[mid].zName[pId->n] ) c = -1;
    if( c==0 ) return (double)aColor[mid].val;
    if( c>0 ){
      first = mid+1;

    /* A height or width less than or equal to zero means "autofit".
    ** Change the height or width to be big enough to contain the text,
    */
    if( pObj->h<=0.0 ){
      if( pObj->nTxt==0 ){
        pObj->h = 0.0;
      }else if( pObj->w<=0.0 ){
        pik_size_to_fit(p, pObj, &pObj->errTok, 3);
      }else{
        pik_size_to_fit(p, pObj, &pObj->errTok, 2);
      }
    }
    if( pObj->w<=0.0 ){
      if( pObj->nTxt==0 ){
        pObj->w = 0.0;
      }else{
        pik_size_to_fit(p, pObj, &pObj->errTok, 1);
      }
    }
    ofst = pik_elem_offset(p, pObj, pObj->eWith);
    dx = (pObj->with.x - ofst.x) - pObj->ptAt.x;
    dy = (pObj->with.y - ofst.y) - pObj->ptAt.y;
    if( dx!=0 || dy!=0 ){
      pik_elem_move(pObj, dx, dy);

      p->wSVG = pik_round(p->wSVG*pikScale);
      p->hSVG = pik_round(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,"\"");
    pik_append(p, " data-pikchr-date=\"" MANIFEST_ISODATE "\">\n", -1);
    pik_elist_render(p, pList);
    pik_append(p,"</svg>\n", -1);
  }else{
    p->wSVG = -1;
    p->hSVG = -1;
  }
  pik_elist_free(p, pList);

  { "mono",       4,   T_MONO,      0,         0        },
  { "monospace",  9,   T_MONO,      0,         0        },
  { "n",          1,   T_EDGEPT,    0,         CP_N     },
  { "ne",         2,   T_EDGEPT,    0,         CP_NE    },
  { "north",      5,   T_EDGEPT,    0,         CP_N     },
  { "nw",         2,   T_EDGEPT,    0,         CP_NW    },
  { "of",         2,   T_OF,        0,         0        },
  { "pikchr_date",11,  T_ISODATE,   0,         0,       },
  { "previous",   8,   T_LAST,      0,         0,       },
  { "print",      5,   T_PRINT,     0,         0        },
  { "rad",        3,   T_RADIUS,    0,         0        },
  { "radius",     6,   T_RADIUS,    0,         0        },
  { "right",      5,   T_RIGHT,     DIR_RIGHT, CP_E     },
  { "rjust",      5,   T_RJUST,     0,         0        },
  { "s",          1,   T_EDGEPT,    0,         CP_S     },

      pToken->eType = T_ERROR;
      return 1;
    }
    default: {
      c = z[0];
      if( c=='.' ){
        unsigned char c1 = z[1];
        if( IsLower(c1) ){
          const PikWord *pFound;
          for(i=2; (c = z[i])>='a' && c<='z'; i++){}
          pFound = pik_find_word((const char*)z+1, i-1,
                                    pik_keywords, count(pik_keywords));
          if( pFound && (pFound->eEdge>0 ||
                         pFound->eType==T_EDGEPT ||
                         pFound->eType==T_START ||
                         pFound->eType==T_END )
          ){
            /* Dot followed by something that is a 2-D place value */
            pToken->eType = T_DOT_E;
          }else if( pFound && (pFound->eType==T_X || pFound->eType==T_Y) ){
            /* Dot followed by "x" or "y" */
            pToken->eType = T_DOT_XY;
          }else{
            /* Any other "dot" */
            pToken->eType = T_DOT_L;
          }
          return 1;
        }else if( IsDigit(c1) ){
          i = 0;
          /* no-op.  Fall through to number handling */
        }else if( IsUpper(c1) ){
          for(i=2; (c = z[i])!=0 && (IsAlnum(c) || c=='_'); i++){}
          pToken->eType = T_DOT_U;
          return 1;
        }else{
          pToken->eType = T_ERROR;
          return 1;
        }
      }
      if( (c>='0' && c<='9') || c=='.' ){
        int nDigit;
        int isInt = 1;
        if( c!='.' ){
          nDigit = 1;
          for(i=1; (c = z[i])>='0' && c<='9'; i++){ nDigit++; }
          if( i==1 && (c=='x' || c=='X') ){
            for(i=2; (c = z[i])!=0 && IsXDigit(c); i++){}
            pToken->eType = T_NUMBER;
            return i;
          }
        }else{
          isInt = 0;
          nDigit = 0;
          i = 0;

         || (c=='p' && c2=='x')
         || (c=='p' && c2=='c')
        ){
          i += 2;
        }
        pToken->eType = T_NUMBER;
        return i;
      }else if( IsLower(c) ){
        const PikWord *pFound;
        for(i=1; (c =  z[i])!=0 && (IsAlnum(c) || c=='_'); i++){}
        pFound = pik_find_word((const char*)z, i,
                               pik_keywords, count(pik_keywords));
        if( pFound ){
          pToken->eType = pFound->eType;
          pToken->eCode = pFound->eCode;
          pToken->eEdge = pFound->eEdge;
          return i;
        }
        pToken->n = i;
        if( pik_find_class(pToken)!=0 ){
          pToken->eType = T_CLASSNAME;
        }else{
          pToken->eType = T_ID;
        }
        return i;
      }else if( c>='A' && c<='Z' ){
        for(i=1; (c =  z[i])!=0 && (IsAlnum(c) || c=='_'); i++){}
        pToken->eType = T_PLACENAME;
        return i;
      }else if( c=='$' && z[1]>='1' && z[1]<='9' && !IsDigit(z[2]) ){
        pToken->eType = T_PARAMETER;
        pToken->eCode = z[1] - '1';
        return 2;
      }else if( c=='_' || c=='$' || c=='@' ){
        for(i=1; (c =  z[i])!=0 && (IsAlnum(c) || c=='_'); i++){}
        pToken->eType = T_ID;
        return i;
      }else{
        pToken->eType = T_ERROR;
        return 1;
      }
    }

  if( z[i]==')' ){
    args[nArg].n = i - iStart;
    /* Remove leading and trailing whitespace from each argument.
    ** If what remains is one of $1, $2, ... $9 then transfer the
    ** corresponding argument from the outer context */
    for(j=0; j<=nArg; j++){
      PToken *t = &args[j];
      while( t->n>0 && IsSpace(t->z[0]) ){ t->n--; t->z++; }
      while( t->n>0 && IsSpace(t->z[t->n-1]) ){ t->n--; }
      if( t->n==2 && t->z[0]=='$' && t->z[1]>='1' && t->z[1]<='9' ){
        if( pOuter ) *t = pOuter[t->z[1]-'1'];
        else t->n = 0;
      }
    }
    return i+1;
  }

      pik_tokenize(p, &pMac->macroBody, pParser, args);
      p->nCtx--;
      pMac->inUse = 0;
    }else{
#if 0
      printf("******** Token %s (%d): \"%.*s\" **************\n",
             yyTokenName[token.eType], token.eType,
             (int)(IsSpace(token.z[0]) ? 0 : sz), token.z);
#endif
      token.n = (unsigned short)(sz & 0xffff);
      if( p->nToken++ > PIKCHR_TOKEN_LIMIT ){
        pik_error(p, &token, "script is too complex");
        break;
      }
      if( token.eType==T_ISODATE ){
        token.z = "\"" MANIFEST_ISODATE "\"";
        token.n = sizeof(MANIFEST_ISODATE)+1;
        token.eType = T_STRING;
      }
      pik_parser(pParser, token.eType, token);
    }
  }
}

/*
** Return the version name.
*/
const char *pikchr_version(void)
  /* Emscripten workaround, else it chokes on the inlined version */;

const char *pikchr_version(void){
  return RELEASE_VERSION " " MANIFEST_ISODATE;
}

/*
** Parse the PIKCHR script contained in zText[].  Return a rendering.  Or
** if an error is encountered, return the error text.  The error message
** is HTML formatted.  So regardless of what happens, the return text
** is safe to be insertd into an HTML output stream.
**

        if( zHtmlHdr==0 ){
          fprintf(stderr, "the \"%s\" option must come first\n",argv[i]);
          exit(1);
        }
        bSvgOnly = 1;
        mFlags |= PIKCHR_PLAINTEXT_ERRORS;
      }else
      if( strcmp(z,"version")==0 || strcmp(z,"v")==0 ){
        printf("pikchr %s\n", pikchr_version());
        return 0;
      }else
      {
        fprintf(stderr,"unknown option: \"%s\"\n", argv[i]);
        usage(argv[0]);
      }
      continue;
    }
    zIn = readFile(argv[i]);

  return TCL_OK;
}


#endif /* PIKCHR_TCL */


#line 8335 "pikchr.c"