示例#1
0
func (s SubVariable) Sub(scp *variables.Scope) (returnString string) {
	logex.Debug("Substituting variable")
	defer func() {
		logex.Debugf("Returned '%s'", returnString)
	}()
	v := scp.Get(s.VarName)

	switch s.SubType {
	case VarSubNormal:
		return v.Val
	case VarSubLength:
		// For the values ${#*} and ${#@}
		// the number of positional parameters is returned
		// We need to perform IFS splitting to figure this out
		return strconv.Itoa(len(v.Val))
	}

	varExists := v.Set == true
	// CheckNull means that an empty string is treated as unset
	if s.CheckNull {
		varExists = varExists && v.Val != ""
	}

	switch s.SubType {
	case VarSubAssign:
		if varExists {
			return v.Val
		}
		scp.Set(s.VarName, s.SubVal)
		return s.SubVal
	case VarSubMinus:
		if varExists {
			return v.Val
		}
		return s.SubVal
	case VarSubPlus:
		if varExists {
			return ""
		}
		return s.SubVal
	case VarSubQuestion:
		if varExists {
			return v.Val
		}
		if s.SubVal != "" {
			ExitShellWithMessage(T.ExitFailure, s.SubVal)
		}
		ExitShellWithMessage(T.ExitFailure, s.VarName+": Parameter not set")
	case VarSubTrimRight, VarSubTrimRightMax, VarSubTrimLeft, VarSubTrimLeftMax:
		ExitShellWithMessage(T.ExitFailure, "Trim operations not implemented")
	}

	logex.Fatal("SubVariable.Sub unreached")
	return ""
}
示例#2
0
func LocalCmd(scp *variables.Scope, ioc *T.IOContainer, args []string) T.ExitStatus {
	// Local should also do assignments, split args on equal sign? already
	// expanded
	for _, a := range args {
		tmp := scp.Get(a)
		if tmp.Set {
			scp.Set(a, tmp.Val, variables.LocalScope)
		} else {
			scp.Set(a, "", variables.LocalScope)
		}
	}
	return T.ExitSuccess
}
示例#3
0
func (n NodeFor) Eval(scp *variables.Scope, ioc *T.IOContainer) T.ExitStatus {
	returnExit := T.ExitSuccess

	expandedArgs := make([]string, len(n.Args))
	for i, arg := range n.Args {
		// This will need to be changed when IFS splitting is coded.
		// Append each split as a seperate item
		expandedArgs[i] = arg.Expand(scp)
	}

	for _, arg := range expandedArgs {
		scp.Set(n.LoopVar, arg)
		returnExit = n.Body.Eval(scp, ioc)
	}

	return returnExit
}
示例#4
0
func (n NodeCommand) Eval(scp *variables.Scope, ioc *T.IOContainer) T.ExitStatus {
	// A line with only assignments applies them to the Root Scope
	// We check this first to avoid unnecessary scope Push/Pop's
	if len(n.Args) == 0 {
		for k, v := range n.Assign {
			scp.Set(k, v.Expand(scp))
		}
		return T.ExitSuccess
	}

	// Minimum of len(n.Args) after expansions, Likely
	// that it will be more after globbing though
	expandedArgs := []string{}
	for _, arg := range n.Args {
		expandedArgs = append(expandedArgs, arg.Expand(scp))
	}

	// Order of precedence:
	// Relative command > Builtin > User Function > Other external command
	command := expandedArgs[0]
	builtinFunc, builtinFound := builtins.All[command]
	userFunc, userFuncFound := scp.Functions[command]

	if strings.ContainsRune(command, '/') || (!builtinFound && !userFuncFound) {
		scp.Push()
		defer scp.Pop()

		for k, v := range n.Assign {
			scp.Set(k, v.Expand(scp), variables.LocalScope)
		}
		return n.execExternal(scp, ioc, expandedArgs)
	}

	if builtinFound {
		return builtinFunc(scp, ioc, expandedArgs[1:])
	}

	if userFuncFound {
		x := userFunc.(NodeFunction)
		return x.EvalFunc(scp, ioc, expandedArgs[1:])
	}

	return T.ExitUnknownCommand
}