javascript_interpreter/Convert.cs at master · andrei-kondakov/javascript_interpreter · 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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ES;

namespace ES
{
    // ---------------------------- Преобразование типов ---------------------------//
    public static class Convert
    {
        public static ES.LanguageType ToPrimitive(ES.LanguageType input, string preferredType)
        {
            if (input is ES.Object)
            {
                throw new NotImplementedException();
                //return ((ES.Object)input).DefaultValue(preferredType);
            }
            else
            {
                return input;
            }
        }
        public static ES.Number ToNumber(ES.LanguageType x)
        {

            if (x is ES.Undefined) return new ES.Number(Double.NaN);// QUESTION/TODO: NaN???!??
            if (x is ES.Null) return new ES.Number(0);
            if (x is ES.Boolean)
            {
                bool val = ((ES.Boolean)x).Value;
                return new ES.Number(System.Convert.ToDouble(val));
            }
            if (x is ES.Number) return (ES.Number)x;
            if (x is ES.String)
            {
                string str = ((ES.String)x).Value;
                double number = double.Parse(str, System.Globalization.CultureInfo.InvariantCulture);
                return new ES.Number(number);
            }
            if (x is Object)
            {
                throw new NotImplementedException();
                //EcmaType primValue = ToPrimitive(x, "Number");
                //return ToNumber(primValue);
            }
            return null;
        }
        public static ES.String ToString(ES.LanguageType x)
        {
            if (x is ES.Undefined)
            {
                return new ES.String("undefined");
            }
            if (x is ES.Null)
            {
                return new ES.String("null");
            }
            if (x is ES.Boolean)
            {
                return new ES.String(((ES.Boolean)x).Value.ToString());
            }
            if (x is ES.Number)
            {
                var number = x as ES.Number;
                if (double.IsNaN(number.Value))
                {
                    return new ES.String("NaN");
                }
                else
                {
                    return new ES.String(number.Value.ToString());
                }
            }
            if (x is ES.String)
            {
                return x as ES.String;
            }
            if (x is ES.Object)
            {
                throw new NotImplementedException();
            }
            return null;
        }
        public static ES.Boolean ToBoolean(ES.LanguageType x)
        {
            if (x is ES.Undefined)
            {
                return new ES.Boolean(false);
            }
            if (x is ES.Null)
            {
                return new ES.Boolean(false);
            }
            if (x is ES.Boolean)
            {
                return x as ES.Boolean;
            }
            if (x is ES.Number)
            {
                var number = x as ES.Number;
                return new ES.Boolean(System.Convert.ToBoolean(number.Value));
            }
            if (x is ES.String)
            {
                var str = x as ES.String;
                if (str.Value.Length > 0)
                {
                    return new ES.Boolean(true);
                }
                else
                {
                    return new ES.Boolean(false);
                }
            }
            if (x is ES.Object)
            {
                return new ES.Boolean(true);
            }
            return null;
        }
        // TODO IsCallable
        // ToObject
    }

}