コード例 #1
0
        public DelegateDeclaration(TypeContainer parent, FullNamedExpression type, Modifiers mod_flags, MemberName name, ParametersCompiled param_list,
                                   VSharpAttributes attrs, CompilationSourceFile file)
            : base(parent, mod_flags | Modifiers.SEALED, AllowedModifiers, name, attrs, name.Location, TypeKind.Delegate, file)

        {
            BaseTypes.Add(KnownTypeReference.MulticastDelegate);
            this.ReturnType = type;
            parameters      = param_list;
            List <IUnresolvedParameter> uparameters = new List <IUnresolvedParameter>();

            foreach (Parameter p in param_list.parameters)
            {
                uparameters.Add(p);
            }


            AddDefaultMethodsToDelegate(type as ITypeReference, uparameters);


            if (attrs != null)
            {
                IUnresolvedMethod invokeMethod = (IUnresolvedMethod)Members.Single(m => m.Name == "Invoke");
                foreach (IUnresolvedAttribute attr in attrs.Attrs.Where(x => x.ExplicitTarget == "ret").ToList())
                {
                    invokeMethod.ReturnTypeAttributes.Add(attr);
                }
            }
        }
コード例 #2
0
 /// <include file='doc\CodeTypeDelegate.uex' path='docs/doc[@for="CodeTypeDelegate.CodeTypeDelegate"]/*' />
 /// <devdoc>
 ///    <para>
 ///       Initializes a new instance of <see cref='System.CodeDom.CodeTypeDelegate'/>.
 ///    </para>
 /// </devdoc>
 public CodeTypeDelegate()
 {
     TypeAttributes &= ~TypeAttributes.ClassSemanticsMask;
     TypeAttributes |= TypeAttributes.Class;
     BaseTypes.Clear();
     BaseTypes.Add(new CodeTypeReference("System.Delegate"));
 }
コード例 #3
0
        public FakeClass AddBaseClass(string name)
        {
            var baseClass  = new FakeClass(name);
            var returnType = new DefaultReturnType(baseClass);

            BaseTypes.Add(returnType);
            return(baseClass);
        }
コード例 #4
0
ファイル: KittyHighNIL.cs プロジェクト: freezernick/kitty
        public KittyHighNIL()
        {
            // Not complete yet, but for now this will do!
            BaseTypes.Add("table");
            BaseTypes.Add("void");
            BaseTypes.Add("string");
            BaseTypes.Add("int");
            BaseTypes.Add("bool");
            BaseTypes.Add("var");
            KeyWords.Add("not");
            KeyWords.Add("class");
            KeyWords.Add("group");
            KeyWords.Add("module");
            KeyWords.Add("global");
            KeyWords.Add("private");
            KeyWords.Add("end");
            KeyWords.Add("and");
            KeyWords.Add("or");
            KeyWords.Add("quickmeta");
            KeyWords.Add("switch");
            KeyWords.Add("case");
            KeyWords.Add("default");
            // KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("else");
            KeyWords.Add("elseif");
            KeyWords.Add("do");
            KeyWords.Add("while");
            KeyWords.Add("true");
            KeyWords.Add("false");
            KeyWords.Add("abstract");
            KeyWords.Add("override");
            KeyWords.Add("self");
            KeyWords.Add("get");
            KeyWords.Add("set");
            KeyWords.Add("try");
            KeyWords.Add("catch");
            KeyWords.Add("finally");
            KeyWords.Add("static");
            KeyWords.Add("return");
            KeyWords.Add("for");
            KeyWords.Add("in");
            KeyWords.Add("delegate");
            KeyWords.Add("readonly");
            KeyWords.Add("new");
            KeyWords.Add("break");
            KeyWords.Add("nil");
            KeyWords.Add("extends");

            KeyWords.Add("CONSTRUCTOR");
            KeyWords.Add("DESTRUCTOR");

            //KeyWords.Add("foreach");
            Langs["nil"] = this;
            Language     = "NIL isn't Lua";
        }
コード例 #5
0
 protected virtual void OnPopulateBaseTypes(object sender, EventArgs e)
 {
     if (!string.IsNullOrEmpty(LinqSettings.BaseContext))
     {
         BaseTypes.Add(LinqSettings.BaseContext);
     }
     else
     {
         BaseTypes.Add(new CodeTypeReference("Worm.Linq.WormLinqContext"));
     }
 }
コード例 #6
0
ファイル: TypeContainer.cs プロジェクト: Arsslensoft/VSharp
 public virtual void SetBaseTypes(FullNamedExpression texpr)
 {
     if (texpr is TypeNameExpression)
     {
         var te = texpr as TypeNameExpression;
         te.lookupMode = NameLookupMode.BaseTypeReference;
         BaseTypes.Add(te);
     }
     else
     {
         BaseTypes.Add(texpr as ITypeReference);
     }
 }
コード例 #7
0
        public void AddActivity(Activity input)
        {
            var path = ((Activity)input).GetPrivateMethodValue <string>("get_DottedPath");

            bool isRoot = (input.Parent == null) || (path.Contains(".") == false);

            if (isRoot)
            {
                ActivityTree.Add(new ActivityWrapper(input, path));
            }
            else
            {
                UnresolvedActivities.Add(new ActivityWrapper(input, path));
            }

            #region Populate Base and Declaration List
            lock (this)
            {
                string fullName = input.GetType().FullName;
                if (DeclarationTypes.Contains(fullName) == false)
                {
                    lock (this)
                    {
                        fullName = input.GetType().FullName;

                        if (DeclarationTypes.Contains(fullName) == false)
                        {
                            DeclarationTypes.Add(fullName);
                        }
                    }
                }
            }

            lock (this)
            {
                string baseTypeName = input.GetType().BaseType.FullName;
                if (BaseTypes.Contains(baseTypeName) == false)
                {
                    lock (this)
                    {
                        baseTypeName = input.GetType().BaseType.FullName;

                        if (BaseTypes.Contains(baseTypeName) == false)
                        {
                            BaseTypes.Add(baseTypeName);
                        }
                    }
                }
            }
            #endregion
        }
コード例 #8
0
 protected internal void EnsureData()
 {
     base.Name = Name;
     if (Entity != null && Entity.BaseEntity != null && Entity.BaseEntity.AutoInterface)
     {
         if (m_baseInterfaceTypeReference != null)
         {
             BaseTypes.Remove(m_baseInterfaceTypeReference);
         }
         m_baseInterfaceTypeReference =
             new CodeTypeReference(new WXMLCodeDomGeneratorNameHelper(_settings).GetEntityInterfaceName(Entity.BaseEntity, NamePrefix, NameSuffix, true));
         BaseTypes.Add(m_baseInterfaceTypeReference);
     }
 }
コード例 #9
0
ファイル: KittyHighCS.cs プロジェクト: DragonBaronDev/kitty
        public KittyHighCS()
        {
            // Not complete yet, but for now this will do!
            BaseTypes.Add("void");
            BaseTypes.Add("int");
            BaseTypes.Add("using");
            BaseTypes.Add("char");
            BaseTypes.Add("bool");
            BaseTypes.Add("delegate");
            BaseTypes.Add("long");
            KeyWords.Add("namespace");
            KeyWords.Add("class");
            KeyWords.Add("struct");
            KeyWords.Add("public");
            KeyWords.Add("private");
            KeyWords.Add("protected");
            KeyWords.Add("internal");
            KeyWords.Add("string");
            KeyWords.Add("switch");
            KeyWords.Add("case");
            KeyWords.Add("default");
            KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("else");
            KeyWords.Add("do");
            KeyWords.Add("while");
            KeyWords.Add("true");
            KeyWords.Add("false");
            KeyWords.Add("abstract");
            KeyWords.Add("override");
            KeyWords.Add("this");
            KeyWords.Add("get");
            KeyWords.Add("set");
            KeyWords.Add("try");
            KeyWords.Add("catch");
            KeyWords.Add("finally");
            KeyWords.Add("static");
            KeyWords.Add("return");
            KeyWords.Add("for");
            KeyWords.Add("in");
            KeyWords.Add("foreach");
            KeyWords.Add("readonly");
            KeyWords.Add("new");
            KeyWords.Add("break");
            KeyWords.Add("null");

            Langs["cs"] = this;
            Language    = "C#";
        }
コード例 #10
0
        static TypeEditor()
        {
            AllTypes.Add(typeof(UnityEngine.Object), new ObjectType());

            BaseTypes.Add(typeof(int).FullName, new IntType());
            BaseTypes.Add(typeof(uint).FullName, new UIntType());
            BaseTypes.Add(typeof(sbyte).FullName, new sByteType());
            BaseTypes.Add(typeof(byte).FullName, new ByteType());
            BaseTypes.Add(typeof(char).FullName, new CharType());
            BaseTypes.Add(typeof(short).FullName, new ShortType());
            BaseTypes.Add(typeof(ushort).FullName, new UShortType());
            BaseTypes.Add(typeof(long).FullName, new LongType());
            BaseTypes.Add(typeof(ulong).FullName, new ULongType());
            BaseTypes.Add(typeof(float).FullName, new FloatType());
            BaseTypes.Add(typeof(double).FullName, new DoubleType());
            BaseTypes.Add(typeof(string).FullName, new StrType());
        }
コード例 #11
0
        public KittyHighGo()
        {
            Langs["go"] = this;
            Language    = "Go";
            KeyWords.Add("break");
            KeyWords.Add("default");
            KeyWords.Add("func");
            KeyWords.Add("interface");
            KeyWords.Add("select");
            KeyWords.Add("case");
            KeyWords.Add("defer");
            KeyWords.Add("go");
            KeyWords.Add("map");
            KeyWords.Add("struct");
            KeyWords.Add("chan");
            KeyWords.Add("else");
            KeyWords.Add("goto");
            KeyWords.Add("package");
            KeyWords.Add("switch");
            KeyWords.Add("const");
            KeyWords.Add("fallthrough");
            KeyWords.Add("if");
            KeyWords.Add("range");
            KeyWords.Add("type");
            KeyWords.Add("continue");
            KeyWords.Add("for");
            KeyWords.Add("import");
            KeyWords.Add("return");
            KeyWords.Add("var");

            BaseTypes.Add("string");
            BaseTypes.Add("int");
            BaseTypes.Add("int32");
            BaseTypes.Add("int64");
            BaseTypes.Add("map");
            BaseTypes.Add("array");
        }
コード例 #12
0
        /// <summary>
        /// Adds the named base type to the class.
        /// </summary>
        void AddBaseType(string name)
        {
            IReturnType returnType = CreateSearchClassReturnType(name);

            BaseTypes.Add(returnType);
        }
コード例 #13
0
ファイル: ReflectionClass.cs プロジェクト: VE-2016/VE-2016
        public ReflectionClass(ICompilationUnit compilationUnit, Type type, string fullName, IClass declaringType) : base(compilationUnit, declaringType)
        {
            if (fullName.Length > 2 && fullName[fullName.Length - 2] == '`')
            {
                FullyQualifiedName = fullName.Substring(0, fullName.Length - 2);
            }
            else
            {
                FullyQualifiedName = fullName;
            }

            this.UseInheritanceCache = true;

            try
            {
                AddAttributes(compilationUnit.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(type));
            }
            catch (Exception ex)
            {
                HostCallback.ShowError("Error reading custom attributes", ex);
            }

            // set classtype
            if (type.IsInterface)
            {
                this.ClassType = ClassType.Interface;
            }
            else if (type.IsEnum)
            {
                this.ClassType = ClassType.Enum;
            }
            else if (type.IsValueType)
            {
                this.ClassType = ClassType.Struct;
            }
            else if (IsDelegate(type))
            {
                this.ClassType = ClassType.Delegate;
            }
            else
            {
                this.ClassType = ClassType.Class;
                ApplySpecialsFromAttributes(this);
            }
            if (type.IsGenericTypeDefinition)
            {
                foreach (Type g in type.GetGenericArguments())
                {
                    this.TypeParameters.Add(new DefaultTypeParameter(this, g));
                }
                int i = 0;
                foreach (Type g in type.GetGenericArguments())
                {
                    AddConstraintsFromType(this.TypeParameters[i++], g);
                }
            }

            ModifierEnum modifiers = ModifierEnum.None;

            if (type.IsNestedAssembly)
            {
                modifiers |= ModifierEnum.Internal;
            }
            if (type.IsSealed)
            {
                modifiers |= ModifierEnum.Sealed;
            }
            if (type.IsAbstract)
            {
                modifiers |= ModifierEnum.Abstract;
            }

            if (type.IsNestedPrivate)
            { // I assume that private is used most and public last (at least should be)
                modifiers |= ModifierEnum.Private;
            }
            else if (type.IsNestedFamily)
            {
                modifiers |= ModifierEnum.Protected;
            }
            else if (type.IsNestedPublic || type.IsPublic)
            {
                modifiers |= ModifierEnum.Public;
            }
            else if (type.IsNotPublic)
            {
                modifiers |= ModifierEnum.Internal;
            }
            else if (type.IsNestedFamORAssem || type.IsNestedFamANDAssem)
            {
                modifiers |= ModifierEnum.Protected;
                modifiers |= ModifierEnum.Internal;
            }
            this.Modifiers = modifiers;

            // set base classes
            if (type.BaseType != null)
            { // it's null for System.Object ONLY !!!
                BaseTypes.Add(ReflectionReturnType.Create(this, type.BaseType, false));
            }

            foreach (Type iface in type.GetInterfaces())
            {
                BaseTypes.Add(ReflectionReturnType.Create(this, iface, false));
            }

            InitMembers(type);
        }
コード例 #14
0
ファイル: KityHighBlitzMax.cs プロジェクト: freezernick/kitty
        public KittyBlitzMax()
        {
            // Not complete yet, but for now this will do!
            caseinsensitive = true;
            singcomment     = "'";
            escape          = '~';
            KeyWords.Add("import");
            KeyWords.Add("module");
            KeyWords.Add("type");
            KeyWords.Add("moduleinfo");
            KeyWords.Add("public");
            KeyWords.Add("private");
            KeyWords.Add("extends");
            KeyWords.Add("method");
            KeyWords.Add("function");
            BaseTypes.Add("string");
            BaseTypes.Add("int");
            BaseTypes.Add("byte");
            BaseTypes.Add("long");
            KeyWords.Add("select");
            KeyWords.Add("case");
            KeyWords.Add("default");
            KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("else");
            KeyWords.Add("elseif");
            KeyWords.Add("then");
            KeyWords.Add("while");
            KeyWords.Add("true");
            KeyWords.Add("false");
            KeyWords.Add("abstract");
            KeyWords.Add("self");
            KeyWords.Add("try");
            KeyWords.Add("catch");
            KeyWords.Add("finally");
            KeyWords.Add("local");
            KeyWords.Add("global");
            KeyWords.Add("return");
            KeyWords.Add("for");
            KeyWords.Add("eachin");
            KeyWords.Add("new");
            KeyWords.Add("delete");
            KeyWords.Add("break");
            KeyWords.Add("null");
            KeyWords.Add("field");
            KeyWords.Add("include");
            KeyWords.Add("incbin");
            KeyWords.Add("framework");
            KeyWords.Add("strict");
            KeyWords.Add("superstrict");
            KeyWords.Add("const");
            KeyWords.Add("not");
            KeyWords.Add("repeat");

            KeyWords.Add("rem"); // Although I must set some things right here...

            // Endings
            KeyWords.Add("end");
            KeyWords.Add("endif");
            KeyWords.Add("endfunction");
            KeyWords.Add("endmethod");
            KeyWords.Add("endtype");
            KeyWords.Add("endrem");
            KeyWords.Add("wend");
            KeyWords.Add("next");
            KeyWords.Add("until");
            KeyWords.Add("forever");


            Langs["bmx"] = this;
            Language     = "BlitzMax";
        }
コード例 #15
0
        public static void Init()
        {
            ReleaseAll();
#if USE_HOT
            foreach (var itor in hotMgr.appdomain.LoadedTypes)
            {
                AllTypesByFullName.Add(itor.Key, itor.Value.ReflectionType);
            }

            Reg <int>();
            Reg <uint>();
            Reg <sbyte>();
            Reg <byte>();
            Reg <short>();
            Reg <ushort>();
            Reg <long>();
            Reg <ulong>();
            Reg <string>();
            Reg <float>();
            Reg <double>();
#endif
            var assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
            foreach (var assembly in assemblies)
            {
                if (assembly.FullName.StartsWith("Game"))
                {
                    var types = assembly.GetTypes();
                    foreach (var type in types)
                    {
                        if (type.FullName.StartsWith("<"))
                        {
                            continue;
                        }

                        System.Type t = null;
                        if (AllTypesByFullName.TryGetValue(type.FullName, out t))
                        {
#if USE_HOT
                            if (t != type)
                            {
                                if ((t is ILRuntimeWrapperType) && ((ILRuntimeWrapperType)t).RealType == type)
                                {
                                    continue;
                                }

                                wxb.L.LogErrorFormat("error:{0}", type.FullName);
                            }
#endif
                            continue;
                        }
                        AllTypesByFullName.Add(type.FullName, type);
                    }
                }
            }

            BaseTypes.Add(typeof(int));
            BaseTypes.Add(typeof(uint));
            BaseTypes.Add(typeof(sbyte));
            BaseTypes.Add(typeof(byte));
            BaseTypes.Add(typeof(short));
            BaseTypes.Add(typeof(ushort));
            BaseTypes.Add(typeof(long));
            BaseTypes.Add(typeof(ulong));
            BaseTypes.Add(typeof(string));
            BaseTypes.Add(typeof(float));
            BaseTypes.Add(typeof(double));

            AllTypesByFullName.Add("int", typeof(int));
            AllTypesByFullName.Add("uint", typeof(uint));
            AllTypesByFullName.Add("sbyte", typeof(sbyte));
            AllTypesByFullName.Add("byte", typeof(byte));
            AllTypesByFullName.Add("short", typeof(short));
            AllTypesByFullName.Add("ushort", typeof(ushort));
            AllTypesByFullName.Add("long", typeof(long));
            AllTypesByFullName.Add("ulong", typeof(ulong));
            AllTypesByFullName.Add("string", typeof(string));
            AllTypesByFullName.Add("float", typeof(float));
            AllTypesByFullName.Add("double", typeof(double));
        }
コード例 #16
0
            public CecilClass(ICompilationUnit compilationUnit, IClass declaringType,
                              TypeDefinition td, string fullName)
                : base(compilationUnit, declaringType)
            {
                this.FullyQualifiedName  = fullName;
                this.UseInheritanceCache = true;

                AddAttributes(compilationUnit.ProjectContent, this.Attributes, td.CustomAttributes);

                // set classtype
                if (td.IsInterface)
                {
                    this.ClassType = ClassType.Interface;
                }
                else if (td.IsEnum)
                {
                    this.ClassType = ClassType.Enum;
                }
                else if (td.IsValueType)
                {
                    this.ClassType = ClassType.Struct;
                }
                else if (IsDelegate(td))
                {
                    this.ClassType = ClassType.Delegate;
                }
                else
                {
                    this.ClassType = ClassType.Class;
                }
                if (td.GenericParameters.Count > 0)
                {
                    foreach (GenericParameter g in td.GenericParameters)
                    {
                        this.TypeParameters.Add(new DefaultTypeParameter(this, g.Name, g.Position));
                    }
                    int i = 0;
                    foreach (GenericParameter g in td.GenericParameters)
                    {
                        AddConstraintsFromType(this.TypeParameters[i++], g);
                    }
                }

                ModifierEnum modifiers = ModifierEnum.None;

                if (td.IsSealed)
                {
                    modifiers |= ModifierEnum.Sealed;
                }
                if (td.IsAbstract)
                {
                    modifiers |= ModifierEnum.Abstract;
                }

                if ((td.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic)
                {
                    modifiers |= ModifierEnum.Public;
                }
                else if ((td.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily)
                {
                    modifiers |= ModifierEnum.Protected;
                }
                else if ((td.Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamORAssem)
                {
                    modifiers |= ModifierEnum.Protected;
                }
                else
                {
                    modifiers |= ModifierEnum.Public;
                }

                this.Modifiers = modifiers;

                // set base classes
                if (td.BaseType != null)
                {
                    BaseTypes.Add(CreateType(this.ProjectContent, this, td.BaseType));
                }

                foreach (TypeReference iface in td.Interfaces)
                {
                    BaseTypes.Add(CreateType(this.ProjectContent, this, iface));
                }

                ReflectionLayer.ReflectionClass.ApplySpecialsFromAttributes(this);

                InitMembers(td);
            }
コード例 #17
0
        public void AddBaseClass(IClass baseClass)
        {
            DefaultReturnType returnType = new DefaultReturnType(baseClass);

            BaseTypes.Add(returnType);
        }
コード例 #18
0
        public KittyHighCS()
        {
            // Not complete yet, but for now this will do!
            BaseTypes.Add("bool");
            BaseTypes.Add("byte");
            BaseTypes.Add("sbyte");
            BaseTypes.Add("char");
            BaseTypes.Add("decimal");
            BaseTypes.Add("double");
            BaseTypes.Add("float");
            BaseTypes.Add("int");
            BaseTypes.Add("uint");
            BaseTypes.Add("long");
            BaseTypes.Add("ulong");
            BaseTypes.Add("short");
            BaseTypes.Add("ushort");
            KeyWords.Add("abstract");
            KeyWords.Add("as");
            KeyWords.Add("base");
            KeyWords.Add("break");
            KeyWords.Add("case");
            KeyWords.Add("catch");
            KeyWords.Add("checked");
            KeyWords.Add("class");
            KeyWords.Add("const");
            KeyWords.Add("continue");
            KeyWords.Add("default");
            KeyWords.Add("delegate");
            KeyWords.Add("do");
            KeyWords.Add("else");
            KeyWords.Add("enum");
            KeyWords.Add("event");
            KeyWords.Add("explicit");
            KeyWords.Add("extern");
            KeyWords.Add("false");
            KeyWords.Add("finally");
            KeyWords.Add("fixed");
            KeyWords.Add("for");
            KeyWords.Add("foreach");
            KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("implicit");
            KeyWords.Add("in");
            KeyWords.Add("interface");
            KeyWords.Add("internal");
            KeyWords.Add("is");
            KeyWords.Add("lock");
            KeyWords.Add("namespace");
            KeyWords.Add("new");
            KeyWords.Add("null");
            KeyWords.Add("object");
            KeyWords.Add("operator");
            KeyWords.Add("out");
            KeyWords.Add("override");
            KeyWords.Add("params");
            KeyWords.Add("private");
            KeyWords.Add("protected");
            KeyWords.Add("public");
            KeyWords.Add("readonly");
            KeyWords.Add("ref");
            KeyWords.Add("return");
            KeyWords.Add("sealed");
            KeyWords.Add("sizeof");
            KeyWords.Add("stackalloc");
            KeyWords.Add("static");
            KeyWords.Add("string");
            KeyWords.Add("struct");
            KeyWords.Add("switch");
            KeyWords.Add("this");
            KeyWords.Add("throw");
            KeyWords.Add("true");
            KeyWords.Add("try");
            KeyWords.Add("typeof");
            KeyWords.Add("unchecked");
            KeyWords.Add("unsafe");
            KeyWords.Add("using");
            KeyWords.Add("virtual");
            KeyWords.Add("volatile");
            KeyWords.Add("while");

            // Since we've them for VB here are unreserved keywords

            KeyWords.Add("add");
            KeyWords.Add("alias");
            KeyWords.Add("ascending");
            KeyWords.Add("async");
            KeyWords.Add("await");
            KeyWords.Add("by");
            KeyWords.Add("descending");
            KeyWords.Add("dynamic");
            KeyWords.Add("equals");
            KeyWords.Add("from");
            KeyWords.Add("get");
            KeyWords.Add("global");
            KeyWords.Add("group");
            KeyWords.Add("into");
            KeyWords.Add("join");
            KeyWords.Add("let");
            KeyWords.Add("nameof");
            KeyWords.Add("notnull");
            KeyWords.Add("on");
            KeyWords.Add("oderby");
            KeyWords.Add("partial");
            KeyWords.Add("remove");
            KeyWords.Add("select");
            KeyWords.Add("set");
            KeyWords.Add("unmanaged");
            KeyWords.Add("value");
            KeyWords.Add("var");
            KeyWords.Add("void");
            KeyWords.Add("when");
            KeyWords.Add("where");
            KeyWords.Add("yield");

            Langs["cs"] = this;
            Language    = "C#";
        }
コード例 #19
0
        public KittyHighVB()
        {
            Langs["vb"]     = this;
            Language        = "VisualBasic";
            singcomment     = "'";
            mulcomment      = false;
            caseinsensitive = true;
            KeyWords.Add("addhandler");
            KeyWords.Add("addressof");
            KeyWords.Add("alias");
            KeyWords.Add("and");
            KeyWords.Add("andalso");
            KeyWords.Add("as");
            KeyWords.Add("byref");
            KeyWords.Add("byval");
            KeyWords.Add("call");
            KeyWords.Add("case");
            KeyWords.Add("catch");
            KeyWords.Add("cbool");
            KeyWords.Add("cbyte");
            KeyWords.Add("cchar");
            KeyWords.Add("cdate");
            KeyWords.Add("cdbl");
            KeyWords.Add("cdec");
            KeyWords.Add("cint");
            KeyWords.Add("class");
            KeyWords.Add("clng");
            KeyWords.Add("cobj");
            KeyWords.Add("const");
            KeyWords.Add("continue");
            KeyWords.Add("csbyte");
            KeyWords.Add("cshort");
            KeyWords.Add("csng");
            KeyWords.Add("cstr");
            KeyWords.Add("ctype");
            KeyWords.Add("cuint");
            KeyWords.Add("culng");
            KeyWords.Add("cushort");
            KeyWords.Add("declare");
            KeyWords.Add("default");
            KeyWords.Add("delegate");
            KeyWords.Add("dim");
            KeyWords.Add("directcast");
            KeyWords.Add("do");
            KeyWords.Add("each");
            KeyWords.Add("else");
            KeyWords.Add("elseif");
            KeyWords.Add("end");
            KeyWords.Add("enum");
            KeyWords.Add("erase");
            KeyWords.Add("error");
            KeyWords.Add("event");
            KeyWords.Add("exit");
            KeyWords.Add("false");
            KeyWords.Add("finally");
            KeyWords.Add("for");
            KeyWords.Add("friend");
            KeyWords.Add("function");
            KeyWords.Add("get");
            KeyWords.Add("gettype");
            KeyWords.Add("getxmlnamespace");
            KeyWords.Add("global");
            KeyWords.Add("goto");
            KeyWords.Add("handles");
            KeyWords.Add("if");
            KeyWords.Add("implements");
            KeyWords.Add("imports");
            KeyWords.Add("in");
            KeyWords.Add("inherits");
            KeyWords.Add("interface");
            KeyWords.Add("is");
            KeyWords.Add("isnot");
            KeyWords.Add("let");
            KeyWords.Add("lib");
            KeyWords.Add("like");
            KeyWords.Add("loop");
            KeyWords.Add("me");
            KeyWords.Add("mod");
            KeyWords.Add("module");
            KeyWords.Add("mustinherit");
            KeyWords.Add("mustoverride");
            KeyWords.Add("mybase");
            KeyWords.Add("myclass");
            KeyWords.Add("namespace");
            KeyWords.Add("narrowing");
            KeyWords.Add("new constraint");
            KeyWords.Add("new operator");
            KeyWords.Add("next");
            KeyWords.Add("not");
            KeyWords.Add("nothing");
            KeyWords.Add("noninheritable");
            KeyWords.Add("notoverridable");
            KeyWords.Add("of");
            KeyWords.Add("on");
            KeyWords.Add("operator");
            KeyWords.Add("option");
            KeyWords.Add("optional");
            KeyWords.Add("or");
            KeyWords.Add("orelse");
            KeyWords.Add("out");
            KeyWords.Add("overloads");
            KeyWords.Add("overridable");
            KeyWords.Add("overrides");
            KeyWords.Add("paramarray");
            KeyWords.Add("partial");
            KeyWords.Add("private");
            KeyWords.Add("property");
            KeyWords.Add("protected");
            KeyWords.Add("public");
            KeyWords.Add("raiseevent");
            KeyWords.Add("readonly");
            KeyWords.Add("redim");
            KeyWords.Add("rem");
            KeyWords.Add("removehandler");
            KeyWords.Add("resume");
            KeyWords.Add("return");
            KeyWords.Add("select");
            KeyWords.Add("set");
            KeyWords.Add("shadows");
            KeyWords.Add("shared");
            KeyWords.Add("static");
            KeyWords.Add("step");
            KeyWords.Add("stop");
            KeyWords.Add("structure constraint");
            KeyWords.Add("sub");
            KeyWords.Add("synclock");
            KeyWords.Add("then");
            KeyWords.Add("throw");
            KeyWords.Add("to");
            KeyWords.Add("true");
            KeyWords.Add("try");
            KeyWords.Add("trycast");
            KeyWords.Add("typeof");
            KeyWords.Add("using");
            KeyWords.Add("when");
            KeyWords.Add("while");
            KeyWords.Add("widening");
            KeyWords.Add("with");
            KeyWords.Add("withevents");
            KeyWords.Add("writeonly");
            KeyWords.Add("xor");

            // unreserved keywords

            KeyWords.Add("aggregate");
            KeyWords.Add("ansi");
            KeyWords.Add("assembly");
            KeyWords.Add("async");
            KeyWords.Add("auto");
            KeyWords.Add("await");
            KeyWords.Add("binary");
            KeyWords.Add("compare");
            KeyWords.Add("custom");
            KeyWords.Add("distinct");
            KeyWords.Add("equals");
            KeyWords.Add("explicit");
            KeyWords.Add("from");
            KeyWords.Add("group");
            KeyWords.Add("by");
            KeyWords.Add("join");
            KeyWords.Add("into");
            KeyWords.Add("isfalse");
            KeyWords.Add("istrue");
            KeyWords.Add("iterator");
            KeyWords.Add("key");
            KeyWords.Add("mid");
            KeyWords.Add("off");
            KeyWords.Add("order");
            KeyWords.Add("preserve");
            KeyWords.Add("skip");
            KeyWords.Add("while");
            KeyWords.Add("strict");
            KeyWords.Add("take");
            KeyWords.Add("text");
            KeyWords.Add("unicode");
            KeyWords.Add("until");
            KeyWords.Add("where");
            KeyWords.Add("yield");

            // Base Types
            BaseTypes.Add("boolean");
            BaseTypes.Add("byte");
            BaseTypes.Add("char");
            BaseTypes.Add("date");
            BaseTypes.Add("decimal");
            BaseTypes.Add("double");
            BaseTypes.Add("integer");
            BaseTypes.Add("long");
            BaseTypes.Add("object");
            BaseTypes.Add("sbyte");
            BaseTypes.Add("short");
            BaseTypes.Add("single");
            BaseTypes.Add("string");
            BaseTypes.Add("uinteger");
            BaseTypes.Add("ulong");
            BaseTypes.Add("ushort");
        }
コード例 #20
0
ファイル: KittyHighC.cs プロジェクト: freezernick/kitty
 public KittyHighC()
 {
     Langs["c"]   = this;
     Langs["cpp"] = this;
     Langs["h"]   = this;
     Langs["hpp"] = this;
     Language     = "C/C++";
     BaseTypes.Add("void");
     BaseTypes.Add("bool");
     BaseTypes.Add("auto");
     BaseTypes.Add("char");
     BaseTypes.Add("int");
     KeyWords.Add("asm");
     KeyWords.Add("else");
     KeyWords.Add("new");
     KeyWords.Add("this");
     KeyWords.Add("enum");
     KeyWords.Add("operator");
     KeyWords.Add("throw");
     KeyWords.Add("explicit");
     KeyWords.Add("private");
     KeyWords.Add("true");
     KeyWords.Add("break");
     KeyWords.Add("export");
     KeyWords.Add("protected");
     KeyWords.Add("try");
     KeyWords.Add("case");
     KeyWords.Add("extern");
     KeyWords.Add("public");
     KeyWords.Add("typedef");
     KeyWords.Add("catch");
     KeyWords.Add("false");
     KeyWords.Add("register");
     KeyWords.Add("typeid");
     KeyWords.Add("float");
     KeyWords.Add("reinterpret_cast");
     KeyWords.Add("typename");
     KeyWords.Add("class");
     KeyWords.Add("for");
     KeyWords.Add("return");
     KeyWords.Add("union");
     KeyWords.Add("const");
     KeyWords.Add("friend");
     KeyWords.Add("short");
     KeyWords.Add("unsigned");
     KeyWords.Add("const_cast");
     KeyWords.Add("goto");
     KeyWords.Add("signed");
     KeyWords.Add("using");
     KeyWords.Add("continue");
     KeyWords.Add("if");
     KeyWords.Add("sizeof");
     KeyWords.Add("virtual");
     KeyWords.Add("default");
     KeyWords.Add("inline");
     KeyWords.Add("static");
     KeyWords.Add("delete");
     KeyWords.Add("static_cast");
     KeyWords.Add("volatile");
     KeyWords.Add("do");
     KeyWords.Add("long");
     KeyWords.Add("struct");
     KeyWords.Add("wchar_t");
     KeyWords.Add("double");
     KeyWords.Add("mutable");
     KeyWords.Add("switch");
     KeyWords.Add("while");
     KeyWords.Add("dynamic_cast");
     KeyWords.Add("namespace");
     KeyWords.Add("template");
 }
コード例 #21
0
        public KittyHighNeil()
        {
            caseinsensitive = true;
            // Base Types
            BaseTypes.Add("void");
            BaseTypes.Add("string");
            BaseTypes.Add("int");
            BaseTypes.Add("bool");
            BaseTypes.Add("var");
            BaseTypes.Add("plua");
            // Not complete yet, but for now this will do!
            KeyWords.Add("not");
            KeyWords.Add("class");
            KeyWords.Add("group");
            KeyWords.Add("module");
            KeyWords.Add("global");
            KeyWords.Add("private");
            KeyWords.Add("end");
            KeyWords.Add("and");
            KeyWords.Add("or");
            KeyWords.Add("table");
            KeyWords.Add("quickmeta");
            KeyWords.Add("switch");
            KeyWords.Add("case");
            KeyWords.Add("default");
            // KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("else");
            KeyWords.Add("elseif");
            KeyWords.Add("do");
            KeyWords.Add("while");
            KeyWords.Add("true");
            KeyWords.Add("false");
            KeyWords.Add("abstract");
            KeyWords.Add("override");
            KeyWords.Add("self");
            KeyWords.Add("get");
            KeyWords.Add("set");
            KeyWords.Add("try");
            KeyWords.Add("catch");
            KeyWords.Add("finally");
            KeyWords.Add("static");
            KeyWords.Add("return");
            KeyWords.Add("for");
            KeyWords.Add("in");
            KeyWords.Add("delegate");
            KeyWords.Add("readonly");
            KeyWords.Add("new");
            KeyWords.Add("break");
            KeyWords.Add("nil");
            KeyWords.Add("extends");

            KeyWords.Add("repeat");
            KeyWords.Add("until");
            KeyWords.Add("loopwhile");
            KeyWords.Add("init");
            KeyWords.Add("cfor");
            KeyWords.Add("pairs");
            KeyWords.Add("ipairs");
            KeyWords.Add("with");
            KeyWords.Add("const");

            KeyWords.Add("constructor");
            KeyWords.Add("destructor");
            KeyWords.Add("infinity");
            KeyWords.Add("defer");

            KeyWords.Add("import");
            KeyWords.Add("export");

            //KeyWords.Add("foreach");
            Langs["neil"] = this;
            Language      = "Neil";
        }
コード例 #22
0
        public KittyHighBlitzBasic()
        {
            // Not complete yet, but for now this will do!
            caseinsensitive = true;
            singcomment     = ";";
            escape          = '\0';
            mulcomment      = false;

            BaseTypes.Add("string");
            BaseTypes.Add("int");
            BaseTypes.Add("byte"); // ?
            BaseTypes.Add("long");

            //KeyWords.Add("import");
            //KeyWords.Add("module");
            KeyWords.Add("type");
            //KeyWords.Add("moduleinfo");
            //KeyWords.Add("public");
            //KeyWords.Add("private");
            //KeyWords.Add("extends");
            KeyWords.Add("method"); // ?
            KeyWords.Add("function");
            KeyWords.Add("select");
            KeyWords.Add("case");
            KeyWords.Add("default");
            KeyWords.Add("goto"); // EEEEW!
            KeyWords.Add("if");
            KeyWords.Add("else");
            KeyWords.Add("elseif");
            KeyWords.Add("then");
            KeyWords.Add("while");
            KeyWords.Add("true");
            KeyWords.Add("false");
            //KeyWords.Add("abstract");
            KeyWords.Add("self");
            KeyWords.Add("try");     // ?
            KeyWords.Add("catch");   // ?
            KeyWords.Add("finally"); // ?
            KeyWords.Add("local");
            KeyWords.Add("global");
            KeyWords.Add("return");
            KeyWords.Add("for");
            KeyWords.Add("each");
            KeyWords.Add("new");
            KeyWords.Add("delete");
            KeyWords.Add("break");
            //KeyWords.Add("null");
            KeyWords.Add("field");
            KeyWords.Add("include");
            //KeyWords.Add("incbin");
            //KeyWords.Add("framework");
            //KeyWords.Add("strict");
            //KeyWords.Add("superstrict");
            KeyWords.Add("const");
            KeyWords.Add("not");
            KeyWords.Add("data");
            KeyWords.Add("dim");
            KeyWords.Add("repeat");

            KeyWords.Add("end");
            KeyWords.Add("endif");
            KeyWords.Add("endfunction");
            KeyWords.Add("endmethod");
            KeyWords.Add("endtype");
            KeyWords.Add("endrem");
            KeyWords.Add("wend");
            KeyWords.Add("next");
            KeyWords.Add("until");
            KeyWords.Add("forever");

            Langs["bb"] = this;
            Language    = "BlitzBasic / Blitz3D / BlitzPlus";
        }
コード例 #23
0
        public KittyHighPascal()
        {
            // Please note, that I tried to cover Pascal, Turbo Pascal and Object Pascal (and in the process Free Pascal) all in one go, so some keywords may not be keywords in all Pascal compilers.
            caseinsensitive = true;
            mulcomment      = true;
            mulcommentstart = "{";
            mulcommentend   = "}";
            Langs["pas"]    = this;
            Language        = "Pascal";
            KeyWords.Add("and");
            KeyWords.Add("array");
            KeyWords.Add("asm");
            KeyWords.Add("begin");
            KeyWords.Add("break");
            KeyWords.Add("case");
            KeyWords.Add("const");
            KeyWords.Add("constructor");
            KeyWords.Add("continue");
            KeyWords.Add("destructor");
            KeyWords.Add("div");
            KeyWords.Add("do");
            KeyWords.Add("downto");
            KeyWords.Add("else");
            KeyWords.Add("end");
            KeyWords.Add("false");
            KeyWords.Add("file");
            KeyWords.Add("for");
            KeyWords.Add("function");
            KeyWords.Add("goto");
            KeyWords.Add("if");
            KeyWords.Add("implementation");
            KeyWords.Add("in");
            KeyWords.Add("inline");
            KeyWords.Add("interface");
            KeyWords.Add("label");
            KeyWords.Add("mod");
            KeyWords.Add("nil");
            KeyWords.Add("not");
            KeyWords.Add("object");
            KeyWords.Add("of");
            KeyWords.Add("operator");
            KeyWords.Add("packed");
            KeyWords.Add("procedure");
            KeyWords.Add("program");
            KeyWords.Add("record");
            KeyWords.Add("repeat");
            KeyWords.Add("set");
            KeyWords.Add("shl");
            KeyWords.Add("shr");
            KeyWords.Add("string");
            KeyWords.Add("then");
            KeyWords.Add("to");
            KeyWords.Add("true");
            KeyWords.Add("type");
            KeyWords.Add("unit");
            KeyWords.Add("until");
            KeyWords.Add("uses");
            KeyWords.Add("var");
            KeyWords.Add("while");
            KeyWords.Add("with");
            KeyWords.Add("xor");

            KeyWords.Add("Object");

            KeyWords.Add("as");
            KeyWords.Add("class");
            KeyWords.Add("dispose");
            KeyWords.Add("except");
            KeyWords.Add("exit");
            KeyWords.Add("exports");
            KeyWords.Add("finalization");
            KeyWords.Add("finally");

            KeyWords.Add("initialization");
            KeyWords.Add("is");
            KeyWords.Add("library");
            KeyWords.Add("new");
            KeyWords.Add("on");
            KeyWords.Add("out");
            KeyWords.Add("property");
            KeyWords.Add("raise");
            KeyWords.Add("self");
            KeyWords.Add("threadvar");
            KeyWords.Add("try");


            KeyWords.Add("absolute");
            KeyWords.Add("abstract");
            KeyWords.Add("alias");
            KeyWords.Add("assembler");
            KeyWords.Add("cdecl");
            KeyWords.Add("cppdecl");
            KeyWords.Add("default");
            KeyWords.Add("export");
            KeyWords.Add("external");
            KeyWords.Add("forward");
            KeyWords.Add("generic");
            KeyWords.Add("index");
            KeyWords.Add("local");
            KeyWords.Add("name");
            KeyWords.Add("nostackframe");
            KeyWords.Add("oldfpccall");
            KeyWords.Add("override");

            KeyWords.Add("private");
            KeyWords.Add("protected");
            KeyWords.Add("public");
            KeyWords.Add("published");
            KeyWords.Add("read");
            KeyWords.Add("register");
            KeyWords.Add("reintroduce");
            KeyWords.Add("safecall");
            KeyWords.Add("softfloat");
            KeyWords.Add("specialize");

            KeyWords.Add("stdcall");
            KeyWords.Add("virtual");
            KeyWords.Add("write");


            KeyWords.Add("far");
            KeyWords.Add("near");

            BaseTypes.Add("integer");
            BaseTypes.Add("word");
            BaseTypes.Add("shortint");
            BaseTypes.Add("byte");
            BaseTypes.Add("char");
            BaseTypes.Add("string");
        }
コード例 #24
0
        public static void Init()
        {
            ReleaseAll();
#if USE_HOT
#if UNITY_EDITOR
            foreach (var itor in DllInitByEditor.appdomain.LoadedTypes)
#else
            foreach (var itor in hotMgr.appdomain.LoadedTypes)
#endif
            {
                string name = itor.Key;
                AllTypesByFullName.Add(name, itor.Value.ReflectionType);
#if USE_HOT
                if (name.IndexOf('/') != -1)
                {
                    AllTypesByFullName.Add(name.Replace('/', '+'), itor.Value.ReflectionType);
                }
#endif
            }

            Reg <int>();
            Reg <uint>();
            Reg <sbyte>();
            Reg <byte>();
            Reg <short>();
            Reg <ushort>();
            Reg <long>();
            Reg <ulong>();
            Reg <string>();
            Reg <float>();
            Reg <double>();
            Reg <char>();
#endif
            var assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
            foreach (var assembly in assemblies)
            {
#if UNITY_EDITOR
                string fn = assembly.FullName;
                if (fn.StartsWith("Assembly-CSharp-Editor"))
                {
                    continue;
                }
                if (fn.EndsWith(".Editor.dll"))
                {
                    continue;
                }
#endif
                //if (assembly.FullName.StartsWith("Assembly-CSharp"))
                {
                    var types = assembly.GetTypes();
                    foreach (var type in types)
                    {
                        if (type.FullName.StartsWith("<"))
                        {
                            continue;
                        }

                        System.Type t = null;
                        if (AllTypesByFullName.TryGetValue(type.FullName, out t))
                        {
//#if USE_HOT
//                            if (t != type)
//                            {
//                                if ((t is ILRuntimeWrapperType) && ((ILRuntimeWrapperType)t).RealType == type)
//                                    continue;

//                                wxb.L.LogErrorFormat("error:{0}", type.FullName);
//                            }
//#endif
                            continue;
                        }
                        AllTypesByFullName.Add(type.FullName, type);
                    }
                }
            }

            BaseTypes.Add(typeof(int));
            BaseTypes.Add(typeof(uint));
            BaseTypes.Add(typeof(sbyte));
            BaseTypes.Add(typeof(byte));
            BaseTypes.Add(typeof(short));
            BaseTypes.Add(typeof(ushort));
            BaseTypes.Add(typeof(long));
            BaseTypes.Add(typeof(ulong));
            BaseTypes.Add(typeof(string));
            BaseTypes.Add(typeof(float));
            BaseTypes.Add(typeof(double));
            BaseTypes.Add(typeof(bool));
            BaseTypes.Add(typeof(char));

            AllTypesByFullName.Add("int", typeof(int));
            AllTypesByFullName.Add("uint", typeof(uint));
            AllTypesByFullName.Add("sbyte", typeof(sbyte));
            AllTypesByFullName.Add("byte", typeof(byte));
            AllTypesByFullName.Add("short", typeof(short));
            AllTypesByFullName.Add("ushort", typeof(ushort));
            AllTypesByFullName.Add("long", typeof(long));
            AllTypesByFullName.Add("ulong", typeof(ulong));
            AllTypesByFullName.Add("string", typeof(string));
            AllTypesByFullName.Add("float", typeof(float));
            AllTypesByFullName.Add("double", typeof(double));
            AllTypesByFullName.Add("bool", typeof(bool));
            AllTypesByFullName.Add("char", typeof(char));
        }