husk 0.1.3

Rust bindings for the mvdan.cc/sh Golang library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

package util

import (
    "github.com/hwittenborn/husk/ctypes"
    "strings"
    "unsafe"
    "runtime/cgo"
    shSyntax "mvdan.cc/sh/v3/syntax"
)

// Return an error. These should be handled in the `husk` Rust crate.
func HuskError(errorString string, huskDefined bool) *ctypes.Char {
        var huskErrorString string

        if huskDefined {
                huskErrorString = "husk-err:"
        } else {
                huskErrorString = "err:"
        }

        huskErrorString += errorString

        return ctypes.CString(huskErrorString)
}

// Build a Go string array from a C string array.
func BuildStringArray(stringArray **ctypes.Char, stringArraySize ctypes.Int) []string {
        var goCStringArray []*ctypes.Char = unsafe.Slice(stringArray, stringArraySize)
        var goStringArray []string                   
         
        for _, item := range goCStringArray {
                goStringArray = append(goStringArray, ctypes.GoString(item))
        }

        return goStringArray
}

// Convert an array of environment variables into a map of key-value pairs.
func EnvListToEnvMap(envList []string) map[string]string {
	envMap := make(map[string]string)

	for _, keyValue := range envList {
		parts := strings.Split(keyValue, "=")
		key := parts[0]
		value := strings.Join(parts[1:], "=")

		envMap[key] = value
	}

	return envMap
}

// Free the memory for an item from Go.
//
// # Arguments:
// - `ptr`: The pointer to the Go item.
func HuskDeleteGoItem(ptr ctypes.UintptrT) {
        handle := cgo.Handle(ptr)
        handle.Delete()
}

// Get a C string out of a Go string array.
//
// # Arguments:
// - `goArray`: The pointer to the Go array.
// - `itemPosition`: The position of the item to return.
//
// # Returns:
// - `cString`: A pointer to the C string. Is null if `itemPosition` isn't a valid index in the list.
func HuskGetCStringFromArray(goArray ctypes.UintptrT, itemPosition ctypes.Int) (cString *ctypes.Char) {
        arrayHandle := cgo.Handle(goArray)
        array := arrayHandle.Value().([]string)
        goItemPosition := int(itemPosition)

        if !(goItemPosition > (len(array) - 1)) {
                cString = ctypes.CString(array[goItemPosition])
        }

        return
}

// Get the `syntax.LangVariant` from an integer.
func GetLangVariant(langVariantInt ctypes.Int) shSyntax.LangVariant {
        var langVariant shSyntax.LangVariant

        switch langVariant {
        case 0:
                langVariant = shSyntax.LangBash
        case 1:
                langVariant = shSyntax.LangPOSIX
        case 2:
                langVariant = shSyntax.LangMirBSDKorn
        case 3:
                langVariant = shSyntax.LangBats
        case 4:
                langVariant = shSyntax.LangAuto
        default:
                panic("Invalid language variant supplied: " + string(langVariant))
        }

	return langVariant
}