LibraryController/hash.go at main · Eclalang/LibraryController · GitHub

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
package LibraryController

import (
	"errors"
	"fmt"
	"reflect"

	"github.com/Eclalang/Ecla/interpreter/eclaType"
	"github.com/Eclalang/LibraryController/utils"
	"github.com/Eclalang/hash"
)

type Hash struct {
	functionMap map[string]interface{}
}

func NewHash() *Hash {
	return &Hash{
		functionMap: map[string]interface{}{
			"hashmd5":        nil,
			"hashsha1":       nil,
			"hashsha224":     nil,
			"hashsha256":     nil,
			"hashsha384":     nil,
			"hashsha512":     nil,
			"hashsha512_224": nil,
			"hashsha512_256": nil,
		},
	}
}

func (h *Hash) Call(name string, args []eclaType.Type) ([]eclaType.Type, error) {
	newArgs := make([]any, len(args))
	for k, arg := range args {
		newArgs[k] = utils.EclaTypeToGo(arg)
	}
	if _, ok := h.functionMap[name]; !ok {
		return nil, errors.New(fmt.Sprintf("Method %s not found in package hash", name))
	}
	switch name {
	case "hashmd5":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashmd5(newArgs[0].(string)))}, nil
		}
	case "hashsha1":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha1(newArgs[0].(string)))}, nil
		}
	case "hashsha224":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha224(newArgs[0].(string)))}, nil
		}
	case "hashsha256":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha256(newArgs[0].(string)))}, nil
		}
	case "hashsha384":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha384(newArgs[0].(string)))}, nil
		}
	case "hashsha512":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha512(newArgs[0].(string)))}, nil
		}
	case "hashsha512_224":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha512_224(newArgs[0].(string)))}, nil
		}
	case "hashsha512_256":
		if reflect.TypeOf(newArgs[0]).Kind() == reflect.String && len(newArgs) == 1 {
			return []eclaType.Type{utils.GoToEclaType(hash.Hashsha512_256(newArgs[0].(string)))}, nil
		}
	default:
		return nil, errors.New(fmt.Sprintf("Method %s not found in package hash", name))
	}

	return []eclaType.Type{eclaType.Null{}}, nil
}