Updated Interpreter. I've been adding a lot. It's basically done

Author: JBrosDevelopment

EZCode/Interpreter.cs

@@ -1,5 +1,5 @@
-using System.Linq;
-using System.Reflection;
+using System.Reflection;
+using System.Runtime.Loader;
 using static EZCodeLanguage.Parser;
 
 namespace EZCodeLanguage
@@ -103,9 +103,9 @@ public Interpreter(Parser parser, Debug.Breakpoint[]? breakpoints = null)
         private object? returned = null;
         private DataType? Returning = null;
         private int StackNumber = 0;
+        internal bool hasexited = false;
+        public CustomAssemblyLoadContext[] LoadedAssemblies = [];
         public Stack<string> StackTrace { get; private set; }
-        internal record Library(string name, string[] files);
-        internal List<Library> DllLibraries { get; set; } = [];
         public Exception[] Errors { get; private set; } = [];
         public Var[] Vars { get; set; } = [];
         public Method[] Methods { get; set; } = [];
@@ -123,6 +123,12 @@ public void Interperate(LineWithTokens[] LineTokens)
             if (Methods.Any(x => x.Name.ToLower() == "start") && !StartMethodEntry)
             {
                 StartMethodEntry = true;
+                LineWithTokens[] lines_with_include = LineTokens.Where(x => x.Tokens.Length > 1).Where(x => x.Tokens[0].Type == TokenType.Include).ToArray();
+                LineWithTokens[] lines_with_exclude = LineTokens.Where(x => x.Tokens.Length > 1).Where(x => x.Tokens[0].Type == TokenType.Exclude).ToArray();
+                if (lines_with_include.Length > 0)
+                    Interperate(lines_with_include);
+                if (lines_with_exclude.Length > 0)
+                    Interperate(lines_with_exclude);
                 LineWithTokens[] lines_with_global = LineTokens.Where(x => x.Tokens.Length > 1).Where(x => x.Tokens[0].Type == TokenType.Global).ToArray();
                 if (lines_with_global.Length > 0)
                     Interperate(lines_with_global);
@@ -131,8 +137,9 @@ public void Interperate(LineWithTokens[] LineTokens)
             }
             else
             {
-                foreach (LineWithTokens line in LineTokens)
+                foreach (LineWithTokens line in LineTokens) 
                 {
+                    if (hasexited) break;
                     if (line.Tokens.Length == 0 || (line.Tokens.Length == 1 && line.Tokens[0].Value is Class or Method))
                         continue;
 
@@ -158,6 +165,18 @@ public void Interperate(LineWithTokens[] LineTokens)
                 }
             }
 
+            // Unload each assembly
+            foreach (var assembly in LoadedAssemblies)
+            {
+                assembly.Unload();
+            }
+            // Let the garbage collector collect to ensure assemblies are fully unloaded
+            for (int i = 0; i < 3; i++)
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            }
+            // Exclude every package
             Package.RemoveAllPackagesFromExecutionDirectory(AppDomain.CurrentDomain.BaseDirectory);
         }
         internal object? SingleLine(LineWithTokens line)
@@ -187,29 +206,24 @@ public void Interperate(LineWithTokens[] LineTokens)
                             string combined_packages = string.Join(" ", line.Tokens.Skip(1).Select(x => x.StringValue));
                             string[] packages = combined_packages.Split(",").Select(x=>x.Trim()).ToArray();
                             Project[] projects = new Project[packages.Length];
+                            bool include = FirstToken.StringValue == "include";
 
                             for (int i = 0; i < packages.Length; i++)
                                 projects[i] = Package.GetPackageAsProject(packages[i]);
 
-                            if (projects.Any(x => !string.IsNullOrEmpty(x.LibraryDirectory)))
+                            if (projects.Any(x => !string.IsNullOrEmpty(x.Configuration?.LibraryDirectory)))
                             {
                                 string destination = AppDomain.CurrentDomain.BaseDirectory;
                                 foreach (var project in projects)
                                 {
-                                    if (FirstToken.StringValue == "include")
-                                    {
-                                        Package.AddPackageToExecutionDirectory(project, destination, out var files);
-                                        DllLibraries.Add(new Library(project.Name, files));
-                                    }
+                                    if (include)
+                                        Package.AddPackageToExecutionDirectory(project, destination);
                                     else
-                                    {
-                                        var library = DllLibraries.FirstOrDefault(x => x.name == project.Name);
-                                        Package.RemovePackageFromExecutionDirectory(library.files);
-                                    }
+                                        Package.RemovePackageFromExecutionDirectory(project, destination);
                                 }
                             }
 
-                            if (FirstToken.StringValue == "include")
+                            if (include)
                             {
                                 parser = Package.ReturnParserWithPackages(parser, packages);
                                 Methods = [.. Methods, .. parser.Methods];
@@ -429,7 +443,10 @@ public void Interperate(LineWithTokens[] LineTokens)
                                         break;
 
                                     case IdentType.Method:
-                                        Method method = (type is Method m) ? new Method(m.Name, m.Line, m.Settings, m.Lines.Select(x => new LineWithTokens(x.Tokens.Select(y => new Token(y.Type, y.Value, y.StringValue)).ToArray(), x.Line)).ToArray(), m.Parameters, m.Returns) : null;
+                                        Method method = (type is Method m) ?
+                                            new Method(m.Name, m.Line, m.Settings, m.Lines.Select(
+                                                x => new LineWithTokens(x.Tokens.Select(y => new Token(
+                                                    y.Type, y.Value, y.StringValue)).ToArray(), x.Line)).ToArray(), m.Parameters, m.Returns)! : new Method();
 
                                         Method.MethodSettings settings = method.Settings;
                                         bool nocol = (settings & Method.MethodSettings.NoCol) != 0;
@@ -571,6 +588,20 @@ public void Interperate(LineWithTokens[] LineTokens)
                             throw new Exception($"Error with \"undefined\", Error Message:\"{ex.Message}\"");
                         }
                         break;
+                    case TokenType.Throw:
+                        string err_message = "";
+                        try
+                        {
+                            line.Tokens = line.Tokens.Skip(1).Prepend(new Token(TokenType.Return, "return", "return")).ToArray();
+                            err_message = SingleLine(line).ToString();
+                        }
+                        catch (Exception ex)
+                        {
+                            throw new Exception($"Error with \"throw\", Error Message:\"{ex.Message}\"");
+                        }
+                        if (err_message != "")
+                            throw new Exception(err_message);
+                        break;
                     case TokenType.Return:
                         try
                         {
@@ -797,6 +828,7 @@ public void Interperate(LineWithTokens[] LineTokens)
             {
                 result = SingleLine(new LineWithTokens(line));
 
+                if (hasexited) break;
                 if (yielded)
                 {
                     yielded = false;
@@ -930,6 +962,7 @@ private IdentType IsType(string token, out object? type)
             {
                 result = SingleLine(line);
 
+                if (hasexited) break;
                 if (line.Tokens.Length > 0 && line.Tokens[0].Type == TokenType.Return || returned != null)
                     break;
             }
@@ -1297,32 +1330,39 @@ public object Reflect(CSharpMethod method)
                 method = o[0] as CSharpMethod;
             }
 
-            return InvokeMethod(method.Path, method.Params != null ? method.Params.Select(x => x).ToArray() : [], EZHelp);
+            object val = InvokeMethod(method.Path, method.Params != null ? method.Params.Select(x => x).ToArray() : [], EZHelp, out var assembly);
+            LoadedAssemblies = LoadedAssemblies.Append(assembly).Where(x => x != null).Distinct().ToArray();
+
+            return val;
         }
-        public static object? InvokeMethod(string methodPath, object[] parameters, EZHelp e)
+        public static object? InvokeMethod(string methodPath, object[] parameters, EZHelp e, out CustomAssemblyLoadContext? assemblyContext)
         {
+            assemblyContext = null;
             // Split the method files into type and method name
             string[] pathParts = methodPath.Split('.');
             if (pathParts.Length < 2)
             {
                 throw new ArgumentException("Invalid method path");
             }
-
             if (pathParts.Length >= 2 && pathParts[1].Equals("dll"))
             {
-                // If the method files contains an assembly name, load the assembly
+                // If the method path contains an assemblyContext name, load the assemblyContext
                 string assemblyPath = pathParts[0] + "." + pathParts[1];
-                string subdirectory = Package.LibraryDirName; // Name of the subdirectory is first part of namespace
-                string fullAssemblyPath = Path.Combine(subdirectory, assemblyPath); // Combine subdirectory files with assembly name
-                Assembly assembly = Assembly.LoadFrom(fullAssemblyPath);
+                string subdirectory = pathParts[0]; // Name of the subdirectory is first part of namespace
+                string relativeAssemblyPath = Path.Combine(subdirectory, assemblyPath); // Combine subdirectory path with assemblyContext name
+                string fullAssemblyPath = Path.GetFullPath(relativeAssemblyPath); // Get the absolute path of the assembly
+
+                // Get Assemblies
+                assemblyContext = new CustomAssemblyLoadContext();
+                Assembly assembly = assemblyContext.LoadFromAssemblyPath(fullAssemblyPath);
 
                 // Get the type name
                 string typeName = string.Join(".", pathParts.Skip(2).Take(pathParts.Length - 3));
-
+                
                 // Get the method name
                 string methodName = pathParts.Last();
 
-                // Get the type from the assembly
+                // Get the type from the assemblyContext
                 Type type = assembly.GetType(typeName);
                 if (type == null)
                 {
@@ -1357,7 +1397,7 @@ public object Reflect(CSharpMethod method)
             {
                 // Get the type from the full type name
                 string typeName = string.Join(".", pathParts.Take(pathParts.Length - 1));
-                // Include the assembly information for types in the System namespace
+                // Include the assemblyContext information for types in the System namespace
                 if (typeName.StartsWith("System."))
                 {
                     typeName += ", mscorlib";
@@ -1405,5 +1445,17 @@ public object Reflect(CSharpMethod method)
                 }
             }
         }
+        public class CustomAssemblyLoadContext : AssemblyLoadContext
+        {
+            public CustomAssemblyLoadContext() : base(isCollectible: true)
+            {
+            }
+
+            protected override Assembly Load(AssemblyName assemblyName)
+            {
+                // Implement if needed: load dependencies, etc.
+                return null;
+            }
+        }
     }
 }

EZCode/Parser.cs

@@ -419,7 +419,8 @@ public enum TokenType
             Exclude,
             Global,
             True, 
-            False
+            False,
+            Throw
         }
         public static char[] Delimeters = [' ', '{', '}', '@', ':', ',', '?', '!'];
         public string Code { get; set; }
@@ -428,12 +429,23 @@ public enum TokenType
         public List<Class> Classes = [];
         public List<Method> Methods = [];
         public LineWithTokens[] LinesWithTokens = [];
+        private Parser[] IncludingExcludingPackages = [];
         public Parser(string code, string file)
         {
             Code = code;
             FilePath = file;
         }
-        public LineWithTokens[] Parse() => LinesWithTokens = TokenArray(Code, FilePath).Where(x => x.Line.Value.ToString() != "").ToArray();
+        public LineWithTokens[] Parse()
+        {
+            var parse = LinesWithTokens = TokenArray(Code, FilePath).Where(x => x.Line.Value.ToString() != "").ToArray();
+
+            foreach (var remove in IncludingExcludingPackages)
+            {
+                Package.RemovePackageFromParser(this, remove);
+            }
+
+            return parse;
+        }
         private LineWithTokens[] TokenArray(string code, string file, bool insideClass = false)
         {
             // Set the file files property
@@ -472,6 +484,14 @@ private LineWithTokens[] TokenArray(string code, string file, bool insideClass =
                         string combined_packages = string.Join(" ", parts.Skip(1).Select(x => x.ToString()));
                         string[] packages = combined_packages.Split(",").Select(x => x.Trim()).ToArray();
                         Parser parser = Package.ReturnParserWithPackages(this, packages);
+                        IncludingExcludingPackages = [.. IncludingExcludingPackages, new Parser(parser.Code, parser.FilePath) 
+                        { 
+                            Methods = parser.Methods.Select(x=> new Method(x.Name, x.Line, x.Settings, x.Lines, x.Parameters, x.Returns)).ToList(), 
+                            Classes = parser.Classes.Select(x=> new Class(x.Name, x.Line, x.Methods, x.Properties, x.WatchFormat, x.Params, x.TypeOf, x.GetTypes, x.Classes, x.Length, x.Aliases)).ToList(), 
+                            commentBlock = parser.commentBlock,
+                            IncludingExcludingPackages = parser.IncludingExcludingPackages,
+                            LinesWithTokens = parser.LinesWithTokens 
+                        }];
                     }
                     if (parts.Length > 1 && parts[0].ToString() == "exclude")
                     {
@@ -481,6 +501,7 @@ private LineWithTokens[] TokenArray(string code, string file, bool insideClass =
                         Parser except = Package.ReturnParserWithPackages(new Parser("", ""), packages);
                         // remove the except parser from the current parser instance
                         Parser parser = Package.RemovePackageFromParser(this, except);
+                        IncludingExcludingPackages = IncludingExcludingPackages.Except([parser]).ToArray();
                     }
 
                     // loops through each part and creates the token from it
@@ -549,6 +570,7 @@ internal Token SingleToken(object[] parts, int partIndex, string stringPart)
                     case "null": tokenType = TokenType.Null; parts[partIndex] = ""; break;
                     case "include": tokenType = TokenType.Include; break;
                     case "exclude": tokenType = TokenType.Exclude; break;
+                    case "throw": tokenType = TokenType.Throw; break;
                 }
                 if (part.StartsWith("//")) tokenType = TokenType.Comment; // If the part starts with '//', it is comment
                 if (part.StartsWith('@')) tokenType = TokenType.DataType; // If the part starts with '@', it is a datatype
@@ -646,6 +668,17 @@ This keeps loop from skipping index */
                             return parts.Take(i).ToArray();
                         }
                     }
+                    else if (parts[i].ToString() == "!" && parts.Length > i + 1 && parts[i + 1].ToString() == "=")
+                    {
+                        /* if the current part is '!' and the next token is '=', combine the 
+                         * parts into a single token. */
+
+                        // turn the current part into both parts
+                        parts[i] = "!=";
+                        // remove the next part
+                        parts = parts.ToList().Where((item, index) => index != i + 1).ToArray();
+
+                    }
                     else if (parts[i].ToString() == "@")
                     {
                         // append the next part to the current part

EZCode/Project.cs

@@ -5,10 +5,9 @@ public class Project
         public string Name { get; set; }
         public string[] Files { get; set; }
         public Config? Configuration { get; set; }
-        public string? LibraryDirectory { get; set; }
-
         public class Config
         {
+            public string? LibraryDirectory { get; set; }
             public string[]? GlobalPackages { get; set; }
         }
     }

TestEnv/Code.ezcode

@@ -1,4 +1,5 @@
-include main
+include main, time
 
-bool match new => regexmatch : hello, hi|hello
-print 'match'
+method start {
+	print 'time current'
+}