public static HassiumList getsourcereps(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
if (args[0] is HassiumFunction)
{
var a = (args[0] as HassiumFunction).Target.Method.GetCustomAttributes(typeof(FunctionAttribute), false);
if (a.Length > 0)
{
var reps = (a[0] as FunctionAttribute).SourceRepresentations;
foreach (var rep in reps)
{
HassiumList.add(vm, list, location, new HassiumString(rep));
}
}
}
else if (args[0] is HassiumMethod)
{
HassiumList.add(vm, list, location, new HassiumString((args[0] as HassiumMethod).SourceRepresentation));
}
else if (args[0] is HassiumMultiFunc)
{
HassiumList.add(vm, list, location, new HassiumString((args[0] as HassiumMultiFunc).Methods[0].SourceRepresentation));
}
else if (args[0] is HassiumProperty)
{
var property = (args[0] as HassiumProperty);
HassiumList.add(vm, list, location, new HassiumString((property.Get as HassiumFunction).GetTopSourceRep()));
if (property.Set != null)
{
HassiumList.add(vm, list, location, new HassiumString((property.Set as HassiumFunction).GetTopSourceRep()));
}
}
return(list);
}
public static HassiumList getdocreqparams(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var list = new HassiumList(new HassiumObject[0]);
if (args[0] is HassiumFunction)
{
var a = (args[0] as HassiumFunction).Target.Method.GetCustomAttributes(typeof(DocStrAttribute), false);
if (a.Length > 0)
{
foreach (var param in (a[0] as DocStrAttribute).RequiredParams)
{
HassiumList.add(vm, list, location, new HassiumString(param));
}
}
}
else if (args[0] is HassiumMethod)
{
var meth = (args[0] as HassiumMethod);
if (meth.DocStr != null)
{
foreach (var param in meth.DocStr.RequiredParams)
{
HassiumList.add(vm, list, location, new HassiumString(param));
}
}
}
return(list);
}
public static HassiumList getparamlengths(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
if (args[0] is HassiumFunction)
{
foreach (int len in (args[0] as HassiumFunction).ParameterLengths)
{
HassiumList.add(vm, list, location, new HassiumInt(len));
}
}
else if (args[0] is HassiumMethod)
{
HassiumList.add(vm, list, location, new HassiumInt((args[0] as HassiumMethod).Parameters.Count));
}
else if (args[0] is HassiumMultiFunc)
{
foreach (var method in (args[0] as HassiumMultiFunc).Methods)
{
HassiumList.add(vm, list, location, new HassiumInt(method.Parameters.Count));
}
}
return(list);
}
public HassiumObject Execute(HassiumModule module, HassiumList args, Dictionary <int, HassiumObject> frame = null)
{
CallStack = new LinkedStack <string>();
CurrentModule = module;
ExceptionReturns = new Dictionary <HassiumMethod, int>();
Globals = module.BoundAttributes["__global__"].BoundAttributes;
Handlers = new Stack <HassiumExceptionHandler>();
Stack = new LinkedStack <HassiumObject>();
StackFrame = new StackFrame();
ImportGlobals();
var globalClass = module.GetAttribute(this, "__global__");
(globalClass.GetAttribute(this, "__init__") as HassiumMethod).Invoke(this, new SourceLocation("", 0, 0));
GlobalFrame = StackFrame.Frames.Peek();
if (globalClass.ContainsAttribute("main"))
{
var mainMethod = (globalClass.GetAttribute(this, "main") as HassiumMethod);
if (mainMethod.Parameters.Count > 0)
{
mainMethod.Invoke(this, mainMethod.SourceLocation, args);
}
else
{
mainMethod.Invoke(this, mainMethod.SourceLocation);
}
}
return(lastValuePopped);
}
public static HassiumObject readalllines(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var file = (self as HassiumFile);
if (!File.Exists(file.AbsolutePath.String))
{
vm.RaiseException(HassiumFileNotFoundException.FileNotFoundExceptionTypeDef._new(vm, null, location, file.AbsolutePath));
return(Null);
}
if (file.closed)
{
vm.RaiseException(HassiumFileClosedException.FileClosedExceptionTypeDef._new(vm, null, location, self, get_abspath(vm, self, location)));
return(Null);
}
HassiumList list = new HassiumList(new HassiumObject[0]);
file.Reader.BaseStream.Position = 0;
while (file.Reader.BaseStream.Position < file.Reader.BaseStream.Length)
{
HassiumList.add(vm, list, location, readline(vm, self, location));
}
return(list);
}
public static HassiumObject readbytes(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var file = (self as HassiumFile);
if (!File.Exists(file.AbsolutePath.String))
{
vm.RaiseException(HassiumFileNotFoundException.FileNotFoundExceptionTypeDef._new(vm, null, location, file.AbsolutePath));
return(Null);
}
if (file.closed)
{
vm.RaiseException(HassiumFileClosedException.FileClosedExceptionTypeDef._new(vm, null, location, self, get_abspath(vm, self, location)));
return(Null);
}
HassiumList list = new HassiumList(new HassiumObject[0]);
int count = (int)args[0].ToInt(vm, args[0], location).Int;
for (int i = 0; i < count; i++)
{
HassiumList.add(vm, list, location, new HassiumChar((char)file.Reader.ReadBytes(1)[0]));
}
return(list);
}
public HassiumList listfiles(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList result = new HassiumList(new HassiumObject[0]);
foreach (string dir in Directory.GetFiles(args[0].ToString(vm, args[0], location).String))
{
HassiumList.add(vm, result, location, new HassiumString(dir));
}
return(result);
}
public HassiumList getvars(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList variables = new HassiumList(new HassiumObject[0]);
foreach (var var_ in Environment.GetEnvironmentVariables())
{
HassiumList.add(vm, variables, location, new HassiumString(var_.ToString()));
}
return(variables);
}
public static HassiumList split(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
foreach (var str in Regex.Split(args[1].ToString(vm, args[1], location).String, args[0].ToString(vm, args[0], location).String))
{
HassiumList.ListTypeDef.add(vm, list, location, new HassiumString(str));
}
return(list);
}
public static HassiumList map(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var list = args[0].ToList(vm, args[0], location).Values;
HassiumList result = new HassiumList(new HassiumObject[0]);
for (int i = 0; i < list.Count; i++)
{
HassiumList.add(vm, result, location, args[1].Invoke(vm, location, list[i]));
}
return(result);
}
public HassiumList getips(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
var ips = Dns.GetHostAddresses(args[0].ToString(vm, args[0], location).String);
foreach (var ip in ips)
{
HassiumList.add(vm, list, location, HassiumIPAddr.IPAddrTypeDef._new(vm, null, location, new HassiumString(ip.ToString())));
}
return(list);
}
public static HassiumList hash(VirtualMachine vm, HassiumObject self, SourceLocation location, HassiumObject[] args)
{
HassiumList list = args[1].ToList(vm, args[1], location);
byte[] bytes = new byte[list.Values.Count];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)list.Values[i].ToChar(vm, list.Values[i], location).Char;
}
byte[] hash = ((HashAlgorithm)CryptoConfig.CreateFromName(args[0].ToString(vm, args[0], location).String.ToUpper())).ComputeHash(bytes);
return(new HassiumByteArray(hash, new HassiumObject[0]));
}
public HassiumList gethosts(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
var hosts = Dns.GetHostAddresses(args[0].ToString(vm, args[0], location).String);
foreach (var host in hosts)
{
HassiumList.add(vm, list, location, new HassiumString(host.ToString()));
}
return(list);
}
public static HassiumList range(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
int lower = args.Length == 1 ? 0 : (int)args[0].ToInt(vm, args[0], location).Int;
int upper = args.Length == 1 ? (int)args[0].ToInt(vm, args[0], location).Int : (int)args[1].ToInt(vm, args[1], location).Int;
HassiumList list = new HassiumList(new HassiumObject[0]);
while (lower < upper)
{
HassiumList.add(vm, list, location, new HassiumInt(lower++));
}
return(list);
}
public static HassiumList match(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
Match match = Regex.Match(args[1].ToString(vm, args[1], location).String, args[0].ToString(vm, args[0], location).String);
HassiumList list = new HassiumList(new HassiumObject[0]);
while (match.Success)
{
HassiumList.ListTypeDef.add(vm, list, location, new HassiumString(match.Value));
match = match.NextMatch();
}
return(list);
}
public static HassiumList randbytes(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var Random = (self as HassiumRandom).Random;
HassiumList bytes = new HassiumList(new HassiumObject[0]);
int count = (int)args[0].ToInt(vm, args[0], location).Int;
for (int i = 0; i < count; i++)
{
byte[] buf = new byte[1];
Random.NextBytes(buf);
HassiumList.add(vm, bytes, location, new HassiumChar((char)buf[0]));
}
return(bytes);
}
public HassiumObject readbytes(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
var socket = (self as HassiumSocket);
if (socket.Closed)
{
vm.RaiseException(HassiumSocketClosedException.SocketClosedExceptionTypeDef._new(vm, null, location, this));
return(Null);
}
HassiumByteArray list = new HassiumByteArray(new byte[0], new HassiumObject[0]);
int count = (int)args[0].ToInt(vm, args[0], location).Int;
for (int i = 0; i < count; i++)
{
HassiumList.add(vm, list, location, new HassiumChar((char)socket.Reader.ReadBytes(1)[0]));
}
return(list);
}
public HassiumList readlines(VirtualMachine vm, HassiumObject self, SourceLocation location, params HassiumObject[] args)
{
HassiumList list = new HassiumList(new HassiumObject[0]);
var stream = new FileStream(args[0].ToString(vm, args[0], location).String, FileMode.Open, FileAccess.Read, FileShare.Read);
var reader = new StreamReader(stream);
try
{
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
HassiumList.add(vm, list, location, new HassiumString(reader.ReadLine()));
}
return(list);
}
finally
{
reader.Close();
}
}
public override HassiumObject Invoke(VirtualMachine vm, SourceLocation location, params HassiumObject[] args)
{
if (SourceRepresentation != string.Empty)
{
vm.PushCallStack(string.Format("{0}\t[{1}]", SourceRepresentation, location));
}
if (SourceRepresentation != string.Empty || Name == "__init__")
{
vm.StackFrame.PushFrame();
}
int i = 0;
foreach (var param in Parameters)
{
// If there's more arguments provided than called for
if (i >= args.Length)
{
vm.RaiseException(HassiumArgLengthException.ArgLengthExceptionTypeDef._new(vm, null, location, this, new HassiumInt(Parameters.Count), new HassiumInt(args.Length)));
return(Null);
}
var arg = args[i++];
if (param.Key.FunctionParameterType == FunctionParameterType.Variadic)
{
if (arg is HassiumList || arg is HassiumTuple)
{
vm.StackFrame.Add(param.Value, arg);
}
else
{
HassiumList list = new HassiumList(new HassiumObject[0]);
for (--i; i < args.Length; i++)
{
HassiumList.add(vm, list, location, args[i]);
}
vm.StackFrame.Add(param.Value, list);
}
break;
}
else if (param.Key.FunctionParameterType == FunctionParameterType.Enforced)
{
var enforcedType = vm.ExecuteMethod(param.Key.EnforcedType);
if (enforcedType is HassiumTrait)
{
if (!(enforcedType as HassiumTrait).Is(vm, location, arg).Bool)
{
vm.RaiseException(HassiumConversionFailedException.ConversionFailedExceptionTypeDef._new(vm, null, location, arg, enforcedType));
return(Null);
}
}
else if (!arg.Types.Contains(enforcedType))
{
vm.RaiseException(HassiumConversionFailedException.ConversionFailedExceptionTypeDef._new(vm, null, location, arg, enforcedType));
return(Null);
}
}
vm.StackFrame.Add(param.Value, arg);
}
// If there's less arguments than called for
if (i < args.Length)
{
vm.RaiseException(HassiumArgLengthException.ArgLengthExceptionTypeDef._new(vm, null, location, this, new HassiumInt(Parameters.Count), new HassiumInt(args.Length)));
return(Null);
}
if (IsConstructor)
{
HassiumClass clazz = new HassiumClass((Parent as HassiumClass).Name);
clazz.BoundAttributes = CloneDictionary(Parent.BoundAttributes);
var parent = (Parent as HassiumClass);
clazz.DocStr = parent.DocStr;
clazz.AddType(parent.TypeDefinition);
foreach (var inherit in parent.Inherits)
{
foreach (var attrib in CloneDictionary(vm.ExecuteMethod(inherit).GetAttributes()))
{
if (!clazz.ContainsAttribute(attrib.Key))
{
attrib.Value.Parent = clazz;
clazz.BoundAttributes.Add(attrib.Key, attrib.Value);
}
}
}
foreach (var type in Parent.Types)
{
clazz.AddType(type as HassiumTypeDefinition);
}
foreach (var attrib in clazz.BoundAttributes.Values)
{
attrib.Parent = clazz;
}
vm.ExecuteMethod(clazz.BoundAttributes["new"] as HassiumMethod);
vm.PopCallStack();
vm.StackFrame.PopFrame();
return(clazz);
}
var ret = vm.ExecuteMethod(this);
if (ReturnType != null)
{
var enforcedType = vm.ExecuteMethod(ReturnType);
enforcedType = enforcedType is HassiumTypeDefinition ? enforcedType : enforcedType.Type();
if (!ret.Types.Contains(enforcedType))
{
vm.RaiseException(HassiumConversionFailedException.ConversionFailedExceptionTypeDef._new(vm, null, location, ret, enforcedType));
return(this);
}
}
if (Name != "__init__" && Name != string.Empty)
{
vm.StackFrame.PopFrame();
}
if (SourceRepresentation != string.Empty && Name != "__init__")
{
vm.PopCallStack();
}
return(ret);
}
public static void ExecuteConfig(HassiumConfig config)
{
if (config.HassiumRunType == HassiumRunType.Code)
{
try
{
VirtualMachine vm = new VirtualMachine();
var module = HassiumCompiler.CompileModuleFromFilePath(System.IO.Path.GetFullPath(config.FilePath), config.SuppressWarnings);
HassiumList hargs = new HassiumList(new HassiumObject[0]);
foreach (var arg in config.Args)
{
hargs.Values.Add(new HassiumString(arg));
}
vm.Execute(module, hargs);
}
catch (CompilerException ex)
{
Console.WriteLine(ex.Message);
if (config.Dev)
{
Console.WriteLine(ex);
}
}
catch (ParserException ex)
{
Console.WriteLine(ex.Message);
if (config.Dev)
{
Console.WriteLine(ex);
}
}
catch (ScannerException ex)
{
Console.WriteLine(ex.Message);
if (config.Dev)
{
Console.WriteLine(ex);
}
}
catch (UnhandledException ex)
{
Console.WriteLine("Unhandled Exception:");
Console.WriteLine(ex.Message);
Console.WriteLine("\nNear:");
ex.SourceLocation.PrintLocation();
Console.WriteLine(ex.CallStack);
Environment.Exit(0);
}
}
else if (config.HassiumRunType == HassiumRunType.PackageManager)
{
var mgr = new HassiumPackageManager();
bool status;
switch (config.Action.ToLower())
{
case "check":
status = mgr.CheckInstalled(config.Package);
if (status)
{
Console.WriteLine("Package '{0}' is installed! Remove it using Hassium.exe --pkg uninstall [PKGNAME]", config.Package);
}
else
{
Console.WriteLine("Package '{0}' is not installed! Install it using Hassium.exe --pkg install [PKGNAME]", config.Package);
}
break;
case "install":
status = mgr.InstallPackage(config.Package);
if (status)
{
Console.WriteLine("Successfully installed '{0}'. Include ```use * from {0}/<mod>``` to use.", config.Package);
}
else
{
Console.WriteLine("Installation failed! Is the package name correct?");
}
break;
case "uninstall":
status = mgr.UninstallPackage(config.Package);
if (status)
{
Console.WriteLine("Successfully uninstalled '{0}'.", config.Package);
}
else
{
Console.WriteLine("Uninstall failed! Is the package already uninstalled?");
}
break;
}
}
else if (config.HassiumRunType == HassiumRunType.REPL)
{
HassiumREPL.Run(config);
}
}
public static byte[] ListToByteArr(VirtualMachine vm, SourceLocation location, HassiumList list)
{
if (list is HassiumByteArray)
{
return((list as HassiumByteArray).Values.ToArray());
}
byte[] bytes = new byte[list.Values.Count];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)list.Values[i].ToChar(vm, list.Values[i], location).Char;
}
return(bytes);
}
