Ejemplo n.º 1
0
        //sets the override to directly hop to the base when called, while still remaining overridable
        //only one function per type can be IsBase
        private void DirectiveIsBase(string val, IBaseFunction func)
        {
            val = val.Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
            bool value = (val == "true" || val == "True") ? true : false;

            if (value)
            {
                var samelist = FunctionStack.Where(func.Name).ToList();
                foreach (var x in samelist)
                {
                    //check to make sure this is the only IsBase directive of this type
                    if (x.UID != func.UID && x.Directives != null && x.Directives.ContainsKey("IsBase"))
                    {
                        var stripws = x.Directives["IsBase"].Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
                        if (stripws == "true" || stripws == "True")
                        {
                            Compiler.ExceptionListener.Throw($"The function [{func.Name}] has already been set IsBase by a directive. Please remove an IsBase directive.");
                        }
                    }
                }
                if (FunctionStack.Contains(func))
                {
                    FunctionStack.First(func.UID).SetBase(samelist[samelist.Count - 1]);
                }
            }
        }
Ejemplo n.º 2
0
        //i guess a quick way to essentially deep clone base functions on demand.
        //idk how much this will kill performance but i cant think of another way
        public static IBaseFunction CopyFunctionReference(string funcName)
        {
            IBaseFunction temp      = null;
            string        definedIn = typeof(Function).Assembly.GetName().Name;

            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                if ((!assembly.GlobalAssemblyCache) && ((assembly.GetName().Name == definedIn) || assembly.GetReferencedAssemblies().Any(a => a.Name == definedIn)))
                {
                    foreach (System.Type type in assembly.GetTypes())
                    {
                        if (type.GetCustomAttributes(typeof(Function), true).Length > 0)
                        {
                            var attt = type.GetCustomAttribute(typeof(Function), true) as Function;
                            if (attt.Name == funcName)
                            {
                                var func = System.Type.GetType(type.ToString());
                                var inst = Activator.CreateInstance(func) as IBaseFunction;
                                inst.SetProperties(attt.Name, attt.ExpectedArgs, attt.Invoking, attt.Sealed, attt.Obsolete, attt.Alias, attt.IsAnonymous);
                                if (!attt.Depricated)
                                {
                                    temp = (inst);
                                }
                            }
                        }
                    }
                }
            }
            return(temp);
        }
Ejemplo n.º 3
0
        //public TFunction Token { get; private set; }

        public Line(string val, IBaseFunction reference)
        {
            Compiler.ExceptionListener.SetCurrentLine(val);
            Value      = val;
            _reference = reference;
            //Token =
            WalkTree(val);
        }
Ejemplo n.º 4
0
 public void SetBase(IBaseFunction func)
 {
     if (func.Sealed)
     {
         Compiler.ExceptionListener.Throw(
             $"Cannot override function [{func.Name}] because it is sealed.");
     }
     Base = func;
 }
Ejemplo n.º 5
0
        public static void AnalyzeScreen(string success, IBaseFunction successAction, IBaseFunction failureAction, string[] prop, TFunction caller = null)
        {
            var tfunc = new TFunction(caller.Function, new List <EDefinition>(), string.Join(",", caller.Function.GetInvokeProperties()), caller.CallingFunction);

            try
            {
                bool   finished = false;
                bool   func     = false;
                Thread th       = new Thread(() =>
                {
                    AnalyzeScreen ascreen = new AnalyzeScreen();
                    ascreen.Analyze(success.UnCleanString(),
                                    () => { finished = true; func = true; },
                                    () => { finished = true; },
                                    prop
                                    );
                });
                th.Start();
                Stopwatch watch = new Stopwatch();
                watch.Start();
                while (finished == false)
                {
                    if (TokenParser.Stop)
                    {
                        break;
                    }
                    Thread.Sleep(1000); //sleep for 1 second before checking again
                                        //if 30 seconds go by, then break and kill the thread
                    if (watch.Elapsed.TotalMilliseconds >= 45000)
                    {
                        Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler(ExceptionType.SystemException,
                                                                                    $"CheckScreen() timed out."));
                        //smash the thread and move on. we dont care about that data anyway
                        try { th.Abort(); } catch (Exception e) { if (!(e is ThreadAbortException))
                                                                  {
                                                                      throw;
                                                                  }
                        }
                        break;
                    }
                }
                watch.Stop();
                if (func)
                {
                    successAction.TryParse(tfunc);
                }
                else
                {
                    failureAction.TryParse(tfunc);
                }
            }
            catch
            {
                Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler("[63]Image check failed to execute. Continuing with failure function"));
                failureAction.TryParse(tfunc);
            }
        }
Ejemplo n.º 6
0
        public override string[] Extend(IBaseFunction input)
        {
            List <string> temp = new List <string>();

            temp.Add(input.Name);
            temp.AddRange(base.Extend());
            FunctionReference.TryParse(new TFunction(FunctionReference, null, temp.ToArray(), null));
            return(Execute(FunctionReference.ReturnBubble.ToString()));
        }
Ejemplo n.º 7
0
        private void DirectiveOmit(string val, IBaseFunction func)
        {
            val = val.Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
            bool value = (val == "true" || val == "True") ? true : false;

            if (value)
            {
                if (FunctionStack.Contains(func))
                {
                    FunctionStack.Remove(func);
                }
            }
        }
Ejemplo n.º 8
0
        private void DirectiveLayer(string val, IBaseFunction func)
        {
            int  index  = 0;
            bool tryint = int.TryParse(val, out index);

            if (!tryint)
            {
                Compiler.ExceptionListener.Throw($"The directive [Layer] must have a whole number as its value.");
            }
            if (index - 1 > FunctionStack.List.Count)
            {
                index = FunctionStack.List.Count - 1;
            }
            FunctionStack.MoveTo(func, index);
            //apply any override to base connections needed since the stack was shuffled
            var samelist = FunctionStack.Where(func.Name).ToList();

            for (var i = 0; i < samelist.Count; i++)
            {
                var obj = samelist[i];
                if (!obj.Override)
                {
                    continue;
                }
                if (i == samelist.Count - 1)
                {
                    continue;
                }
                IBaseFunction next = null;
                for (var nexti = i; nexti <= samelist.Count - i; nexti++)
                {
                    if (samelist.ElementAtOrDefault(nexti) == null)
                    {
                        continue;
                    }
                    else
                    {
                        next = samelist[nexti];
                        break;
                    }
                }
                if (next == null)
                {
                    Compiler.ExceptionListener.Throw($"Unknown error applying directive [Layer] on function [{func.Name}]");
                }
                obj.SetBase(next);
            }
        }
Ejemplo n.º 9
0
        //this constructor is when function is anonomysly named
        public AnonymousFunction(string value, bool anon, IBaseFunction callerBase) : this()
        {
            Base        = callerBase;
            IsAnonymous = true;
            //get top level anonymous functions before everything else
            value = value.Substring(1);
            var anonRegex        = new Regex(Compiler.ScopeRegex(@"=>"), RegexOptions.IgnorePatternWhitespace);
            var anonRegexMatches = anonRegex.Matches(value);

            foreach (var a in anonRegexMatches)
            {
                var func = new AnonymousFunction(a.ToString(), true, _base);
                FunctionStack.Add(func);
                value = value.Replace(a.ToString(), $"\"{func.Name}\"");
            }
            Value        = value;
            Name         = "AnonymousFunction" + Compiler.AnonymousFunctionIndex;
            ExpectedArgs = value.Split('(')[1].Split(')')[0].Split(',');
            ParseDirectives(value);
            //Name = value.Split('.')[1].Split('(')[0];
        }
Ejemplo n.º 10
0
        }/// <summary>

        /// callingFunction is the function that is calling(usually `this`), func is the function being called
        /// </summary>
        /// <param name="func"></param>
        /// <param name="ext"></param>
        /// <param name="args"></param>
        /// <param name="callingFunction"></param>
        public TFunction(IBaseFunction func, List <EDefinition> ext, string[] args, IBaseFunction callingFunction, LoopTracer t = null)
        {
            Name            = func.Name;
            Function        = func;
            _value          = "[Type.TFunction]";
            Extensions      = ext;
            Arguments       = args;
            CallingFunction = callingFunction;
            if (t != null)
            {
                Tracer = t;
            }
            else
            if (callingFunction != null)
            {
                Tracer = callingFunction.Tracer;
            }
            else
            {
                Tracer = null;
            }
        }
Ejemplo n.º 11
0
        //seals the function so no more overrides can occur
        private void DirectiveSealed(string val, IBaseFunction func)
        {
            val = val.Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
            bool value = (val == "true" || val == "True") ? true : false;

            if (value)
            {
                //FunctionStack.MoveTo(func, 0);
                var samelist = FunctionStack.Where(func.Name).ToList();
                foreach (var x in samelist)
                {
                    if (x.UID != func.UID && x.Directives != null && x.Directives.ContainsKey("Sealed"))
                    {
                        var stripws = x.Directives["Sealed"].Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
                        if (stripws == "true" || stripws == "True")
                        {
                            Compiler.ExceptionListener.Throw($"The function [{func.Name}] has already been sealed by a directive. Please remove a Sealed directive.");
                        }
                    }
                }
                func.SetSealed(value);
            }
        }
Ejemplo n.º 12
0
 internal TryCatchEvent(IBaseFunction tryblock, IBaseFunction catchblock)
 {
     TryBlock   = tryblock;
     CatchBlock = catchblock;
 }
Ejemplo n.º 13
0
 public virtual string[] Extend(IBaseFunction input)
 {
     ObsoleteWarning();
     Compiler.ExceptionListener.Throw("[51]Unexpected error occured.");
     return(null);
 }
Ejemplo n.º 14
0
 private void DirectiveMinVer(string val, IBaseFunction func)
 {
     val = val.Replace(" ", "").Replace("\n", "").Replace("\t", "").Replace("\r", "");
     string[] splode = val.Split(',');
     if (splode[0] == "soft")
     {
         var maj   = splode.ElementAtOrDefault(1);
         var min   = splode.ElementAtOrDefault(2);
         var build = splode.ElementAtOrDefault(3);
         var rev   = splode.ElementAtOrDefault(4);
         if (maj == null)
         {
             Compiler.ExceptionListener.Throw("MinVer Directive must express a major version");
         }
         string[] ver      = Assembly.GetExecutingAssembly().GetName().Version.ToString().Split('.');
         int      majint   = -1;
         int      minint   = -1;
         int      buildint = -1;
         int      revint   = -1;
         int.TryParse(maj, out majint);
         if (min != null)
         {
             int.TryParse(min, out minint);
         }
         if (build != null)
         {
             int.TryParse(build, out buildint);
         }
         if (rev != null)
         {
             int.TryParse(rev, out revint);
         }
         if (majint == -1)
         {
             Compiler.ExceptionListener.Throw("MinVer Directive must express a major version as a number");
         }
         if (int.Parse(ver[0]) < majint)
         {
             Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Major version [{majint}]."));
             if (FunctionStack.Contains(func))
             {
                 FunctionStack.Remove(func);
             }
             return;
         }
         if (minint != -1 && int.Parse(ver[1]) < minint)
         {
             Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Minor version [{minint}]."));
             if (FunctionStack.Contains(func))
             {
                 FunctionStack.Remove(func);
             }
             return;
         }
         if (buildint != -1 && int.Parse(ver[2]) < buildint)
         {
             Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Build version [{buildint}]."));
             if (FunctionStack.Contains(func))
             {
                 FunctionStack.Remove(func);
             }
             return;
         }
         if (revint != -1 && int.Parse(ver[3]) < revint)
         {
             Compiler.ExceptionListener.ThrowSilent(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Revision version [{revint}]."));
             if (FunctionStack.Contains(func))
             {
                 FunctionStack.Remove(func);
             }
             return;
         }
     }
     else
     {
         var maj   = splode.ElementAtOrDefault(0);
         var min   = splode.ElementAtOrDefault(1);
         var build = splode.ElementAtOrDefault(2);
         var rev   = splode.ElementAtOrDefault(3);
         if (maj == null)
         {
             Compiler.ExceptionListener.Throw("MinVer Directive must express a major version");
         }
         string[] ver      = Assembly.GetExecutingAssembly().GetName().Version.ToString().Split('.');
         int      majint   = -1;
         int      minint   = -1;
         int      buildint = -1;
         int      revint   = -1;
         int.TryParse(maj, out majint);
         if (min != null)
         {
             int.TryParse(min, out minint);
         }
         if (build != null)
         {
             int.TryParse(build, out buildint);
         }
         if (rev != null)
         {
             int.TryParse(rev, out revint);
         }
         if (majint == -1)
         {
             Compiler.ExceptionListener.Throw("MinVer Directive must express a major version as a number");
         }
         if (int.Parse(ver[0]) < majint)
         {
             Compiler.ExceptionListener.Throw(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Major version [{majint}]."));
         }
         if (minint != -1 && int.Parse(ver[1]) < minint)
         {
             Compiler.ExceptionListener.Throw(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Minor version [{minint}]."));
         }
         if (buildint != -1 && int.Parse(ver[2]) < buildint)
         {
             Compiler.ExceptionListener.Throw(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Build version [{buildint}]."));
         }
         if (revint != -1 && int.Parse(ver[3]) < revint)
         {
             Compiler.ExceptionListener.Throw(new ExceptionHandler($"Function [{func.Name}] did not pass minimum version directive. Expected Revision version [{revint}]."));
         }
     }
 }