+++ /dev/null
-package main
-
-import (
- _ "fmt"
-)
-
-func (smith *Smith) initStatements() {
- smith.statements = []func(){
- smith.stmtOas,
- smith.stmtAs,
- smith.stmtInc,
- smith.stmtIf,
- smith.stmtFor,
- smith.stmtSend,
- smith.stmtRecv,
- smith.stmtSelect,
- smith.stmtSwitchExpr,
- smith.stmtSwitchType,
- smith.stmtTypeDecl,
- smith.stmtVarDecl,
- smith.stmtCall,
- smith.stmtReturn,
- smith.stmtBreak,
- smith.stmtContinue,
- smith.stmtGoto,
- smith.stmtSink,
- }
-}
-
-func (smith *Smith) genStatement() {
- if smith.stmtCount >= NStatements {
- return
- }
- smith.exprCount = 0
- smith.stmtCount++
- smith.statements[smith.rnd(len(smith.statements))]()
-}
-
-func (smith *Smith) stmtOas() {
- list := smith.atypeList(TraitAny)
- str, vars := smith.fmtOasVarList(list)
- smith.line("%v := %v", str, smith.fmtRvalueList(list))
- for _, v := range vars {
- smith.defineVar(v.id, v.typ)
- }
-}
-
-func (smith *Smith) stmtReturn() {
- smith.line("return %v", smith.fmtRvalueList(smith.curFunc.rets))
-}
-
-func (smith *Smith) stmtAs() {
- types := smith.atypeList(TraitAny)
- smith.line("%v = %v", smith.fmtLvalueList(types), smith.fmtRvalueList(types))
-}
-
-func (smith *Smith) stmtInc() {
- smith.line("%v %v", smith.lvalueOrMapIndex(smith.atype(ClassNumeric)), smith.choice("--", "++"))
-}
-
-func (smith *Smith) stmtIf() {
- smith.enterBlock(true)
- smith.enterBlock(true)
- if smith.rndBool() {
- smith.line("if %v {", smith.rvalue(smith.atype(ClassBoolean)))
- } else {
- smith.line("if %v; %v {", smith.stmtSimple(true, nil), smith.rvalue(smith.atype(ClassBoolean)))
- }
- smith.genBlock()
- if smith.rndBool() {
- smith.line("} else {")
- smith.genBlock()
- }
- smith.leaveBlock()
- smith.line("}")
- smith.leaveBlock()
-}
-
-func (smith *Smith) stmtFor() {
- smith.enterBlock(true)
- smith.enterBlock(true)
- smith.curBlock.isBreakable = true
- smith.curBlock.isContinuable = true
- var vars []*Var
- switch smith.choice("simple", "complex", "range") {
- case "simple":
- smith.line("for %v {", smith.rvalue(smith.atype(ClassBoolean)))
- case "complex":
- smith.line("for %v; %v; %v {", smith.stmtSimple(true, nil), smith.rvalue(smith.atype(ClassBoolean)), smith.stmtSimple(false, nil))
- case "range":
- switch smith.choice("slice", "string", "channel", "map") {
- case "slice":
- t := smith.atype(TraitAny)
- s := smith.rvalue(smith.sliceOf(t))
- switch smith.choice("one", "two", "oneDecl", "twoDecl") {
- case "one":
- smith.line("for %v = range %v {", smith.lvalueOrBlank(smith.intType), s)
- case "two":
- smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(smith.intType), smith.lvalueOrBlank(t), s)
- case "oneDecl":
- id := smith.newId("Var")
- smith.line("for %v := range %v {", id, s)
- vars = append(vars, &Var{id: id, typ: smith.intType})
- case "twoDecl":
- types := []*Type{smith.intType, t}
- str := ""
- str, vars = smith.fmtOasVarList(types)
- smith.line("for %v := range %v {", str, s)
- default:
- panic("bad")
- }
- case "string":
- s := smith.rvalue(smith.stringType)
- switch smith.choice("one", "two", "oneDecl", "twoDecl") {
- case "one":
- smith.line("for %v = range %v {", smith.lvalueOrBlank(smith.intType), s)
- case "two":
- smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(smith.intType), smith.lvalueOrBlank(smith.runeType), s)
- case "oneDecl":
- id := smith.newId("Var")
- smith.line("for %v := range %v {", id, s)
- vars = append(vars, &Var{id: id, typ: smith.intType})
- case "twoDecl":
- types := []*Type{smith.intType, smith.runeType}
- str := ""
- str, vars = smith.fmtOasVarList(types)
- smith.line("for %v := range %v {", str, s)
- default:
- panic("bad")
- }
- case "channel":
- cht := smith.atype(ClassChan)
- ch := smith.rvalue(cht)
- switch smith.choice("one", "oneDecl") {
- case "one":
- smith.line("for %v = range %v {", smith.lvalueOrBlank(cht.ktyp), ch)
- case "oneDecl":
- id := smith.newId("Var")
- smith.line("for %v := range %v {", id, ch)
- vars = append(vars, &Var{id: id, typ: cht.ktyp})
- default:
- panic("bad")
- }
- case "map":
- t := smith.atype(ClassMap)
- m := smith.rvalue(t)
- switch smith.choice("one", "two", "oneDecl", "twoDecl") {
- case "one":
- smith.line("for %v = range %v {", smith.lvalueOrBlank(t.ktyp), m)
- case "two":
- smith.line("for %v, %v = range %v {", smith.lvalueOrBlank(t.ktyp), smith.lvalueOrBlank(t.vtyp), m)
- case "oneDecl":
- id := smith.newId("Var")
- smith.line("for %v := range %v {", id, m)
- vars = append(vars, &Var{id: id, typ: t.ktyp})
- case "twoDecl":
- types := []*Type{t.ktyp, t.vtyp}
- str := ""
- str, vars = smith.fmtOasVarList(types)
- smith.line("for %v := range %v {", str, m)
- default:
- panic("bad")
- }
- default:
- panic("bad")
- }
- default:
- panic("bad")
- }
- smith.enterBlock(true)
- if len(vars) > 0 {
- smith.line("")
- for _, v := range vars {
- smith.defineVar(v.id, v.typ)
- }
- }
- smith.genBlock()
- smith.leaveBlock()
- smith.leaveBlock()
- smith.line("}")
- smith.leaveBlock()
-}
-
-func (smith *Smith) stmtSimple(oas bool, newVars *[]*Var) string {
- // We emit a fake statement in "oas", so make sure that nothing can be inserted in between.
- if smith.curBlock.extendable {
- panic("bad")
- }
- // "send" crashes gccgo with random errors too frequently.
- // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61273
- switch smith.choice("empty", "inc", "assign", "oas", "send", "expr") {
- case "empty":
- return ""
- case "inc":
- return F("%v %v", smith.lvalueOrMapIndex(smith.atype(ClassNumeric)), smith.choice("--", "++"))
- case "assign":
- list := smith.atypeList(TraitAny)
- return F("%v = %v", smith.fmtLvalueList(list), smith.fmtRvalueList(list))
- case "oas":
- if !oas {
- return ""
- }
- list := smith.atypeList(TraitAny)
- str, vars := smith.fmtOasVarList(list)
- if newVars != nil {
- *newVars = vars
- }
- res := F("%v := %v", str, smith.fmtRvalueList(list))
- smith.line("")
- for _, v := range vars {
- smith.defineVar(v.id, v.typ)
- }
- return res
- case "send":
- t := smith.atype(TraitSendable)
- return F("%v <- %v", smith.rvalue(t), smith.rvalue(t.ktyp))
- case "expr":
- return ""
- default:
- panic("bad")
- }
-}
-
-func (smith *Smith) stmtSend() {
- t := smith.atype(TraitSendable)
- smith.line("%v <- %v", smith.rvalue(t), smith.rvalue(t.ktyp))
-}
-
-func (smith *Smith) stmtRecv() {
- t := smith.atype(TraitReceivable)
- ch := smith.rvalue(t)
- switch smith.choice("normal", "decl") {
- case "normal":
- smith.line("%v, %v = <-%v", smith.lvalueOrBlank(t.ktyp), smith.lvalueOrBlank(smith.boolType), ch)
- case "decl":
- vv := smith.newId("Var")
- ok := smith.newId("Var")
- smith.line("%v, %v := <-%v", vv, ok, ch)
- smith.defineVar(vv, t.ktyp)
- smith.defineVar(ok, smith.boolType)
- default:
- panic("bad")
- }
-}
-
-func (smith *Smith) stmtTypeDecl() {
- id := smith.newId("Type")
- t := smith.atype(TraitAny)
- smith.line("type %v %v", id, t.id)
-
- newTyp := new(Type)
- *newTyp = *t
- newTyp.id = id
- newTyp.namedUserType = true
- if t.class == ClassStruct {
- newTyp.literal = func() string {
- // replace struct name with new type id
- l := t.literal()
- l = l[len(t.id)+1:]
- return "(" + id + l
- }
- newTyp.complexLiteral = func() string {
- // replace struct name with new type id
- l := t.complexLiteral()
- l = l[len(t.id)+1:]
- return "(" + id + l
- }
- } else {
- newTyp.literal = func() string {
- return F("%v(%v)", id, t.literal())
- }
- if t.complexLiteral != nil {
- newTyp.complexLiteral = func() string {
- return F("%v(%v)", id, t.complexLiteral())
- }
- }
- }
- smith.defineType(newTyp)
-}
-
-func (smith *Smith) stmtVarDecl() {
- id := smith.newId("Var")
- t := smith.atype(TraitAny)
- smith.line("var %v %v = %v", id, t.id, smith.rvalue(t))
- smith.defineVar(id, t)
-}
-
-func (smith *Smith) stmtSelect() {
- smith.enterBlock(true)
- smith.line("select {")
- for smith.rnd(5) != 0 {
- smith.enterBlock(true)
- elem := smith.atype(TraitAny)
- cht := smith.chanOf(elem)
- ch := smith.rvalue(cht)
- if smith.rndBool() {
- smith.line("case %v <- %v:", ch, smith.rvalue(elem))
- } else {
- switch smith.choice("one", "two", "oneDecl", "twoDecl") {
- case "one":
- smith.line("case %v = <-%v:", smith.lvalueOrBlank(elem), ch)
- case "two":
- smith.line("case %v, %v = <-%v:", smith.lvalueOrBlank(elem), smith.lvalueOrBlank(smith.boolType), ch)
- case "oneDecl":
- vv := smith.newId("Var")
- smith.line("case %v := <-%v:", vv, ch)
- smith.defineVar(vv, elem)
- case "twoDecl":
- vv := smith.newId("Var")
- ok := smith.newId("Var")
- smith.line("case %v, %v := <-%v:", vv, ok, ch)
- smith.defineVar(vv, elem)
- smith.defineVar(ok, smith.boolType)
- default:
- panic("bad")
- }
- }
- smith.genBlock()
- smith.leaveBlock()
- }
- if smith.rndBool() {
- smith.enterBlock(true)
- smith.line("default:")
- smith.genBlock()
- smith.leaveBlock()
- }
- smith.line("}")
- smith.leaveBlock()
-}
-
-func (smith *Smith) stmtSwitchExpr() {
- var t *Type
- cond := ""
- if smith.rndBool() {
- t = smith.atype(TraitComparable)
- cond = smith.rvalue(t)
- } else {
- t = smith.boolType
- }
- smith.enterBlock(true)
- smith.enterBlock(true)
- smith.curBlock.isBreakable = true
- var vars []*Var
- if smith.rndBool() {
- smith.line("switch %v {", cond)
- } else {
- smith.line("switch %v; %v {", smith.stmtSimple(true, &vars), cond)
- }
- // TODO: we generate at most one case, because if we generate more,
- // we can generate two cases with equal constants.
- fallth := false
- if smith.rndBool() {
- smith.enterBlock(true)
- smith.line("case %v:", smith.rvalue(t))
- smith.genBlock()
- smith.leaveBlock()
- if smith.rndBool() {
- fallth = true
- smith.line("fallthrough")
- }
- }
- if fallth || len(vars) > 0 || smith.rndBool() {
- smith.enterBlock(true)
- smith.line("default:")
- smith.genBlock()
- for _, v := range vars {
- smith.line("_ = %v", v.id)
- v.used = true
- }
- smith.leaveBlock()
- }
- smith.leaveBlock()
- smith.line("}")
- smith.leaveBlock()
-}
-
-func (smith *Smith) stmtSwitchType() {
- cond := smith.lvalue(smith.atype(TraitAny))
- smith.enterBlock(true)
- smith.curBlock.isBreakable = true
- smith.line("switch COND := (interface{})(%v); COND.(type) {", cond)
- if smith.rndBool() {
- smith.enterBlock(true)
- smith.line("case %v:", smith.atype(TraitAny).id)
- smith.genBlock()
- smith.leaveBlock()
- }
- if smith.rndBool() {
- smith.enterBlock(true)
- smith.line("default:")
- smith.genBlock()
- smith.leaveBlock()
- }
- smith.line("}")
- smith.leaveBlock()
-}
-
-func (smith *Smith) stmtCall() {
- if smith.rndBool() {
- smith.stmtCallBuiltin()
- }
- t := smith.atype(ClassFunction)
- prefix := smith.choice("", "go", "defer")
- smith.line("%v %v(%v)", prefix, smith.rvalue(t), smith.fmtRvalueList(t.styp))
-}
-
-func (smith *Smith) stmtCallBuiltin() {
- prefix := smith.choice("", "go", "defer")
- switch fn := smith.choice("close", "copy", "delete", "panic", "print", "println", "recover"); fn {
- case "close":
- smith.line("%v %v(%v)", prefix, fn, smith.rvalue(smith.atype(ClassChan)))
- case "copy":
- smith.line("%v %v", prefix, smith.exprCopySlice())
- case "delete":
- t := smith.atype(ClassMap)
- smith.line("%v %v(%v, %v)", prefix, fn, smith.rvalue(t), smith.rvalue(t.ktyp))
- case "panic":
- smith.line("%v %v(%v)", prefix, fn, smith.rvalue(smith.atype(TraitAny)))
- case "print":
- fallthrough
- case "println":
- list := smith.atypeList(TraitPrintable)
- smith.line("%v %v(%v)", prefix, fn, smith.fmtRvalueList(list))
- case "recover":
- smith.line("%v %v()", prefix, fn)
- default:
- panic("bad")
- }
-}
-
-func (smith *Smith) stmtBreak() {
- if !smith.curBlock.isBreakable {
- return
- }
- smith.line("break")
-}
-
-func (smith *Smith) stmtContinue() {
- if !smith.curBlock.isContinuable {
- return
- }
- smith.line("continue")
-}
-
-func (smith *Smith) stmtGoto() {
- // TODO: suppport goto down
- id := smith.materializeGotoLabel()
- smith.line("goto %v", id)
-}
-
-func (smith *Smith) stmtSink() {
- // Makes var escape.
- smith.line("SINK = %v", smith.exprVar(smith.atype(TraitAny)))
-}
projects / dotfiles / .git / blobdiff