Golang parse.Indexing類代碼示例

func (cp *compiler) indexingVar(n *parse.Indexing, msg string) variableOp {
	// XXX will we be using indexingVar for purposes other than setting?
	varname := cp.literal(n.Head, msg)
	p := n.Begin()

	if len(n.Indicies) == 0 {
		cp.registerVariableSet(varname)

		return func(ec *evalCtx) Variable {
			ns, barename := splitQualifiedName(varname)
			variable := ec.ResolveVar(ns, barename)
			if variable == nil {
				// New variable.
				// XXX We depend on the fact that this variable will
				// immeidately be set.
				variable = newPtrVariable(nil)
				ec.local[barename] = variable
			}
			return variable
		}
	} else {
		cp.registerVariableGet(varname)
		indexOps := cp.arrays(n.Indicies)
		indexBegins := make([]int, len(n.Indicies))
		indexEnds := make([]int, len(n.Indicies))
		for i, in := range n.Indicies {
			indexBegins[i] = in.Begin()
			indexEnds[i] = in.End()
		}

		return func(ec *evalCtx) Variable {
			variable := ec.ResolveVar(splitQualifiedName(varname))
			if variable == nil {
				ec.errorf(p, "variable $%s does not exisit, compiler bug", varname)
			}
			for i, op := range indexOps {
				indexer, ok := variable.Get().(IndexVarer)
				if !ok {
					ec.errorf( /* from p to */ indexBegins[i], "cannot be indexing for setting (type %T)", variable.Get())
				}
				values := op(ec)
				if len(values) != 1 {
					ec.errorf(indexBegins[i], "index must eval to a single Value (got %v)", values)
				}

				variable = indexer.IndexVar(values[0])
			}
			return variable
		}
	}
}

func (cp *compiler) indexing(n *parse.Indexing) valuesOp {
	if len(n.Indicies) == 0 {
		return cp.primary(n.Head)
	}

	headOp := cp.primary(n.Head)
	indexOps := cp.arrays(n.Indicies)
	p := n.Begin()
	indexPoses := make([]int, len(n.Indicies))
	for i, index := range n.Indicies {
		indexPoses[i] = index.Begin()
	}

	return func(ec *evalCtx) []Value {
		v := ec.must(headOp(ec), "the indexing value", p).mustOne()
		for i, indexOp := range indexOps {
			index := ec.must(indexOp(ec), "the index", p).mustOne()
			v = evalIndex(ec, v, index, p, indexPoses[i])
		}
		return []Value{v}
	}
}

func (cp *compiler) lvaluesOne(n *parse.Indexing, msg string) (bool, LValuesOpFunc) {
	varname := cp.literal(n.Head, msg)
	cp.registerVariableSet(varname)
	explode, ns, barename := ParseAndFixVariable(varname)

	if len(n.Indicies) == 0 {
		return explode, func(ec *EvalCtx) []Variable {
			variable := ec.ResolveVar(ns, barename)
			if variable == nil {
				if ns == "" || ns == "local" {
					// New variable.
					// XXX We depend on the fact that this variable will
					// immeidately be set.
					variable = NewPtrVariable(nil)
					ec.local[barename] = variable
				} else if mod, ok := ec.Modules[ns]; ok {
					variable = NewPtrVariable(nil)
					mod[barename] = variable
				} else {
					throwf("cannot set $%s", varname)
				}
			}
			return []Variable{variable}
		}
	}

	p := n.Begin()
	indexOps := cp.arrayOps(n.Indicies)

	return explode, func(ec *EvalCtx) []Variable {
		variable := ec.ResolveVar(ns, barename)
		if variable == nil {
			throwf("variable $%s does not exisit, compiler bug", varname)
		}

		// Indexing. Do Index up to the last but one index.
		value := variable.Get()
		n := len(indexOps)
		// TODO set location information according.
		for _, op := range indexOps[:n-1] {
			indexer := mustIndexer(value, ec)

			indicies := op.Exec(ec)
			values := indexer.Index(indicies)
			if len(values) != 1 {
				throw(errors.New("multi indexing not implemented"))
			}
			value = values[0]
		}
		// Now this must be an IndexSetter.
		indexSetter, ok := value.(IndexSetter)
		if !ok {
			// XXX the indicated end location will fall on or after the opening
			// bracket of the last index, instead of exactly on the penultimate
			// index.
			ec.errorpf(p, indexOps[n-1].Begin, "cannot be indexed for setting (value is %s, type %s)", value.Repr(NoPretty), value.Kind())
		}
		// XXX Duplicate code.
		indicies := indexOps[n-1].Exec(ec)
		if len(indicies) != 1 {
			ec.errorpf(indexOps[n-1].Begin, indexOps[n-1].End, "index must eval to a single Value (got %v)", indicies)
		}
		return []Variable{elemVariable{indexSetter, indicies[0]}}
	}
}

// lvaluesOp compiles lvalues, returning the fixed part and, optionally a rest
// part.
//
// In the AST an lvalue is either an Indexing node where the head is a string
// literal, or a braced list of such Indexing nodes. The last Indexing node may
// be prefixed by @, in which case they become the rest part. For instance, in
// {a[x],b,@c[z]}, "a[x],b" is the fixed part and "c[z]" is the rest part.
func (cp *compiler) lvaluesOp(n *parse.Indexing) (LValuesOp, LValuesOp) {
	if n.Head.Type == parse.Braced {
		// Braced list of variable specs, possibly with indicies. The braced list
		if len(n.Indicies) > 0 {
			cp.errorf("may not have indicies")
		}

		opFuncs := make([]LValuesOpFunc, len(n.Head.Braced))
		var restNode *parse.Indexing
		var restOpFunc LValuesOpFunc

		// Compile each spec inside the brace.
		lvalueNodes := n.Head.Braced
		fixedEnd := 0
		for i, cn := range lvalueNodes {
			if len(cn.Indexings) != 1 {
				cp.errorpf(cn.Begin(), cn.End(), "must be an lvalue")
			}
			var rest bool
			rest, opFuncs[i] = cp.lvaluesOne(cn.Indexings[0], "must be an lvalue ")
			// Only the last one may a rest part.
			if rest {
				if i == len(n.Head.Braced)-1 {
					restNode = cn.Indexings[0]
					restOpFunc = opFuncs[i]
				} else {
					cp.errorpf(cn.Begin(), cn.End(), "only the last lvalue may have @")
				}
			} else {
				fixedEnd = cn.End()
			}
		}

		var restOp LValuesOp
		// If there is a rest part, make LValuesOp for it and remove it from opFuncs.
		if restOpFunc != nil {
			restOp = LValuesOp{restOpFunc, restNode.Begin(), restNode.End()}
			opFuncs = opFuncs[:len(opFuncs)-1]
		}

		var op LValuesOp
		// If there is still anything left in opFuncs, make LValuesOp for the fixed part.
		if len(opFuncs) > 0 {
			op = LValuesOp{func(ec *EvalCtx) []Variable {
				var variables []Variable
				for _, opFunc := range opFuncs {
					variables = append(variables, opFunc(ec)...)
				}
				return variables
			}, lvalueNodes[0].Begin(), fixedEnd}
		}

		return op, restOp
	}
	rest, opFunc := cp.lvaluesOne(n, "must be an lvalue or a braced list of those")
	op := LValuesOp{opFunc, n.Begin(), n.End()}
	if rest {
		return LValuesOp{}, op
	} else {
		return op, LValuesOp{}
	}
}

func (cp *compiler) indexingOp(n *parse.Indexing) ValuesOp {
	return ValuesOp{cp.indexing(n), n.Begin(), n.End()}
}

func (cp *compiler) singleVariable(n *parse.Indexing, msg string) VariableOp {
	// XXX will we be using this for purposes other than setting?
	varname := cp.literal(n.Head, msg)
	p := n.Begin()

	if len(n.Indicies) == 0 {
		cp.registerVariableSet(varname)

		return func(ec *EvalCtx) Variable {
			splice, ns, barename := parseVariable(varname)
			if splice {
				// XXX
				ec.errorf(p, "not yet supported")
			}
			variable := ec.ResolveVar(ns, barename)
			if variable == nil {
				// New variable.
				// XXX We depend on the fact that this variable will
				// immeidately be set.
				variable = NewPtrVariable(nil)
				ec.local[barename] = variable
			}
			return variable
		}
	}
	cp.registerVariableGet(varname)
	indexOps := cp.arrays(n.Indicies)
	indexBegins := make([]int, len(n.Indicies))
	indexEnds := make([]int, len(n.Indicies))
	for i, in := range n.Indicies {
		indexBegins[i] = in.Begin()
		indexEnds[i] = in.End()
	}

	return func(ec *EvalCtx) Variable {
		splice, ns, name := parseVariable(varname)
		if splice {
			// XXX
			ec.errorf(p, "not yet supported")
		}
		variable := ec.ResolveVar(ns, name)
		if variable == nil {
			ec.errorf(p, "variable $%s does not exisit, compiler bug", varname)
		}
		if len(indexOps) == 0 {
			// Just a variable, return directly.
			return variable
		}

		// Indexing. Do Index up to the last but one index.
		value := variable.Get()
		n := len(indexOps)
		for i, op := range indexOps[:n-1] {
			indexer, ok := value.(Indexer)
			if !ok {
				ec.errorf( /* from p to */ indexBegins[i], "cannot be indexed (value is %s, type %s)", value.Repr(), value.Kind())
			}

			indicies := op(ec)
			if len(indicies) != 1 {
				ec.errorf(indexBegins[i], "index must eval to a single Value (got %v)", indicies)
			}

			value = indexer.Index(indicies[0])
		}
		// Now this must be an IndexSetter.
		indexSetter, ok := value.(IndexSetter)
		if !ok {
			ec.errorf( /* from p to */ indexBegins[n-1], "cannot be indexed for setting (value is %s, type %s)", value.Repr(), value.Kind())
		}
		// XXX Duplicate code.
		indicies := indexOps[n-1](ec)
		if len(indicies) != 1 {
			ec.errorf(indexBegins[n-1], "index must eval to a single Value (got %v)", indicies)
		}
		return elemVariable{indexSetter, indicies[0]}
	}
}