Method parseFunction

lang/expressions/parse_function.go:16–61

(exec bool, cmd []rune, strOrVal varFormatting)

}

func (tree *ParserT) parseFunction(exec bool, cmd []rune, strOrVal varFormatting) ([]rune, primitives.FunctionT, error) {
	params, err := tree.parseFunctionParameters(cmd)
	if err != nil {
		return nil, nil, fmt.Errorf("cannot parse `function(parameters...)`: %s", err.Error())
	}
	r := append(cmd, params...)

	if !exec {
		return r, nil, nil
	}

	fn := func() (*primitives.Value, error) {
		val := new(primitives.Value)
		var err error

		fork := tree.p.Fork(lang.F_NO_STDIN | lang.F_CREATE_STDOUT)
		params = append([]rune{' '}, params[1:len(params)-1]...)
		block := append(cmd, params...)
		val.ExitNum, err = fork.Execute(block)

		//val.Error = fork.Stderr

		if err != nil {
			return val, fmt.Errorf("function `%s` compilation error: %s", string(cmd), err.Error())
		}

		if val.ExitNum != 0 {
			return val, fmt.Errorf("function `%s` returned non-zero exit number (%d)", string(cmd), val.ExitNum)
		}

		b, err := fork.Stdout.ReadAll()
		if err != nil {
			return val, fmt.Errorf("function `%s` STDOUT read error: %s", string(cmd), err.Error())
		}
		b = utils.CrLfTrim(b)
		val.DataType = fork.Stdout.GetDataType()
		val.Value, err = formatBytes(tree, b, val.DataType, strOrVal)
		if err != nil {
			return nil, fmt.Errorf("function `%s` STDOUT conversion error: %s", string(cmd), err.Error())
		}

		return val, err
	}

	return r, fn, nil
}

func (tree *ParserT) parseFunctionParameters(cmd []rune) ([]rune, error) {
	var escape bool