提交: 6c1e69841e14f57b0fdebc368ea727263d822e88 - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• 修订版: 6c1e69841e14f57b0fdebc368ea727263d822e88 (tree)
• 时间: 2016-12-16 00:10:07
• 作者: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

見直しやミスの修正などをした

更改概述

• modified: src/bytecode.go
• modified: src/char.go
• modified: src/compiler.go
• modified: src/system.go

差异

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -458,9 +458,6 @@ func (be BytecodeExp) toI() int32 {
 	return *(*int32)(unsafe.Pointer(&be[0]))
 }
 func (be *BytecodeExp) appendValue(bv BytecodeValue) (ok bool) {
-	if bv.IsSF() {
-		return false
-	}
 	switch bv.t {
 	case VT_Float:
 		be.append(OC_float)
@@ -492,16 +489,14 @@ func (_ BytecodeExp) blnot(v *BytecodeValue) {
 	v.t = VT_Int
 }
 func (_ BytecodeExp) pow(v1 *BytecodeValue, v2 BytecodeValue, pn int) {
-	t := ValueType(Min(int32(v1.t), int32(v2.t)))
-	if t == VT_Float {
+	if ValueType(Min(int32(v1.t), int32(v2.t))) == VT_Float {
 		v1.SetF(float32(math.Pow(float64(v1.ToF()), float64(v2.ToF()))))
 	} else if v2.ToF() < 0 {
 		if sys.cgi[pn].ver[0] == 1 {
 			v1.SetF(float32(math.Pow(float64(v1.ToI()), float64(v2.ToI()))))
 		} else {
 			f := float32(math.Pow(float64(v1.ToI()), float64(v2.ToI())))
-			i := *(*int32)(unsafe.Pointer(&f))
-			v1.SetI(i << 29)
+			v1.SetI(*(*int32)(unsafe.Pointer(&f)) << 29)
 		}
 	} else {
 		i1, i2, hb := v1.ToI(), v2.ToI(), int32(-1)
@@ -524,7 +519,30 @@ func (_ BytecodeExp) pow(v1 *BytecodeValue, v2 BytecodeValue, pn int) {
 		v1.SetI(i)
 	}
 }
-func (be BytecodeExp) run(c *Char) BytecodeValue {
+func (_ BytecodeExp) mul(v1 *BytecodeValue, v2 BytecodeValue) {
+	if ValueType(Min(int32(v1.t), int32(v2.t))) == VT_Float {
+		v1.SetF(v1.ToF() * v2.ToF())
+	} else {
+		v1.SetI(v1.ToI() * v2.ToI())
+	}
+}
+func (_ BytecodeExp) div(v1 *BytecodeValue, v2 BytecodeValue) {
+	if ValueType(Min(int32(v1.t), int32(v2.t))) == VT_Float {
+		v1.SetF(v1.ToF() / v2.ToF())
+	} else if v2.ToI() == 0 {
+		*v1 = BytecodeSF()
+	} else {
+		v1.SetI(v1.ToI() / v2.ToI())
+	}
+}
+func (_ BytecodeExp) mod(v1 *BytecodeValue, v2 BytecodeValue) {
+	if v2.ToI() == 0 {
+		*v1 = BytecodeSF()
+	} else {
+		v1.SetI(v1.ToI() % v2.ToI())
+	}
+}
+func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 	sys.bcStack.Clear()
 	for i := 1; i <= len(be); i++ {
 		switch be[i-1] {
@@ -541,17 +559,34 @@ func (be BytecodeExp) run(c *Char) BytecodeValue {
 			be.blnot(sys.bcStack.Top())
 		case OC_pow:
 			v2 := sys.bcStack.Pop()
-			be.pow(sys.bcStack.Top(), v2, c.playerno)
+			be.pow(sys.bcStack.Top(), v2, scpn)
+		case OC_mul:
+			v2 := sys.bcStack.Pop()
+			be.mul(sys.bcStack.Top(), v2)
+		case OC_div:
+			v2 := sys.bcStack.Pop()
+			be.div(sys.bcStack.Top(), v2)
+		case OC_mod:
+			v2 := sys.bcStack.Pop()
+			be.mod(sys.bcStack.Top(), v2)
 		default:
 			unimplemented()
 		}
 	}
 	return sys.bcStack.Pop()
 }
-func (be BytecodeExp) eval(c *Char) float64 { return be.run(c).v }
+func (be BytecodeExp) evalF(c *Char, scpn int) float32 {
+	return be.run(c, scpn).ToF()
+}
+func (be BytecodeExp) evalI(c *Char, scpn int) int32 {
+	return be.run(c, scpn).ToI()
+}
+func (be BytecodeExp) evalB(c *Char, scpn int) bool {
+	return be.run(c, scpn).ToB()
+}
 
 type StateController interface {
-	Run(c *Char) (changeState bool)
+	Run(c *Char, scpn int) (changeState bool)
 }
 
 const (
@@ -559,8 +594,14 @@ const (
 	SCID_const   byte = 128
 )
 
-type StateControllerBase []byte
+type StateControllerBase struct {
+	playerNo int
+	code     []byte
+}
 
+func newStateControllerBase(pn int) *StateControllerBase {
+	return &StateControllerBase{playerNo: pn}
+}
 func (scb StateControllerBase) beToExp(be ...BytecodeExp) []BytecodeExp {
 	return be
 }
@@ -581,24 +622,24 @@ func (scb StateControllerBase) iToExp(i ...int32) (exp []BytecodeExp) {
 	return
 }
 func (scb *StateControllerBase) add(id byte, exp []BytecodeExp) {
-	*scb = append(*scb, id, byte(len(exp)))
+	scb.code = append(scb.code, id, byte(len(exp)))
 	for _, e := range exp {
 		l := int32(len(e))
-		*scb = append(*scb, (*(*[4]byte)(unsafe.Pointer(&l)))[:]...)
-		*scb = append(*scb, (*(*[]byte)(unsafe.Pointer(&e)))...)
+		scb.code = append(scb.code, (*(*[4]byte)(unsafe.Pointer(&l)))[:]...)
+		scb.code = append(scb.code, (*(*[]byte)(unsafe.Pointer(&e)))...)
 	}
 }
 func (scb StateControllerBase) run(f func(byte, []BytecodeExp) bool) bool {
-	for i := 0; i < len(scb); {
-		id := scb[i]
+	for i := 0; i < len(scb.code); {
+		id := scb.code[i]
 		i++
-		n := scb[i]
+		n := scb.code[i]
 		i++
 		exp := make([]BytecodeExp, n)
-		for m := byte(0); m < n; m++ {
-			l := *(*int32)(unsafe.Pointer(&scb[i]))
+		for m := 0; m < int(n); m++ {
+			l := *(*int32)(unsafe.Pointer(&scb.code[i]))
 			i += 4
-			exp[m] = (*(*BytecodeExp)(unsafe.Pointer(&scb)))[i : i+int(l)]
+			exp[m] = (*(*BytecodeExp)(unsafe.Pointer(&scb.code)))[i : i+int(l)]
 			i += int(l)
 		}
 		if !f(id, exp) {
@@ -633,39 +674,39 @@ const (
 	stateDef_poweradd_c        = stateDef_poweradd + SCID_const
 )
 
-func (sd stateDef) Run(c *Char) bool {
+func (sd stateDef) Run(c *Char, scpn int) bool {
 	StateControllerBase(sd).run(func(id byte, exp []BytecodeExp) bool {
 		switch id {
 		case stateDef_hitcountpersist, stateDef_hitcountpersist_c:
-			if id == stateDef_hitcountpersist_c || exp[0].eval(c) == 0 {
+			if id == stateDef_hitcountpersist_c || !exp[0].evalB(c, scpn) {
 				c.clearHitCount()
 			}
 		case stateDef_movehitpersist, stateDef_movehitpersist_c:
-			if id == stateDef_movehitpersist_c || exp[0].eval(c) == 0 {
+			if id == stateDef_movehitpersist_c || !exp[0].evalB(c, scpn) {
 				c.clearMoveHit()
 			}
 		case stateDef_hitdefpersist, stateDef_hitdefpersist_c:
-			if id == stateDef_hitdefpersist_c || exp[0].eval(c) == 0 {
+			if id == stateDef_hitdefpersist_c || !exp[0].evalB(c, scpn) {
 				c.clearHitDef()
 			}
 		case stateDef_sprpriority:
-			c.setSprPriority(int32(exp[0].eval(c)))
+			c.setSprPriority(exp[0].evalI(c, scpn))
 		case stateDef_sprpriority_c:
 			c.setSprPriority(exp[0].toI())
 		case stateDef_facep2, stateDef_facep2_c:
-			if id == stateDef_facep2_c || exp[0].eval(c) != 0 {
+			if id == stateDef_facep2_c || exp[0].evalB(c, scpn) {
 				c.faceP2()
 			}
 		case stateDef_juggle:
-			c.setJuggle(int32(exp[0].eval(c)))
+			c.setJuggle(exp[0].evalI(c, scpn))
 		case stateDef_juggle_c:
 			c.setJuggle(exp[0].toI())
 		case stateDef_velset:
-			c.setXV(float32(exp[0].eval(c)))
+			c.setXV(exp[0].evalF(c, scpn))
 			if len(exp) > 1 {
-				c.setYV(float32(exp[1].eval(c)))
+				c.setYV(exp[1].evalF(c, scpn))
 				if len(exp) > 2 {
-					exp[2].run(c)
+					exp[2].run(c, scpn)
 				}
 			}
 		case stateDef_velset_c:
@@ -674,15 +715,15 @@ func (sd stateDef) Run(c *Char) bool {
 				c.setYV(exp[1].toF())
 			}
 		case stateDef_anim:
-			c.changeAnim(int32(exp[0].eval(c)))
+			c.changeAnim(exp[0].evalI(c, scpn))
 		case stateDef_anim_c:
 			c.changeAnim(exp[0].toI())
 		case stateDef_ctrl:
-			c.setCtrl(exp[0].eval(c) != 0)
+			c.setCtrl(exp[0].evalB(c, scpn))
 		case stateDef_ctrl_c:
 			c.setCtrl(exp[0].toI() != 0)
 		case stateDef_poweradd:
-			c.addPower(int32(exp[0].eval(c)))
+			c.addPower(exp[0].evalI(c, scpn))
 		case stateDef_poweradd_c:
 			c.addPower(exp[0].toI())
 		}

--- a/src/char.go
+++ b/src/char.go
@@ -272,8 +272,8 @@ type Char struct {
 	name        string
 	cmd         []CommandList
 	key         int
-	helperindex int
-	playerno    int
+	helperIndex int
+	playerNo    int
 	keyctrl     bool
 	player      bool
 	sprpriority int32
@@ -287,8 +287,8 @@ func newChar(n, idx int) (c *Char) {
 	return c
 }
 func (c *Char) init(n, idx int) {
-	c.playerno, c.helperindex = n, idx
-	if c.helperindex == 0 {
+	c.playerNo, c.helperIndex = n, idx
+	if c.helperIndex == 0 {
 		c.keyctrl, c.player = true, true
 	}
 	c.key = n
@@ -297,7 +297,7 @@ func (c *Char) init(n, idx int) {
 	}
 }
 func (c *Char) load(def string) error {
-	gi := &sys.cgi[c.playerno]
+	gi := &sys.cgi[c.playerNo]
 	gi.displayname, gi.author, gi.sff, gi.snd = "", "", nil, nil
 	gi.anim = NewAnimationTable()
 	for i := range gi.palkeymap {

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -12,12 +12,11 @@ const kuuhaktokigou = " !=<>()|&+-*/%,[]^|:\"\t\r\n"
 type ExpFunc func(out *BytecodeExp, in *string) (BytecodeValue, error)
 type Compiler struct {
 	cmdl     *CommandList
-	valCnt   int
 	maeOp    string
 	usiroOp  bool
 	norange  bool
 	token    string
-	playerno int
+	playerNo int
 }
 
 func newCompiler() *Compiler {
@@ -181,13 +180,13 @@ func (_ *Compiler) isOperator(token string) int {
 	}
 	return 0
 }
-func (c *Compiler) operator(in *string) (string, error) {
+func (c *Compiler) operator(in *string) error {
 	if len(c.maeOp) > 0 {
 		if opp := c.isOperator(c.token); opp <= c.isOperator(c.maeOp) {
 			if opp < 0 || ((!c.usiroOp || c.token[0] != '(') &&
 				(c.token[0] < 'A' || c.token[0] > 'Z') &&
 				(c.token[0] < 'a' || c.token[0] > 'z')) {
-				return "", Error(c.maeOp + "が不正です")
+				return Error(c.maeOp + "が不正です")
 			}
 			*in = c.token + " " + *in
 			c.token = c.maeOp
@@ -195,7 +194,7 @@ func (c *Compiler) operator(in *string) (string, error) {
 			c.norange = true
 		}
 	}
-	return c.token, nil
+	return nil
 }
 func (c *Compiler) number(token string) BytecodeValue {
 	f, err := strconv.ParseFloat(token, 64)
@@ -223,7 +222,6 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	c.usiroOp, c.norange = true, false
 	bv := c.number(c.token)
 	if !bv.IsSF() {
-		c.valCnt++
 		c.token = c.tokenizer(in)
 		return bv, nil
 	}
@@ -231,11 +229,10 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 		defer func() { c.usiroOp = false }()
 	}
 	unimplemented()
-	c.valCnt++
 	c.token = c.tokenizer(in)
 	return bv, nil
 }
-func (c *Compiler) renzikuEnzansihaError(in *string) error {
+func (c *Compiler) renzokuEnzansihaError(in *string) error {
 	*in = strings.TrimSpace(*in)
 	if len(*in) > 0 {
 		switch (*in)[0] {
@@ -265,14 +262,13 @@ func (c *Compiler) expPostNot(out *BytecodeExp, in *string) (BytecodeValue,
 		}
 		c.token = c.tokenizer(in)
 	}
-
 	if len(c.maeOp) == 0 {
 		opp := c.isOperator(c.token)
 		if opp == 0 {
 			if !c.usiroOp && c.token == "(" {
 				return BytecodeSF(), Error("演算子がありません")
 			}
-			oldin := *in
+			oldtoken, oldin := c.token, *in
 			var dummyout BytecodeExp
 			if _, err := c.expValue(&dummyout, in); err != nil {
 				return BytecodeSF(), err
@@ -280,13 +276,14 @@ func (c *Compiler) expPostNot(out *BytecodeExp, in *string) (BytecodeValue,
 			if c.isOperator(c.token) <= 0 {
 				return BytecodeSF(), Error("演算子がありません")
 			}
-			if err := c.renzikuEnzansihaError(in); err != nil {
+			if err := c.renzokuEnzansihaError(in); err != nil {
 				return BytecodeSF(), err
 			}
 			oldin = oldin[:len(oldin)-len(*in)]
-			*in = "(" + oldin[:strings.LastIndex(oldin, c.token)] + *in
+			*in = oldtoken + " " + oldin[:strings.LastIndex(oldin, c.token)] + " " +
+				*in
 		} else if opp > 0 {
-			if err := c.renzikuEnzansihaError(in); err != nil {
+			if err := c.renzokuEnzansihaError(in); err != nil {
 				return BytecodeSF(), err
 			}
 		}
@@ -300,31 +297,27 @@ func (c *Compiler) expPow(out *BytecodeExp, in *string) (BytecodeValue,
 		return BytecodeSF(), err
 	}
 	for {
-		op, err := c.operator(in)
-		if err != nil {
+		if err := c.operator(in); err != nil {
 			return BytecodeSF(), err
 		}
-		if op == "**" {
+		if c.token == "**" {
 			var be BytecodeExp
 			bv2, err := c.expPostNot(&be, in)
 			if err != nil {
 				return BytecodeSF(), err
 			}
-			if !bv.IsSF() && !bv.IsSF() {
-				out.pow(&bv, bv, c.playerno)
+			if !bv.IsSF() && !bv2.IsSF() {
+				out.pow(&bv, bv2, c.playerNo)
 			} else {
-				if !bv.IsSF() {
-					out.appendValue(bv)
-				}
+				out.appendValue(bv)
 				out.append(be...)
-				if !bv.IsSF() {
-					out.appendValue(bv2)
-				}
+				out.appendValue(bv2)
 				out.append(OC_pow)
 				bv = BytecodeSF()
 			}
+		} else {
+			break
 		}
-		unimplemented()
 	}
 	return bv, nil
 }
@@ -334,8 +327,44 @@ func (c *Compiler) expMldv(out *BytecodeExp, in *string) (BytecodeValue,
 	if err != nil {
 		return BytecodeSF(), err
 	}
-	unimplemented()
-	return bv, nil
+	for {
+		if err := c.operator(in); err != nil {
+			return BytecodeSF(), err
+		}
+		switch c.token {
+		case "*", "/", "%":
+		default:
+			return bv, nil
+		}
+		var be BytecodeExp
+		bv2, err := c.expPow(&be, in)
+		if err != nil {
+			return BytecodeSF(), err
+		}
+		if !bv.IsSF() && !bv2.IsSF() {
+			switch c.token {
+			case "*":
+				out.mul(&bv, bv2)
+			case "/":
+				out.div(&bv, bv2)
+			case "%":
+				out.mod(&bv, bv2)
+			}
+		} else {
+			out.appendValue(bv)
+			out.append(be...)
+			out.appendValue(bv2)
+			switch c.token {
+			case "*":
+				out.append(OC_mul)
+			case "/":
+				out.append(OC_div)
+			case "%":
+				out.append(OC_mod)
+			}
+			bv = BytecodeSF()
+		}
+	}
 }
 func (c *Compiler) expAdsb(out *BytecodeExp, in *string) (BytecodeValue,
 	error) {
@@ -410,9 +439,7 @@ func (c *Compiler) expBoolXor(out *BytecodeExp, in *string) (BytecodeValue,
 }
 func (c *Compiler) expBoolOr(out *BytecodeExp, in *string) (BytecodeValue,
 	error) {
-	defer func(ovc int, omp string) {
-		c.valCnt, c.maeOp = ovc, omp
-	}(c.valCnt, c.maeOp)
+	defer func(omp string) { c.maeOp = omp }(c.maeOp)
 	bv, err := c.expBoolXor(out, in)
 	if err != nil {
 		return BytecodeSF(), err
@@ -430,11 +457,7 @@ func (c *Compiler) typedExp(ef ExpFunc, in *string,
 	}
 	if !bv.IsSF() {
 		if vt == VT_Bool {
-			if bv.v != 0 {
-				bv.v = 1
-			} else {
-				bv.v = 0
-			}
+			bv.SetB(bv.ToB())
 		}
 		return nil, bv, nil
 	}
@@ -569,9 +592,11 @@ func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
 		}
 	}
 	cns := true
-	for _, v := range vs {
+	for i, v := range vs {
 		if v.IsSF() {
 			cns = false
+		} else {
+			bes[i].appendValue(v)
 		}
 	}
 	if cns {
@@ -595,7 +620,7 @@ func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
 }
 func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 	return c.stateSec(is, func() error {
-		var sc StateControllerBase
+		sc := newStateControllerBase(c.playerNo)
 		if err := c.stateParam(is, "type", func(data string) error {
 			if len(data) == 0 {
 				return Error("値が指定されていません")
@@ -669,7 +694,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			}
 			if v.IsSF() {
 				sc.add(stateDef_hitcountpersist, sc.beToExp(be))
-			} else if v.v == 0 { // falseのときだけクリアする
+			} else if !v.ToB() { // falseのときだけクリアする
 				sc.add(stateDef_hitcountpersist_c, nil)
 			}
 			return nil
@@ -688,7 +713,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			}
 			if v.IsSF() {
 				sc.add(stateDef_movehitpersist, sc.beToExp(be))
-			} else if v.v == 0 { // falseのときだけクリアする
+			} else if !v.ToB() { // falseのときだけクリアする
 				sc.add(stateDef_movehitpersist_c, nil)
 			}
 			return nil
@@ -707,7 +732,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			}
 			if v.IsSF() {
 				sc.add(stateDef_hitdefpersist, sc.beToExp(be))
-			} else if v.v == 0 { // falseのときだけクリアする
+			} else if !v.ToB() { // falseのときだけクリアする
 				sc.add(stateDef_hitdefpersist_c, nil)
 			}
 			return nil
@@ -718,7 +743,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			sc.add(stateDef_hitdefpersist_c, nil)
 		}
 		if err := c.stateParam(is, "sprpriority", func(data string) error {
-			return c.scAdd(&sc, stateDef_sprpriority, data, VT_Int, 1)
+			return c.scAdd(sc, stateDef_sprpriority, data, VT_Int, 1)
 		}); err != nil {
 			return err
 		}
@@ -729,7 +754,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			}
 			if v.IsSF() {
 				sc.add(stateDef_facep2, sc.beToExp(be))
-			} else if v.v != 0 {
+			} else if v.ToB() {
 				sc.add(stateDef_facep2_c, nil)
 			}
 			return nil
@@ -739,7 +764,7 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 		b = false
 		if err := c.stateParam(is, "juggle", func(data string) error {
 			b = true
-			return c.scAdd(&sc, stateDef_juggle, data, VT_Int, 1)
+			return c.scAdd(sc, stateDef_juggle, data, VT_Int, 1)
 		}); err != nil {
 			return err
 		}
@@ -747,26 +772,26 @@ func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 			sc.add(stateDef_juggle_c, sc.iToExp(0))
 		}
 		if err := c.stateParam(is, "velset", func(data string) error {
-			return c.scAdd(&sc, stateDef_velset, data, VT_Float, 3)
+			return c.scAdd(sc, stateDef_velset, data, VT_Float, 3)
 		}); err != nil {
 			return err
 		}
 		if err := c.stateParam(is, "anim", func(data string) error {
-			return c.scAdd(&sc, stateDef_anim, data, VT_Int, 1)
+			return c.scAdd(sc, stateDef_anim, data, VT_Int, 1)
 		}); err != nil {
 			return err
 		}
 		if err := c.stateParam(is, "ctrl", func(data string) error {
-			return c.scAdd(&sc, stateDef_ctrl, data, VT_Bool, 1)
+			return c.scAdd(sc, stateDef_ctrl, data, VT_Bool, 1)
 		}); err != nil {
 			return err
 		}
 		if err := c.stateParam(is, "poweradd", func(data string) error {
-			return c.scAdd(&sc, stateDef_poweradd, data, VT_Int, 1)
+			return c.scAdd(sc, stateDef_poweradd, data, VT_Int, 1)
 		}); err != nil {
 			return err
 		}
-		sbc.stateDef = stateDef(sc)
+		sbc.stateDef = stateDef(*sc)
 		return nil
 	})
 }
@@ -813,7 +838,7 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 	return nil
 }
 func (c *Compiler) Compile(n int, def string) (*Bytecode, error) {
-	c.playerno = n
+	c.playerNo = n
 	bc := newBytecode()
 	str, err := LoadText(def)
 	if err != nil {

--- a/src/system.go
+++ b/src/system.go
@@ -437,7 +437,7 @@ func (l *Loader) loadChar(pn int) int {
 		sys.cgi[pn].palno = pal
 	}
 	if sys.cgi[pn].sff == nil {
-		if l.code[pn], l.err = newCompiler().Compile(p.playerno, cdef); l.err != nil {
+		if l.code[pn], l.err = newCompiler().Compile(p.playerNo, cdef); l.err != nil {
 			sys.chars[pn] = nil
 			return -1
 		}