public static SkryptObject ToJSON(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var str = TypeConverter.ToString(input, 0, engine);
var json = JsonConvert.DeserializeObject <Dictionary <string, string> >(str);
var array = engine.Create <Array>();
foreach (var kv in json)
{
array.Table[kv.Key] = engine.Create <String>(kv.Value);
}
return(array);
}
public static SkryptObject ToHex(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var n = TypeConverter.ToNumeric(input, 0);
var str = Sys.Convert.ToString((long)n, 16);
return(engine.Create <String>(str));
}
public static SkryptObject Mod(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToNumeric(values, 0);
var b = TypeConverter.ToNumeric(values, 1);
return(engine.Create <Numeric>(a % b));
}
public static SkryptObject error(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var s = TypeConverter.ToString(values, 0, engine);
engine.ThrowError(s, engine.CurrentNode?.Token);
return(engine.Create <Null>(s));
}
public static SkryptObject Lerp(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToNumeric(values, 0);
var b = TypeConverter.ToNumeric(values, 1);
var t = TypeConverter.ToNumeric(values, 2);
return(engine.Create <Numeric>(a * (1 - t) + b * t));
}
public static SkryptObject Open(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var path = TypeConverter.ToString(values, 0, engine);
var file = engine.Create <File>(path);
return(file);
}
public static SkryptObject Clamp(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var x = TypeConverter.ToNumeric(values, 0);
var a = TypeConverter.ToNumeric(values, 1);
var b = TypeConverter.ToNumeric(values, 2);
return(engine.Create <Numeric>(SysMath.Min(SysMath.Max(x, a), b)));
}
public static SkryptObject ToUTF16(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var str = TypeConverter.ToString(input, 0, engine);
byte[] bytes = Sys.Text.Encoding.Default.GetBytes(str);
var encoded = Sys.Text.UnicodeEncoding.Unicode.GetString(bytes);
return(engine.Create <String>(encoded));
}
public SkryptObject Replace(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
return(engine.Create <String>(
((String)self).Value.Replace(
TypeConverter.ToString(input, 0, engine),
TypeConverter.ToString(input, 1, engine)
)
));
}
public SkryptObject Explode(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var delimiter = TypeConverter.ToString(input, 0, engine);
var selfString = ((String)self).Value;
var exploded = !string.IsNullOrEmpty(delimiter) ?
selfString.Split(new string[] { delimiter }, Sys.StringSplitOptions.None) :
new string[] { selfString };
var array = engine.Create <Array>();
for (int i = 0; i < exploded.Length; i++)
{
array.List.Add(engine.Create <String>(exploded[i]));
}
return(array);
}
public SkryptObject Find(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
return(engine.Create <Numeric>(
((String)self).Value.IndexOf(
TypeConverter.ToString(input, 0, engine),
(int)TypeConverter.ToNumeric(input, 1)
)
));
}
public SkryptObject Reverse(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var s = (String)self;
char[] charArray = s.Value.ToCharArray();
Sys.Array.Reverse(charArray);
return(engine.Create <String>(new string(charArray)));
}
public override ScopeContext Execute(SkryptEngine engine, SkryptObject self, SkryptObject[] parameters, ScopeContext scope)
{
SkryptObject returnValue = null;
if (IsSkryptMethod)
{
returnValue = ((SkryptDelegate)Method)(engine, self, parameters);
}
else
{
var parCount = Method.Method.GetParameters().Count();
var input = new object[parCount];
for (int i = 0; i < input.Length; i++)
{
if (i < parameters.Length)
{
input[i] = parameters[i];
}
else
{
input[i] = null;
}
}
returnValue = (SkryptObject)Method.DynamicInvoke(input);
if (returnValue == null)
{
returnValue = engine.Create <Null>();
}
}
if (typeof(SkryptType).IsAssignableFrom(returnValue.GetType()))
{
returnValue.GetPropertiesFrom(engine.Executor.GetType(((SkryptType)returnValue).TypeName, scope));
}
var newScope = new ScopeContext {
ParentScope = scope,
Properties = scope.Properties | ScopeProperties.InMethod
};
if (self != null)
{
newScope.SetVariable("self", self, Modifier.Const);
}
newScope.ReturnObject = returnValue;
newScope.ReturnObject.Engine = engine;
newScope.Variables = new Dictionary <string, Variable>(scope.Variables);
return(newScope);
}
public static SkryptObject Range(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var sorted = a.Sort(engine, a, null);
double high = (Numeric)((Array)sorted).List.Last();
double low = (Numeric)((Array)sorted).List.First();
return(engine.Create <Numeric>(high - low));
}
public static SkryptObject Mean(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var total = 0d;
for (int i = 0; i < a.List.Count; i++)
{
total += (Numeric)a.List[i];
}
return(engine.Create <Numeric>(total / a.List.Count));
}
public static SkryptObject print(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToAny(values, 0);
var s = GetString(a, engine);
if ((engine.Settings & EngineSettings.NoLogs) == 0)
{
Console.WriteLine(s);
}
return(engine.Create <String>(s));
}
public SkryptObject Read(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var s = (File)self;
var str = "";
using (StreamReader streamReader = new StreamReader(s.Path)) {
str = streamReader.ReadToEnd();
streamReader.Close();
}
return(engine.Create <String>(str));
}
public SkryptObject GetBytes(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var byteArray = Sys.Text.Encoding.ASCII.GetBytes(((String)self).Value);
var array = engine.Create <Array>();
for (int i = 0; i < byteArray.Length - 1; i++)
{
array.List.Add((Numeric)byteArray[i]);
}
return(array);
}
public SkryptObject Sum(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var b = 0d;
for (int i = 0; i < a.List.Count; i++)
{
b += (Numeric)a.List[i];
}
return(engine.Create <Numeric>(b));
}
public static SkryptObject Parse(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var s = TypeConverter.ToString(input, 0, engine);
var p = double.TryParse(s, out double r);
if (!p)
{
throw new SkryptException("Invalid input format!");
}
return(engine.Create <Numeric>(r));
}
public SkryptObject PadLeft(SkryptEngine engine, SkryptObject self, SkryptObject[] input)
{
var a = TypeConverter.ToNumeric(input, 0);
var s = TypeConverter.ToString(input, 1, engine);
var newString = engine.Create <String>(((String)self).Value);
while (newString.Value.Length < a)
{
newString.Value = s + newString.Value;
}
return(newString);
}
public static SkryptObject Mode(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var v = a.List;
var query = v.GroupBy(x => ((Numeric)x).Value)
.Select(group => new { Value = group.Key, Count = group.Count() })
.OrderByDescending(x => x.Count);
var item = query.First();
return(engine.Create <Numeric>(item.Value));
}
public static SkryptObject SHA1(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var s = TypeConverter.ToString(values, 0, engine);
var byteArray = Sys.Text.Encoding.ASCII.GetBytes(s.Value);
var hashValue = new SHA1Managed().ComputeHash(byteArray);
var array = engine.Create <Array>();
for (int i = 0; i < hashValue.Length; i++)
{
array.List.Add((Numeric)hashValue[i]);
}
return(array);
}
public static SkryptObject Max(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var b = -double.MaxValue;
for (int i = 0; i < a.List.Count; i++)
{
if ((Numeric)a.List[i] > b)
{
b = (Numeric)a.List[i];
}
}
return(engine.Create <Numeric>(b));
}
public static SkryptObject Request(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var address = TypeConverter.ToString(values, 0, engine);
var request = (HttpWebRequest)WebRequest.Create(address);
request.Credentials = CredentialCache.DefaultCredentials;
request.ContentType = "text/plain";
request.Timeout = Timeout.Infinite;
request.Method = "GET";
request.Accept = "text/plain";
request.KeepAlive = false;
HttpWebResponse response = null;
try {
response = (HttpWebResponse)request.GetResponse();
} catch (WebException e) {
return(engine.Create <String>(e.Status.ToString()));
}
// Get the stream containing content returned by the server.
var dataStream = response.GetResponseStream();
// Open the stream using a StreamReader for easy access.
var reader = new StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Display the content.
Console.WriteLine(responseFromServer);
// Clean up the streams and the response.
reader.Close();
response.Close();
return(engine.Create <String>(responseFromServer));
}
public static SkryptObject input(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
engine.Stopwatch.Stop();
var a = TypeConverter.ToAny(values, 0);
if ((engine.Settings & EngineSettings.NoLogs) == 0)
{
Console.WriteLine(a);
}
var input = Console.ReadLine();
engine.Stopwatch.Start();
return(engine.Create <String>(input));
}
public static SkryptObject Small(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = (Array)TypeConverter.ToArray(values, 0).Clone(); // Copy array so we don't affect the original one by sorting it
var k = TypeConverter.ToNumeric(values, 1);
a.List.Sort((x, y) => {
if ((Numeric)x > (Numeric)y)
{
return(1);
}
else
{
return(-1);
}
});
return(engine.Create <Numeric>(a.List[a.List.Count - (int)k - 1]));
}
public static SkryptObject CountEmpty(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var a = TypeConverter.ToArray(values, 0);
var empty = 0;
for (int i = 0; i < a.List.Count; i++)
{
if (a.List[i] == null || a.List[i] == (String)"")
{
empty++;
}
else
{
empty--;
}
}
return(engine.Create <Numeric>(empty));
}
public SkryptObject Map(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var m = TypeConverter.ToMethod(values, 0);
var newArray = engine.Create <Array>(((Array)self).List);
if (m.GetType() == typeof(SkryptMethod) && m.Parameters.Count != 1)
{
engine.ThrowError("Input function must have 1 parameter!");
}
var scope = SkryptMethod.GetPopulatedScope(m, new[] { new Null() });
scope.ParentScope = engine.CurrentScope;
var name = scope.Variables.Keys.First();
for (int i = 0; i < newArray.List.Count; i++)
{
var x = newArray.List[i];
scope.Variables[name].Value = x;
var r = m.Execute(engine, self, new[] { x }, scope);
((Array)self).List[i] = scope.Variables[name].Value;
}
var iterator = new Dictionary <string, SkryptObject>(((Array)self).Table);
foreach (var p in iterator)
{
var x = p.Value;
scope.Variables[name].Value = x;
var r = m.Execute(engine, self, new[] { x }, scope);
newArray.Table[p.Key] = scope.Variables[name].Value;
}
return(newArray);
}
public static SkryptObject AESEncrypt(SkryptEngine engine, SkryptObject self, SkryptObject[] values)
{
var toEncrypt = TypeConverter.ToString(values, 0, engine);
var password = TypeConverter.ToString(values, 1, engine);
var bytesToBeEncrypted = Sys.Text.Encoding.UTF8.GetBytes(toEncrypt);
var passwordBytes = Sys.Text.Encoding.UTF8.GetBytes(password);
// Hash the password with SHA256
passwordBytes = Sys.Security.Cryptography.SHA256.Create().ComputeHash(passwordBytes);
byte[] encryptedBytes = null;
// Set your salt here, change it to meet your flavor:
// The salt bytes must be at least 8 bytes.
byte[] saltBytes = new byte[] { 2, 64, 56, 76, 12, 10, 23, 5 };
using (MemoryStream ms = new MemoryStream()) {
using (RijndaelManaged AES = new RijndaelManaged()) {
AES.KeySize = 256;
AES.BlockSize = 128;
var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
AES.Key = key.GetBytes(AES.KeySize / 8);
AES.IV = key.GetBytes(AES.BlockSize / 8);
AES.Mode = CipherMode.CBC;
using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write)) {
cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
cs.Close();
}
encryptedBytes = ms.ToArray();
}
}
var result = Convert.ToBase64String(encryptedBytes);
return(engine.Create <String>(result));
}
