func getInput(d dynamics.Dwimmer, context *term.SettingT, hintstrings, toolmap term.T) term.T {
quotedHints, err := represent.ToList(d, hintstrings)
if err != nil {
return represent.ConversionError.T(hintstrings, err)
}
hints := make([]string, len(quotedHints))
for i, quoted := range quotedHints {
hints[i], err = represent.ToStr(d, quoted)
if err != nil {
return represent.ConversionError.T(quoted, err)
}
}
tools := make(map[rune]string)
for toolmap.Head() != maps.Empty {
switch toolmap.Head() {
case maps.Cons:
vs := toolmap.Values()
c, err := represent.ToRune(d, vs[0])
if err != nil {
return represent.ConversionError.T(vs[0], err)
}
s, err := represent.ToStr(d, vs[1])
if err != nil {
return represent.ConversionError.T(vs[1], err)
}
tools[c] = s
toolmap = vs[2]
default:
context.AppendTerm(UnrecognizedDictionary.T())
return nil
}
}
input := d.Readln(" < ", hints, tools)
return core.Answer.T(represent.Str(input))
}
func displayTemplate(d dynamics.Dwimmer, context *term.SettingT, quotedSetting term.T) term.T {
setting, err := represent.ToSetting(d, quotedSetting)
if err != nil {
return represent.ConversionError.T(quotedSetting, err)
}
settingS := addNames(setting)
ShowSettingS(d, settingS)
d.Println("")
d.Println("")
quotedNames := make([]term.T, len(settingS.Names))
for i, name := range settingS.Names {
quotedNames[i] = represent.Str(name)
}
return Names.T(represent.List(quotedNames))
}
func TestRepresentations(t *testing.T) {
d := dwimmer.TestDwimmer()
defer d.Close()
template := term.Make("term with argument [] and second half here")
template2, err := represent.ToTemplate(d, represent.Template(template))
if err != nil {
t.Errorf("received error %v", err)
}
if template != template2 {
t.Errorf("%v != %v", template, template2)
}
setting := term.Init().Append(template)
setting2, err := represent.ToSetting(d, represent.Setting(setting))
if err != nil {
t.Errorf("received error %v", err)
}
if term.IDSetting(setting) != term.IDSetting(setting2) {
t.Errorf("%v != %v", setting, setting2)
}
actions := []term.ActionC{term.ReturnC(term.Cr(3)), term.ClarifyC(term.Cr(2), core.OK.C()), term.DeleteC(7)}
for _, action := range actions {
action2, err := represent.ToActionC(d, represent.ActionC(action))
if err != nil {
t.Errorf("received error %v", err)
}
if term.IDActionC(action) != term.IDActionC(action2) {
t.Errorf("%v != %v", action, action2)
}
}
stub := term.Make("stub")
tm := template.T(stub.T())
tm2, err := represent.ToT(d, represent.T(tm))
if err != nil {
t.Errorf("received error %v", err)
}
if tm2.String() != tm.String() {
t.Errorf("%v != %v", tm2, tm)
}
rep, err := d.Answer(represent.Explicit.T(represent.T(tm)))
if err != nil {
t.Errorf("failed to make representation explicit: %v", err)
}
tm3, err := represent.ToT(d, rep)
if err != nil {
t.Errorf("received error %v", err)
}
if tm3.String() != tm.String() {
t.Errorf("%v != %v", tm3, tm)
}
settingT := term.InitT().AppendTerm(tm)
settingT2, err := represent.ToSettingT(d, represent.SettingT(settingT))
if err != nil {
t.Errorf("received error %v")
}
if settingT2.Setting.ID != settingT.Setting.ID {
t.Errorf("%v != %v", settingT2, settingT)
}
n := -127
n2, err := represent.ToInt(d, represent.Int(n))
if err != nil {
t.Errorf("received error %v", err)
}
if n != n2 {
t.Errorf("%v != %v", n, n2)
}
s := "hello ₳"
s2, err := represent.ToStr(d, represent.Str(s))
if err != nil {
t.Errorf("received error %v", err)
}
if s != s2 {
t.Errorf("%s != %s", s, s2)
}
}
func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int {
var yyn int
var yylval yySymType
var yyVAL yySymType
var yyDollar []yySymType
_ = yyDollar // silence set and not used
yyS := make([]yySymType, yyMaxDepth)
Nerrs := 0 /* number of errors */
Errflag := 0 /* error recovery flag */
yystate := 0
yychar := -1
yytoken := -1 // yychar translated into internal numbering
yyrcvr.lookahead = func() int { return yychar }
defer func() {
// Make sure we report no lookahead when not parsing.
yystate = -1
yychar = -1
yytoken = -1
}()
yyp := -1
goto yystack
ret0:
return 0
ret1:
return 1
yystack:
/* put a state and value onto the stack */
if yyDebug >= 4 {
__yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate))
}
yyp++
if yyp >= len(yyS) {
nyys := make([]yySymType, len(yyS)*2)
copy(nyys, yyS)
yyS = nyys
}
yyS[yyp] = yyVAL
yyS[yyp].yys = yystate
yynewstate:
yyn = yyPact[yystate]
if yyn <= yyFlag {
goto yydefault /* simple state */
}
if yychar < 0 {
yychar, yytoken = yylex1(yylex, &yylval)
}
yyn += yytoken
if yyn < 0 || yyn >= yyLast {
goto yydefault
}
yyn = yyAct[yyn]
if yyChk[yyn] == yytoken { /* valid shift */
yychar = -1
yytoken = -1
yyVAL = yylval
yystate = yyn
if Errflag > 0 {
Errflag--
}
goto yystack
}
yydefault:
/* default state action */
yyn = yyDef[yystate]
if yyn == -2 {
if yychar < 0 {
yychar, yytoken = yylex1(yylex, &yylval)
}
/* look through exception table */
xi := 0
for {
if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
break
}
xi += 2
}
for xi += 2; ; xi += 2 {
yyn = yyExca[xi+0]
if yyn < 0 || yyn == yytoken {
break
}
}
yyn = yyExca[xi+1]
if yyn < 0 {
goto ret0
}
}
if yyn == 0 {
/* error ... attempt to resume parsing */
switch Errflag {
case 0: /* brand new error */
yylex.Error(yyErrorMessage(yystate, yytoken))
Nerrs++
if yyDebug >= 1 {
__yyfmt__.Printf("%s", yyStatname(yystate))
__yyfmt__.Printf(" saw %s\n", yyTokname(yytoken))
}
fallthrough
case 1, 2: /* incompletely recovered error ... try again */
Errflag = 3
/* find a state where "error" is a legal shift action */
for yyp >= 0 {
yyn = yyPact[yyS[yyp].yys] + yyErrCode
if yyn >= 0 && yyn < yyLast {
yystate = yyAct[yyn] /* simulate a shift of "error" */
if yyChk[yystate] == yyErrCode {
goto yystack
}
}
/* the current p has no shift on "error", pop stack */
if yyDebug >= 2 {
__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
}
yyp--
}
/* there is no state on the stack with an error shift ... abort */
goto ret1
case 3: /* no shift yet; clobber input char */
if yyDebug >= 2 {
__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken))
}
if yytoken == yyEofCode {
goto ret1
}
yychar = -1
yytoken = -1
goto yynewstate /* try again in the same state */
}
}
/* reduction by production yyn */
if yyDebug >= 2 {
__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
}
yynt := yyn
yypt := yyp
_ = yypt // guard against "declared and not used"
yyp -= yyR2[yyn]
// yyp is now the index of $0. Perform the default action. Iff the
// reduced production is ε, $1 is possibly out of range.
if yyp+1 >= len(yyS) {
nyys := make([]yySymType, len(yyS)*2)
copy(nyys, yyS)
yyS = nyys
}
yyVAL = yyS[yyp+1]
/* consult goto table to find next state */
yyn = yyR1[yyn]
yyg := yyPgo[yyn]
yyj := yyg + yyS[yyp].yys + 1
if yyj >= yyLast {
yystate = yyAct[yyg]
} else {
yystate = yyAct[yyj]
if yyChk[yystate] != -yyn {
yystate = yyAct[yyg]
}
}
// dummy call; replaced with literal code
switch yynt {
case 1:
yyDollar = yyS[yypt-6 : yypt+1]
//line parser.y:30
{
yylex.(*lexer).setActionResult(yyDollar[2].string, yyDollar[6].expr, yyDollar[4].int)
}
case 2:
yyDollar = yyS[yypt-4 : yypt+1]
//line parser.y:31
{
yylex.(*lexer).setActionResult(yyDollar[2].string, yyDollar[4].expr, -1)
}
case 3:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:32
{
yylex.(*lexer).setActionResult(yyDollar[2].string, nil, -1)
}
case 4:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:33
{
yylex.(*lexer).setTermResult(yyDollar[2].expr)
}
case 5:
yyDollar = yyS[yypt-4 : yypt+1]
//line parser.y:34
{
{
yylex.(*lexer).setActionResult(yyDollar[2].string, nil, yyDollar[4].int)
}
}
case 6:
yyDollar = yyS[yypt-8 : yypt+1]
//line parser.y:35
{
yylex.(*lexer).setTransitiveActionResult(yyDollar[2].string, yyDollar[6].string, yyDollar[8].expr)
}
case 7:
yyDollar = yyS[yypt-7 : yypt+1]
//line parser.y:36
{
yylex.(*lexer).setTransitiveActionResult(yyDollar[2].string, yyDollar[5].string, yyDollar[7].expr)
}
case 8:
yyDollar = yyS[yypt-7 : yypt+1]
//line parser.y:37
{
yylex.(*lexer).setTransitiveActionResult(yyDollar[2].string, yyDollar[5].string, yyDollar[7].expr)
}
case 9:
yyDollar = yyS[yypt-6 : yypt+1]
//line parser.y:38
{
yylex.(*lexer).setTransitiveActionResult(yyDollar[2].string, yyDollar[4].string, yyDollar[6].expr)
}
case 11:
yyDollar = yyS[yypt-0 : yypt+1]
//line parser.y:42
{
yyVAL.expr = EmptyExpr()
}
case 12:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:43
{
yyVAL.expr = yyDollar[1].expr
yyVAL.expr.append(yyDollar[2].clause)
}
case 16:
yyDollar = yyS[yypt-1 : yypt+1]
//line parser.y:46
{
yyVAL.clause = exprText(yyDollar[1].string)
}
case 17:
yyDollar = yyS[yypt-1 : yypt+1]
//line parser.y:47
{
yyVAL.clause = exprTerm{toC(yyDollar[1].expr)}
}
case 18:
yyDollar = yyS[yypt-3 : yypt+1]
//line parser.y:49
{
yyVAL.expr = yyDollar[2].expr
}
case 19:
yyDollar = yyS[yypt-3 : yypt+1]
//line parser.y:50
{
yyVAL.expr = yyDollar[2].expr
}
case 20:
yyDollar = yyS[yypt-3 : yypt+1]
//line parser.y:52
{
yyVAL.clause = exprTerm{term.ConstC{represent.Str(yyDollar[2].string)}}
}
case 21:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:53
{
yyVAL.clause = exprTerm{term.ConstC{represent.Str("")}}
}
case 22:
yyDollar = yyS[yypt-1 : yypt+1]
//line parser.y:55
{
yyVAL.clause = exprTerm{term.ConstC{represent.Int(yyDollar[1].int)}}
}
case 23:
yyDollar = yyS[yypt-1 : yypt+1]
//line parser.y:57
{
yyVAL.clause = yylex.(*lexer).parseWord(yyDollar[1].string)
}
case 26:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:59
{
yyVAL.string = yyDollar[1].string + yyDollar[2].string
}
case 39:
yyDollar = yyS[yypt-2 : yypt+1]
//line parser.y:65
{
yyVAL.string = yyDollar[1].string + yyDollar[2].string
}
}
goto yystack /* stack new state and value */
}