func (r *lexer) setActionResult(head string, e *Expr, n int) {
var a term.ActionC
var t term.C
if e != nil {
t = toC(e)
}
switch strings.ToLower(head) {
case "return", "reply", "say", "respond", "answer":
if t == nil {
t = term.Cc(represent.Int(n))
}
a = term.ReturnC(t)
case "ask", "inquire", "do":
a = term.AskC(t)
case "view", "check", "inspect", "see":
if t == nil {
t = term.Cc(represent.Int(n))
}
a = term.ViewC(t)
case "replace", "rewrite", "change", "jump", "set":
a = term.ReplaceC(t, n)
case "replay", "redo", "repeat":
a = term.ReplayC(n)
case "correct", "fix", "debug":
a = term.CorrectC(n)
case "meta", "self", "here", "this":
a = term.MetaC()
case "close", "dismiss", "stop", "delete", "del", "remove":
c := toC(e)
switch c := c.(type) {
case term.ReferenceC:
a = term.DeleteC(c.Index)
}
default:
return
}
r.actionResult = &a
}
func getID(d dynamics.Dwimmer, s *term.SettingT, quoted term.T) term.T {
var result int
switch quoted.Head() {
case represent.QuotedSetting:
setting, err := represent.ToSetting(d, quoted)
if err != nil {
return term.Make("was asked to find the ID of a setting, " +
"but while converting to a setting received []").T(err)
}
result = int(setting.ID)
case term.Int(0).Head():
result = int(term.IDer.PackInt(int(quoted.(term.Int))).(intern.ID))
case term.Str("").Head():
result = int(term.IDer.PackString(string(quoted.(term.Str))).(intern.ID))
}
return core.Answer.T(represent.Int(result))
}
//TODO only do this sometimes, or control better the length, or something...
func GetHints(d dynamics.Dwimmer, context *term.SettingT, s *term.SettingS, n int) []string {
suggestions, err := d.Answer(similarity.SuggestedActions.T(
represent.Setting(s.Setting),
represent.Int(n),
), context)
if err != nil {
return []string{}
}
suggestionList, err := represent.ToList(d, suggestions)
if err != nil {
return []string{}
}
result := []string{}
for _, suggestion := range suggestionList {
actionC, err := represent.ToActionC(d, suggestion)
if err != nil {
continue
}
actionS := actionC.Uninstantiate(s.Names)
result = append(result, actionS.String())
}
reverseHints(result)
return result
}
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 nativeSize(d dynamics.Dwimmer, s *term.SettingT) term.T {
x, y := d.Size()
return WidthHeight.T(represent.Int(x), represent.Int(y))
}
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 */
}