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);
}
}
}
/// <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"));
}
public FakeClass AddBaseClass(string name)
{
var baseClass = new FakeClass(name);
var returnType = new DefaultReturnType(baseClass);
BaseTypes.Add(returnType);
return(baseClass);
}
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";
}
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"));
}
}
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);
}
}
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
}
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);
}
}
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#";
}
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());
}
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");
}
/// <summary>
/// Adds the named base type to the class.
/// </summary>
void AddBaseType(string name)
{
IReturnType returnType = CreateSearchClassReturnType(name);
BaseTypes.Add(returnType);
}
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);
}
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";
}
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));
}
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);
}
public void AddBaseClass(IClass baseClass)
{
DefaultReturnType returnType = new DefaultReturnType(baseClass);
BaseTypes.Add(returnType);
}
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#";
}
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");
}
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");
}
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";
}
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";
}
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");
}
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));
}