core

var (
	MODES          = []string{COLOR_AUTO, COLOR_ALWAYS, COLOR_NEVER}
	NO_CONSTRAINTS []string

	FlagHelp                 BoolRadArg
	FlagDebug                BoolRadArg
	FlagRadDebug             BoolRadArg
	FlagColor                StringRadArg
	FlagQuiet                BoolRadArg
	FlagShell                BoolRadArg
	FlagVersion              BoolRadArg
	FlagConfirmShellCommands BoolRadArg
	FlagSrc                  BoolRadArg
	FlagCstTree              BoolRadArg
	FlagAstTree              BoolRadArg
	FlagRadArgsDump          BoolRadArg
	FlagMockResponse         StringRadArg
	FlagRepl                 BoolRadArg
	FlagTlsInsecure          BoolRadArg
)

var (
	RRootCmd                 *ra.Cmd
	RConfig                  *RadConfig
	RP                       Printer
	RIo                      RadIo
	RExit                    *RadExitHandler
	RReq                     *Requester
	RClock                   Clock
	RSleep                   func(duration time.Duration)
	RShell                   ShellExecutor
	RNG                      *rand.Rand
	HasScript                bool
	ScriptPath               string
	ScriptDir                string
	ScriptName               string
	IsTest                   bool
	AlreadyExportedShellVars bool

	StartEpochMillis int64
)

var ATTR_STRINGS = make([]string, 0)

var Cmds []EmbeddedCmd

var CmdsByName map[string]EmbeddedCmd

var EMPTY_STR = NewRadString("")

var FuncColorize = BuiltInFunc{
	Name: FUNC_COLORIZE,
	Execute: func(f FuncInvocation) RadValue {
		strVal := ToPrintableQuoteStr(f.GetArg("_val"), false)
		enum := lo.Uniq(f.GetList("_enum").AsStringList(false))
		skipIfSingle := f.GetBool("skip_if_single")

		if len(enum) == 0 {
			return f.ReturnErrf(rl.ErrEmptyList, "Possible values list cannot be empty, but was.")
		}

		if skipIfSingle && len(enum) == 1 {
			s := NewRadString(strVal)
			return f.Return(s)
		}

		sort.Strings(enum)

		if !lo.Contains(enum, strVal) {
			return f.ReturnErrf(rl.ErrColorizeValNotInEnum,
				"Value '%s' not found in the provided list of possible values: %s",
				strVal,
				enum)
		}

		r, g, b, err := GetEnumColor(strVal, enum)
		if err != nil {
			return f.ReturnErrf(rl.ErrEmptyList, "Failed to get color for value '%s': %s", strVal, err.Error())
		}

		s := NewRadString(strVal)
		s.SetRgb(r, g, b)
		return f.Return(s)
	},
}

var FuncConvertDuration = BuiltInFunc{
	Name: FUNC_CONVERT_DURATION,
	Execute: func(f FuncInvocation) RadValue {
		value := f.GetFloat("_value")
		unit := f.GetStr("_unit").Plain()

		var nanosFloat float64
		switch unit {
		case "nanos":
			nanosFloat = value
		case "micros":
			nanosFloat = value * float64(time.Microsecond)
		case "millis":
			nanosFloat = value * float64(time.Millisecond)
		case "seconds":
			nanosFloat = value * float64(time.Second)
		case "minutes":
			nanosFloat = value * float64(time.Minute)
		case "hours":
			nanosFloat = value * float64(time.Hour)
		case "days":
			nanosFloat = value * 24 * float64(time.Hour)
		default:
			bugIncorrectTypes(FUNC_CONVERT_DURATION)
			panic(UNREACHABLE)
		}

		if math.IsNaN(nanosFloat) || math.IsInf(nanosFloat, 0) || math.Abs(nanosFloat) > float64(math.MaxInt64) {
			return f.ReturnErrf(rl.ErrNumInvalidRange, "Duration overflow: value too large for %s", unit)
		}

		return f.Return(NewDurationMap(int64(nanosFloat)))
	},
}

var FuncDebug = BuiltInFunc{
	Name: FUNC_DEBUG,
	Execute: func(f FuncInvocation) RadValue {
		RP.ScriptDebug(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncExit = BuiltInFunc{
	Name: FUNC_EXIT,
	Execute: func(f FuncInvocation) RadValue {
		err := f.GetIntAllowingBool("_code")
		exit(f.i, err)
		return VOID_SENTINEL
	},
}

var FuncInternalCheckFromLogs = BuiltInFunc{
	Name: INTERNAL_FUNC_CHECK_FROM_LOGS,
	Execute: func(f FuncInvocation) RadValue {

		raw := strings.TrimSpace(f.GetStr("_duration").Plain())
		d, err := ParseDuration(raw)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidCheckDuration, "Invalid duration: %s", err.Error())
		}
		if d < 0 {
			return f.ReturnErrf(rl.ErrInvalidCheckDuration, "Duration cannot be negative: %s", raw)
		}
		durationMillis := d.Milliseconds()

		verbose := f.GetBool("_verbose")

		scripts := parseInvocationLogs(f.i, f.callNode, durationMillis)

		sortScriptsByLastOccurrence(scripts)

		durationDesc := raw
		if durationMillis == 0 {
			durationDesc = "all time"
		}
		RP.Printf("Found %d scripts in invocation logs (checking within %s)...\n\n", len(scripts), durationDesc)

		chk, err := check.NewChecker()
		if err != nil {

			chk = nil
			RP.RadStderrf("Warning! Failed to init checker once, will init per file: %v\n", err)
		}

		results := make([]scriptResult, 0, len(scripts))
		maxPathLen := 0
		for i, script := range scripts {
			RP.RadDebugf("Checking script %d/%d: %s", i+1, len(scripts), script.Path)
			if !com.IsRegularFile(script.Path) {
				RP.RadDebugf("  skipped (not a regular file)")
				results = append(results, scriptResult{Path: script.Path, Skipped: true})
				continue
			}
			checkStart := time.Now()
			counts, ok := checkScriptWith(script.Path, chk)
			RP.RadDebugf("  checked in %s (ok=%t, errors=%d)", time.Since(checkStart), ok, counts.Errors)
			r := scriptResult{Path: script.Path, Counts: counts, Ok: ok}
			results = append(results, r)
			if len(script.Path) > maxPathLen {
				maxPathLen = len(script.Path)
			}
		}

		// Column headers and their widths
		type col struct {
			Header string
			Width  int
		}
		cols := []col{
			{"Errors", 6},
			{"Warns", 5},
			{"Info", 5},
			{"Hints", 5},
		}

		faint := color.New(color.Faint)
		green := color.New(color.FgGreen)
		red := color.New(color.FgRed)
		yellow := color.New(color.FgYellow)
		cyan := color.New(color.FgCyan)
		blue := color.New(color.FgBlue)

		colsWidth := 0
		for _, c := range cols {
			colsWidth += 2 + c.Width
		}
		tableWidth := 4 + maxPathLen + colsWidth

		hasDataRows := false
		for _, r := range results {
			if !r.Skipped {
				hasDataRows = true
				break
			}
		}
		if hasDataRows {
			headerLine := fmt.Sprintf("    %-*s", maxPathLen, "")
			for _, c := range cols {
				headerLine += fmt.Sprintf("  %*s", c.Width, c.Header)
			}
			RP.Printf("%s\n", faint.Sprint(headerLine))
		}

		totalChecked, passed, failed, skipped, loadErrors := 0, 0, 0, 0, 0
		var totalCounts diagCounts

		for _, r := range results {
			if r.Skipped {
				skipped++
				if verbose {
					RP.Printf("  %s\n", faint.Sprintf("- %s (not found or not a regular file)", r.Path))
				}
				continue
			}

			totalChecked++
			totalCounts.Errors += r.Counts.Errors
			totalCounts.Warnings += r.Counts.Warnings
			totalCounts.Infos += r.Counts.Infos
			totalCounts.Hints += r.Counts.Hints

			isFail := !r.Ok || r.Counts.Errors > 0
			if isFail {
				failed++
			} else {
				passed++
			}
			if !r.Ok {
				loadErrors++
			}

			// Status icon
			var icon string
			if isFail {
				icon = red.Sprint("✗")
			} else {
				icon = green.Sprint("✓")
			}

			line := fmt.Sprintf("  %s %-*s", icon, maxPathLen, r.Path)

			if r.Ok {
				line += formatCount(r.Counts.Errors, cols[0].Width, red, faint)
				line += formatCount(r.Counts.Warnings, cols[1].Width, yellow, faint)
				line += formatCount(r.Counts.Infos, cols[2].Width, cyan, faint)
				line += formatCount(r.Counts.Hints, cols[3].Width, blue, faint)
			} else {
				line += "  " + faint.Sprint("(load error)")
			}

			RP.Printf("%s\n", line)
		}

		sepWidth := tableWidth
		if sepWidth < 40 {
			sepWidth = 40
		}
		RP.Printf("\n%s\n", strings.Repeat("─", sepWidth))

		bold := color.New(color.Bold)

		summary := fmt.Sprintf("Checked %d scripts: %s passed, %s failed",
			totalChecked,
			green.Sprintf("%d", passed),
			red.Sprintf("%d", failed))

		// Append non-zero diagnostic/status details in a single parenthetical
		var detailParts []string
		if totalCounts.Errors > 0 {
			noun := "errors"
			if totalCounts.Errors == 1 {
				noun = "error"
			}
			detailParts = append(detailParts, red.Sprintf("%d %s", totalCounts.Errors, noun))
		}
		if loadErrors > 0 {
			noun := "load errors"
			if loadErrors == 1 {
				noun = "load error"
			}
			detailParts = append(detailParts, faint.Sprintf("%d %s", loadErrors, noun))
		}
		if totalCounts.Warnings > 0 {
			noun := "warnings"
			if totalCounts.Warnings == 1 {
				noun = "warning"
			}
			detailParts = append(detailParts, yellow.Sprintf("%d %s", totalCounts.Warnings, noun))
		}
		if totalCounts.Infos > 0 {
			noun := "info diagnostics"
			if totalCounts.Infos == 1 {
				noun = "info diagnostic"
			}
			detailParts = append(detailParts, cyan.Sprintf("%d %s", totalCounts.Infos, noun))
		}
		if totalCounts.Hints > 0 {
			noun := "hints"
			if totalCounts.Hints == 1 {
				noun = "hint"
			}
			detailParts = append(detailParts, blue.Sprintf("%d %s", totalCounts.Hints, noun))
		}
		if skipped > 0 {
			detailParts = append(detailParts, faint.Sprintf("%d skipped", skipped))
		}
		if len(detailParts) > 0 {
			summary += " (" + strings.Join(detailParts, ", ") + ")"
		}

		RP.Printf("%s.\n", bold.Sprint(summary))

		if failed > 0 {
			RExit.Exit(1)
		} else {
			RExit.Exit(0)
		}
		return VOID_SENTINEL
	},
}

var FuncMatches = BuiltInFunc{
	Name: FUNC_MATCHES,
	Execute: func(f FuncInvocation) RadValue {
		input := f.GetStr("_str").Plain()
		pattern := f.GetStr("_pattern").Plain()
		partial := f.GetBool("partial")

		re, err := regexp.Compile(pattern)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
		}

		var matches bool
		if partial {
			matches = re.FindString(input) != ""
		} else {

			anchoredPattern := "^(?:" + pattern + ")$"
			anchoredRe, err := regexp.Compile(anchoredPattern)
			if err != nil {
				return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
			}
			matches = anchoredRe.MatchString(input)
		}

		return f.Return(matches)
	},
}

var FuncMultipick = BuiltInFunc{
	Name: FUNC_MULTIPICK,
	Execute: func(f FuncInvocation) RadValue {

		options := f.GetList("_options").AsStringList(false)

		if len(options) == 0 {
			return f.Return(NewErrorStrf("Cannot multipick from empty options list"))
		}

		minArg := f.GetArg("min")
		maxArg := f.GetArg("max")
		promptArg := f.GetArg("prompt")

		min := int64(0)
		if !minArg.IsNull() {
			min = minArg.RequireInt(f.i, f.callNode)
		}

		if min < 0 {
			return f.Return(NewErrorStrf("min must be non-negative, got %d", min))
		}

		// Get max value (optional)
		var max *int64
		if !maxArg.IsNull() {
			maxVal := maxArg.RequireInt(f.i, f.callNode)
			max = &maxVal

			if maxVal <= 0 {
				return f.Return(NewErrorStrf("max must be positive, got %d", maxVal))
			}

			if min > maxVal {
				return f.Return(NewErrorStrf("min (%d) cannot be greater than max (%d)", min, maxVal))
			}
		}

		if min > int64(len(options)) {
			if min == 1 {
				return f.Return(NewErrorStrf("min is 1 but there are no options available"))
			} else {
				return f.Return(NewErrorStrf("min is %d but only %d options available", min, len(options)))
			}
		}

		// Generate smart default prompt if not provided
		var prompt string
		if promptArg.IsNull() {
			prompt = generateMultipickPrompt(min, max)
		} else {
			prompt = f.GetStr("prompt").Plain()
			if prompt == "" {

				prompt = " "
			}
		}

		opts := make([]huh.Option[string], len(options))
		for i, opt := range options {
			opts[i] = huh.NewOption(opt, opt)
		}

		multiSelect := huh.NewMultiSelect[string]().
			Title(prompt).
			Options(opts...).
			Validate(func(selected []string) error {
				count := int64(len(selected))

				if max != nil && min == *max {
					if count != min {
						if min == 1 {
							return fmt.Errorf("Must select exactly 1 option, but selected %d", count)
						} else {
							return fmt.Errorf("Must select exactly %d options, but selected %d", min, count)
						}
					}
					return nil
				}

				if count < min {
					if min == 1 {
						return fmt.Errorf("Must select at least 1 option, but only selected %d", count)
					} else {
						return fmt.Errorf("Must select at least %d options, but only selected %d", min, count)
					}
				}

				if max != nil && count > *max {
					if *max == 1 {
						return fmt.Errorf("Must select at most 1 option, but selected %d", count)
					} else {
						return fmt.Errorf("Must select at most %d options, but selected %d", *max, count)
					}
				}

				return nil
			})

		if max != nil {
			multiSelect = multiSelect.Limit(int(*max))
		}

		// Execute the selection
		var selected []string
		multiSelect = multiSelect.Value(&selected)

		if err := multiSelect.Run(); err != nil {
			return f.Return(NewErrorStrf("Error running multipick: %v", err))
		}

		result := NewRadList()
		for _, item := range selected {
			result.Append(newRadValueStr(item))
		}

		return f.Return(result)
	},
}

var FuncPPrint = BuiltInFunc{
	Name: FUNC_PPRINT,
	Execute: func(f FuncInvocation) RadValue {
		item := f.GetArg("_item")

		jsonStruct := RadToJsonType(item)
		output := prettify(f.i, f.callNode, jsonStruct)
		RP.Print(output)
		return VOID_SENTINEL
	},
}

var FuncParseDuration = BuiltInFunc{
	Name: FUNC_PARSE_DURATION,
	Execute: func(f FuncInvocation) RadValue {
		durStr := f.GetStr("_duration").Plain()

		nanos, err := ParseDurationString(durStr)
		if err != nil {
			return f.ReturnErrf(rl.ErrParseDuration, "Failed to parse duration %q: %s", durStr, err)
		}

		return f.Return(NewDurationMap(nanos))
	},
}

var FuncPick = BuiltInFunc{
	Name: FUNC_PICK,
	Execute: func(f FuncInvocation) RadValue {
		options := f.GetList("_options").AsStringList(false)
		filterArg := f.GetArg("_filter")

		filters := make([]string, 0)
		if !filterArg.IsNull() {
			switch coerced := filterArg.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK)
			}
		}

		keyGroups := lo.Map(options, func(key string, _ int) []string { return []string{key} })
		prioExact := f.GetBool(namedArgPreferExact)
		str, err := pickKv(f, keyGroups, keyGroups, filters, prioExact)
		if err != nil {
			return f.Return(err)
		}

		return f.Return(str[0])
	},
}

var FuncPickFromResource = BuiltInFunc{
	Name: FUNC_PICK_FROM_RESOURCE,
	Execute: func(f FuncInvocation) RadValue {
		path := f.GetStr("path").Plain()
		filter := f.GetArg("_filter")

		resource, err := LoadPickResource(f.i, f.callNode, path)
		if err != nil {
			return f.Return(err)
		}

		var keyGroups [][]string
		var valueGroups [][]RadValue
		for _, opt := range resource.Opts {
			keyGroups = append(keyGroups, opt.Keys)
			valueGroups = append(valueGroups, opt.Values)
		}

		filters := make([]string, 0)
		if !filter.IsNull() {
			switch coerced := filter.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK_KV)
			}
		}

		prioExact := f.GetBool(namedArgPreferExact)
		out, err := pickKv(f, keyGroups, valueGroups, filters, prioExact)

		if err != nil {
			return f.Return(err)
		}

		if len(out) == 1 {
			return newRadValues(f.i, f.callNode, out[0])
		} else {
			return newRadValues(f.i, f.callNode, out)
		}
	},
}

var FuncPickKv = BuiltInFunc{
	Name: FUNC_PICK_KV,
	Execute: func(f FuncInvocation) RadValue {
		keys := f.GetList("keys").AsStringList(false)
		values := f.GetList("values").Values
		filter := f.GetArg("_filter")

		filters := make([]string, 0)
		if !filter.IsNull() {
			switch coerced := filter.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK_KV)
			}
		}

		keyGroups := lo.Map(keys, func(key string, _ int) []string { return []string{key} })
		valueGroups := lo.Map(values, func(value RadValue, _ int) []RadValue { return []RadValue{value} })

		prioExact := f.GetBool(namedArgPreferExact)
		out, err := pickKv(f, keyGroups, valueGroups, filters, prioExact)
		if err != nil {
			return f.Return(err)
		}
		return f.Return(out[0])
	},
}

var FuncPrint = BuiltInFunc{
	Name: FUNC_PRINT,
	Execute: func(f FuncInvocation) RadValue {
		RP.Print(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncPrintErr = BuiltInFunc{
	Name: FUNC_PRINT_ERR,
	Execute: func(f FuncInvocation) RadValue {
		RP.ScriptStderrf(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncRand = BuiltInFunc{
	Name: FUNC_RAND,
	Execute: func(f FuncInvocation) RadValue {
		return f.Return(RNG.Float64())
	},
}

var FuncRandInt = BuiltInFunc{
	Name: FUNC_RAND_INT,
	Execute: func(f FuncInvocation) RadValue {
		arg1 := f.GetInt("_arg1")
		arg2 := f.GetArg("_arg2")

		var min, max int64

		if arg2.IsNull() {
			min = 0
			max = arg1
		} else {
			min = arg1
			max = arg2.RequireInt(f.i, f.callNode)
		}

		if min >= max {
			return f.ReturnErrf(rl.ErrArgsContradict, "min (%d) must be less than max (%d).", min, max)
		}

		n := max - min
		return newRadValues(f.i, f.callNode, min+RNG.Int63n(n))
	},
}

var FuncRange = BuiltInFunc{
	Name: FUNC_RANGE,
	Execute: func(f FuncInvocation) RadValue {
		useFloats := false

		arg1 := f.GetArg("_arg1")
		arg2 := f.GetArg("_arg2")
		step := f.GetArg("_step")

		for _, arg := range []RadValue{arg1, arg2, step} {
			switch arg.Type() {
			case rl.RadFloatT:
				useFloats = true
			case rl.RadIntT, rl.RadNullT:
			default:
				bugIncorrectTypes(FUNC_RANGE)
			}
		}

		if useFloats {
			return runFloatRange(f, arg1, arg2, step)
		} else {
			return runIntRange(f, arg1, arg2, step)
		}
	},
}

var FuncReplace = BuiltInFunc{
	Name: FUNC_REPLACE,
	Execute: func(f FuncInvocation) RadValue {
		original := f.GetStr("_original").Plain()
		find := f.GetStr("_find").Plain()
		replace := f.GetStr("_replace").Plain()

		re, err := regexp.Compile(find)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
		}

		replacementFunc := func(match string) string {
			submatches := re.FindStringSubmatch(match)

			if len(submatches) == 0 {
				return match
			}

			result := replace
			for i, submatch := range submatches {
				placeholder := fmt.Sprintf("$%d", i)
				result = strings.ReplaceAll(result, placeholder, submatch)
			}

			return result
		}

		newString := re.ReplaceAllStringFunc(original, replacementFunc)

		return f.Return(newString)
	},
}

var FuncSeedRandom = BuiltInFunc{
	Name: FUNC_SEED_RANDOM,
	Execute: func(f FuncInvocation) RadValue {
		RNG = rand.New(rand.NewSource(f.GetInt("_seed")))
		return VOID_SENTINEL
	},
}

var FuncSleep = BuiltInFunc{
	Name: FUNC_SLEEP,
	Execute: func(f FuncInvocation) RadValue {
		duration := f.GetArg("_duration")
		switch coerced := duration.Val.(type) {
		case int64:
			err := sleep(time.Duration(coerced)*time.Second, f.namedArgs)
			if err != nil {
				return f.Return(err)
			}
			return VOID_SENTINEL
		case float64:
			err := sleep(time.Duration(coerced*1000)*time.Millisecond, f.namedArgs)
			if err != nil {
				return f.Return(err)
			}
			return VOID_SENTINEL
		case RadString:
			durStr := coerced.Plain()

			floatVal, err := rts.ParseFloat(durStr)
			if err == nil {
				err := sleep(time.Duration(floatVal*1000)*time.Millisecond, f.namedArgs)
				if err != nil {
					return f.Return(err)
				}
				return VOID_SENTINEL
			}

			nanos, err := ParseDurationString(durStr)
			if err == nil {
				err := sleep(time.Duration(nanos), f.namedArgs)
				if err != nil {
					return f.Return(err)
				}
				return VOID_SENTINEL
			}

			return f.ReturnErrf(rl.ErrSleepStr, "Invalid string argument: %q", coerced.Plain())
		default:
			bugIncorrectTypes(FUNC_SLEEP)
			panic(UNREACHABLE)
		}
	},
}

var FuncSplit = BuiltInFunc{
	Name: FUNC_SPLIT,
	Execute: func(f FuncInvocation) RadValue {
		toSplit := f.GetStr("_val").Plain()
		splitter := f.GetStr("_sep").Plain()

		limitArg := f.GetArg("limit")
		limit := -1
		if !limitArg.IsNull() {
			limitVal := limitArg.RequireInt(f.i, f.callNode)
			if limitVal < 1 {
				return f.Return(NewErrorStrf("limit must be at least 1, got %d", limitVal).SetCode(rl.ErrNumInvalidRange))
			}

			limit = int(limitVal) + 1
		}

		return f.Return(regexSplit(f.i, f.callNode, toSplit, splitter, limit))
	},
}

var FuncSplitLines = BuiltInFunc{
	Name: FUNC_SPLIT_LINES,
	Execute: func(f FuncInvocation) RadValue {
		toSplit := f.GetStr("_val").Plain()
		return f.Return(splitLines(f.i, f.callNode, toSplit))
	},
}

var FunctionsByName map[string]BuiltInFunc

var (
	NO_NAMED_ARGS_INPUT = map[string]namedArg{}
)

var RAD_NULL = RadNull{}

var RAD_NULL_VAL = newRadValue(nil, nil, RAD_NULL)

var VOID_SENTINEL = RadValue{Val: 0x0}

var VoidBreak = NewEvalResult(VOID_SENTINEL, CtrlBreak)

var VoidContinue = NewEvalResult(VOID_SENTINEL, CtrlContinue)

var VoidNormal = NewEvalResult(VOID_SENTINEL, CtrlNormal)