//添加小类型 public bool AddSmaillType(int bid, string sname, string explain) { SmallType st = new SmallType { Id = BackIdService <BigType> .Instance.NewId(), Name = sname, EditionUser = "******", BigType = bid, Explain = explain }; var r = dbm.AddSmaillType(st); return(r); }
private static MethodDefinition GetDefinition(MethodSyntax pMethod, int pCounter, string pNamespace, string pName) { List <SmallType> arguments = new List <SmallType>(pMethod.Parameters.Count); for (int i = 0; i < pMethod.Parameters.Count; i++) { var parmType = pMethod.Parameters[i].Type; arguments.Add(parmType); } SmallType ret = pMethod.Type; string mangledName = pNamespace + "__" + pName + "_" + pCounter; return(new MethodDefinition(pMethod.Scope, pMethod.Name, mangledName, pMethod.External, arguments, ret)); }
public MethodDefinition AddMethod(SmallType pType, string pNamespace, MethodSyntax pNode) { var name = GetMethodName(pType, pNode.Name); if (!_methods.ContainsKey(name)) { _methods.Add(name, new List <MethodDefinition>()); _counter.Add(name, 0); } _counter[name]++; var md = GetDefinition(pNode, _counter[name], pNamespace, name); _methods[name].Add(md); return(md); }
public FindResult FromString(string pName, out SmallType pType) { //Look through primitive types if (SmallTypeCache.TryGetPrimitive(pName, out pType)) { return(FindResult.Found); } //Look for types defined in this compilation pType = _types.FindType(pName); if (pType == SmallTypeCache.Undefined) { return(FindResult.NotFound); } return(FindResult.Found); }
public FindResult FromString(string pNamespace, string pName, out SmallType pType) { if (pNamespace == null) { return(FromString(pName, out pType)); } else { var result = _references[pNamespace].Cache.FromString(pName, out pType); if (result == FindResult.NotFound) { return(FromString(pName, out pType)); } else if (pType.Scope == FileScope.Private) { return(FindResult.IncorrectScope); } return(result); } }
private SmallType GetReturnType() { var ts = new SmallType[] { SmallType.I16, SmallType.I32, SmallType.I64, SmallType.Float, SmallType.Double }; var t = new SmallType[, ] { { SmallType.I16, SmallType.I32, SmallType.I64, SmallType.Float, SmallType.Double }, { SmallType.I32, SmallType.I32, SmallType.I64, SmallType.Float, SmallType.Double }, { SmallType.I64, SmallType.I64, SmallType.I64, SmallType.Float, SmallType.Double }, { SmallType.Float, SmallType.Float, SmallType.Float, SmallType.Float, SmallType.Double }, { SmallType.Double, SmallType.Double, SmallType.Double, SmallType.Double, SmallType.Double } }; int i = Array.IndexOf(ts, Left.Type); int i2 = Array.IndexOf(ts, Right.Type); if (i == -1 || i2 == -1) { return(SmallType.Undefined); } return(t[i, i2]); }
protected override void VisitForSyntax(ForSyntax pNode) { _locals.AddScope(); if (pNode.Iterator != null) { Visit(pNode.Iterator); //Array vs Enumerable<T> if (pNode.Iterator.Type.IsArray) { _itType = pNode.Iterator.Type.GetElementType(); } else if (SmallTypeCache.TryGetEnumerable(_unit, out SmallType enumerable) && pNode.Iterator.Type.IsAssignableFrom(enumerable)) { _itType = pNode.Iterator.Type.GenericArguments[0]; } else { _itType = pNode.Iterator.Type; } } else { foreach (var d in pNode.Initializer) { Visit(d); } Visit(pNode.Condition); foreach (var f in pNode.Finalizer) { Visit(f); } } Visit(pNode.Body); _locals.RemoveScope(); }
internal static SmallType GetResultType(SmallType pLeft, BinaryExpressionOperator pOp, SmallType pRight) { switch (pOp) { case BinaryExpressionOperator.Addition: case BinaryExpressionOperator.Subtraction: case BinaryExpressionOperator.Multiplication: case BinaryExpressionOperator.Division: case BinaryExpressionOperator.Mod: if (pLeft.IsAssignableFrom(pRight)) { return(pLeft); } if (TypeHelper.IsFloat(pLeft) && TypeHelper.IsNumber(pRight)) { return(pLeft); } if (TypeHelper.IsFloat(pRight) && TypeHelper.IsNumber(pLeft)) { return(pRight); } return(SmallTypeCache.Undefined); case BinaryExpressionOperator.Equals: case BinaryExpressionOperator.GreaterThan: case BinaryExpressionOperator.GreaterThanOrEqual: case BinaryExpressionOperator.LessThan: case BinaryExpressionOperator.LessThanOrEqual: case BinaryExpressionOperator.NotEquals: if (pLeft.IsAssignableFrom(pRight)) { return(pLeft); } return(SmallTypeCache.Undefined); default: throw new NotSupportedException("Unknown binary expression operator " + pOp.ToString()); } }
private void ChangeNumber(NumericLiteralSyntax pNode, SmallType pType) { if (pType == SmallType.Double) { pNode.NumberType = NumberType.Double; } if (pType == SmallType.Float) { pNode.NumberType = NumberType.Float; } if (pType == SmallType.I16) { pNode.NumberType = NumberType.I16; } if (pType == SmallType.I32) { pNode.NumberType = NumberType.I32; } if (pType == SmallType.I64) { pNode.NumberType = NumberType.I64; } }
public override void Visit(WorkspaceSyntax pNode) { foreach (var i in pNode.Imports) { i.Accept(this); } //We need to register all types since structs could have fields of other types foreach (var s in pNode.Structs) { var st = SmallType.RegisterType("", s.Prefix, true, s.TypeArgs); if (s.Initializer != null) { st.SetInitializer(new InitializerInfo(s.Initializer)); } } foreach (var s in pNode.Structs) { s.Accept(this); } foreach (var m in pNode.Methods) { m.Accept(this); } foreach (var c in pNode.Casts) { c.Accept(this); } if (!_mainFound && _mainRequired) { Compiler.ReportError(CompilerErrorType.NoRun, new TextSpan()); } MetadataCache.AddImplicitCasts(); }
public SmallRequestEventArgs(SmallType small) { Small = small; }
public Compiler.FindResult FindMethod(out MethodDefinition pMethod, bool pAllowPrivate, SmallType pType, string pName, params SmallType[] pArguments) { var name = GetMethodName(pType, pName); if (!_methods.ContainsKey(name)) { pMethod = default; return(Compiler.FindResult.NotFound); } List <MethodDefinition> candidates = _methods[name]; MethodDefinition retval = candidates[0]; foreach (var c in candidates) { //Parameter count match if (c.ArgumentTypes.Count == pArguments.Length) { retval = c; //Types match bool found = true; for (int i = 0; i < c.ArgumentTypes.Count && found; i++) { if (c.ArgumentTypes[i].IsGenericParameter && pType != null) { found = pArguments[i].IsAssignableFrom(pType.GenericArguments[i]); } else { found = pArguments[i].IsAssignableFrom(c.ArgumentTypes[i]); } } //Scope match if (found) { pMethod = c; if (pMethod.Scope == FileScope.Public || pAllowPrivate) { return(Compiler.FindResult.Found); } return(Compiler.FindResult.IncorrectScope); } } } pMethod = retval; return(Compiler.FindResult.NotFound); }
public IdentifierSyntax(string pValue) : base(0) { Value = pValue; _type = SmallType.FromString("", pValue); TypeParameters = new List <string>(); }
public LocalBuilder CreateLocal(string pValue, SmallType pType) { return(CurrentMethod.CreateLocal(pValue, pType)); }
public bool UpdateSmallType(SmallType h) { st.SetCtx(db); return(st.Update(h)); }
public bool AddSmaillType(SmallType h) { st.SetCtx(db); return(st.Add(h)); }
/// <summary> /// 小类表类型添加 /// </summary> /// <param name="model"></param> /// <returns></returns> public int PostSmallType(SmallType model) { string sql = $"insert into SmallType values('{model.Stname}')"; return(DBHelper.ExecuteNonQuery(sql)); }
public void SetType(SmallType pType) { _type = pType; }
public FieldDefinition(SmallType pType, string pName, object pValue) : this(pType, pName, pValue, FieldVisibility.Public) { }
private void CreateParameter(short pPosition, string pName, SmallType pType, bool pIsRef) { CurrentMethod.CreateParameter(pName, pPosition, pType, pIsRef); }
public Type EmitStruct(SmallType pDefinition) { Type t = null; var ta = TypeAttributes.Class | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.SequentialLayout; if (pDefinition.Exported) { ta |= TypeAttributes.Public; } var tb = _builder.DefineType(pDefinition.Name, ta, typeof(ValueType)); GenericTypeParameterBuilder[] typeParms = null; if (pDefinition.IsGenericDefinition) { typeParms = tb.DefineGenericParameters(pDefinition.GenericTypeParameters.Select((pSt) => pSt.Name).ToArray()); //eww } if (pDefinition.Exported) { var c = typeof(TypePrefixAttribute).GetConstructor(new Type[] { typeof(string) }); var cb = new CustomAttributeBuilder(c, new object[] { pDefinition.Name }); tb.SetCustomAttribute(cb); } foreach (var f in pDefinition.GetFields()) { var found = false; if (typeParms != null) { foreach (var tp in typeParms) { foreach (var a in f.Type.GenericTypeParameters) { if (tp.Name == a.Name) { Type tt = tp; if (f.Type.IsArray) { tt = tt.MakeArrayType(); } f.Info = tb.DefineField(f.Name, tt, FieldAttributes.Public); found = true; break; } } } } if (!found) { f.Info = tb.DefineField(f.Name, f.Type.ToSystemType(), FieldAttributes.Public); } } if (pDefinition.HasInitializer) { var mb = tb.DefineMethod("Initialize", MethodAttributes.HideBySig | MethodAttributes.Public, null, null); pDefinition.Initializer.SetBuilder(mb); } //t = tb.CreateType(); pDefinition.SetSystemType(tb); return(t); }
public MethodInfo EmitFunction(MethodDefinition pDefinition) { if (pDefinition.ExternMethod != null) { pDefinition.SetExternMethod(pDefinition.ExternMethod); if (pDefinition.ExternMethod.ContainsGenericParameters) { for (int i = 0; i < pDefinition.TypeHints.Count; i++) { var args = pDefinition.ExternMethod.GetGenericArguments(); for (int j = 0; j < args.Length; j++) { if (pDefinition.TypeHints[i].Name == args[j].Name) { pDefinition.TypeHints[i].SetSystemType(args[j]); } } } } return(pDefinition.CallSite); } var ma = MethodAttributes.HideBySig | MethodAttributes.Static; switch (pDefinition.Scope) { case Scope.Private: ma |= MethodAttributes.Private; break; case Scope.Public: ma |= MethodAttributes.Public; break; } CurrentMethod = pDefinition; var mb = _currentType.DefineMethod(pDefinition.Name, ma, null, null); CurrentMethod.SetBuilder(mb); Type[] types = new Type[pDefinition.Parameters.Length]; Type[] typeParms = null; if (pDefinition.TypeHints.Count > 0) { string[] typeNames = new string[pDefinition.TypeHints.Count]; for (int i = 0; i < typeNames.Length; i++) { typeNames[i] = pDefinition.TypeHints[i].Name; } typeParms = mb.DefineGenericParameters(typeNames); } for (int i = 0; i < pDefinition.Parameters.Length; i++) { var st = pDefinition.Parameters[i].Type; Type t = null; if (typeParms != null) { for (int j = 0; j < typeParms.Length; j++) { for (int k = 0; k < st.GenericTypeArgs.Length; k++) { var stt = st.GenericTypeArgs[k]; if (stt.Name == typeParms[j].Name) { t = typeParms[j]; stt.SetSystemType(t); } } } if (st.IsGenericTypeParameter) { t = typeParms[0]; st.SetSystemType(t); } } types[i] = st.ToSystemType(); if (pDefinition.Parameters[i].IsRef) { types[i] = types[i].MakeByRefType(); } } SmallType srt = pDefinition.GetReturnType(); if (typeParms != null) { for (int j = 0; j < typeParms.Length; j++) { if (srt.Name == typeParms[j].Name) { srt.SetSystemType(typeParms[j]); } } } mb.SetParameters(types); mb.SetReturnType(srt.ToSystemType()); if (pDefinition.IsMain) { _assembly.SetEntryPoint(CurrentMethod.CallSite, PEFileKinds.ConsoleApplication); var cb = new CustomAttributeBuilder(typeof(STAThreadAttribute).GetConstructor(new Type[] { }), new object[] { }); mb.SetCustomAttribute(cb); } for (short i = 0; i < pDefinition.Parameters.Length; i++) { CreateParameter(i, pDefinition.Parameters[i].Name, pDefinition.Parameters[i].Type, pDefinition.Parameters[i].IsRef); } return(CurrentMethod.CallSite); }
public static GenericTypeSyntax GenericType(SmallType pType) { return(new GenericTypeSyntax(pType)); }
public LLVMValueRef EmitMethodHeader(string pName, Syntax.MethodSyntax pMethod, out string pNewName) { //Get method return type LLVMTypeRef ret; if (pMethod.ReturnValues.Count == 0) { ret = LLVMTypeRef.VoidType(); } else if (pMethod.ReturnValues.Count == 1) { ret = SmallTypeCache.GetLLVMType(pMethod.Type, this); } else { LLVMTypeRef[] types = new LLVMTypeRef[pMethod.ReturnValues.Count]; for (int i = 0; i < types.Length; i++) { types[i] = SmallTypeCache.GetLLVMType(pMethod.ReturnValues[i].Type, this); } ret = LLVM.StructType(types, false); Cache.SetLLVMType(pMethod.Type.Name, ret); } //If we are emitting a struct method we need to add "self" as a parameter SmallType[] originalTypes = new SmallType[pMethod.Parameters.Count]; LLVMTypeRef[] parmTypes = null; int start = 0; if (CurrentStruct != null) { parmTypes = new LLVMTypeRef[pMethod.Parameters.Count + 1]; parmTypes[0] = LLVMTypeRef.PointerType(SmallTypeCache.GetLLVMType(CurrentStruct, this), 0); start = 1; } else { parmTypes = new LLVMTypeRef[pMethod.Parameters.Count]; } //Get parameter types for (int i = 0; i < pMethod.Parameters.Count; i++) { var parmType = pMethod.Parameters[i].Type; if (parmType.IsGenericParameter) { originalTypes[i] = TypeMappings[parmType.Name]; } else { originalTypes[i] = parmType; } //For calling external methods with strings, we only want to pass the character array if (pMethod.External && parmType == SmallTypeCache.String) { parmType = parmType.GetElementType(); } parmTypes[start + i] = SmallTypeCache.GetLLVMType(parmType, this); if (pMethod.Parameters[i].Type.IsStruct || pMethod.Parameters[i].Type.IsArray) { parmTypes[start + i] = LLVMTypeRef.PointerType(parmTypes[start + i], 0); } } var result = Cache.FindMethod(out MethodDefinition pDefinition, null, CurrentStruct, pName, originalTypes); Debug.Assert(result == Compiler.FindResult.Found); pNewName = pDefinition.MangledName; //Method header var func = LLVM.GetNamedFunction(CurrentModule, pNewName); if (func.Pointer == IntPtr.Zero) { func = LLVM.AddFunction(CurrentModule, pNewName, LLVM.FunctionType(ret, parmTypes, false)); LLVM.SetLinkage(func, LLVMLinkage.LLVMExternalLinkage); } if (pMethod.External) { //Create attribute so we can find it later when executing var attribute = LLVM.CreateStringAttribute(_context, "external", 8, pMethod.Annotation.Value, (uint)pMethod.Annotation.Value.Length); LLVM.AddAttributeAtIndex(func, LLVMAttributeIndex.LLVMAttributeFunctionIndex, attribute); } return(func); }
internal GenericTypeSyntax(SmallType pType) : base(null, pType.Name, new List <TypeSyntax>()) { _type = pType; }
public void Request(SmallType smallType, long uval) { HandleSend(new IS_SMALL { ReqI = RequestId, SubT = smallType, UVal = (uint)uval }); }
public bool DeleteSmaillType(SmallType h) { st.SetCtx(db); return(st.Delete(h)); }
public MemberAccess(LLVMValueRef pValue, SmallType pType) { Value = pValue; Type = pType; }
public override void Visit(ImportSyntax pNode) { if (!_importPath.Contains(pNode.Path)) { _importPath.Add(pNode.Path); var path = System.IO.Path.GetFullPath(System.IO.Path.Combine(_path, pNode.Path + ".dll")); Assembly asm = null; try { asm = Assembly.LoadFile(path); } catch (Exception) { Compiler.ReportError(CompilerErrorType.InvalidImport, pNode, pNode.Path); return; } try { System.IO.File.Copy(path, System.IO.Path.Combine(_path, System.IO.Path.GetFileName(path)), true); } catch (Exception) { Compiler.ReportError("Unable to copy import to local directory"); } //Import all types from the import //TODO move this to struct definition thing? foreach (var t in asm.GetTypes()) { if (t.IsValueType && t.IsPublic) { string prefix = ""; var attr = t.GetCustomAttributes <Emitting.TypePrefixAttribute>().SingleOrDefault(); //All exported types must have a TypePrefixAttribute in order to be imported if (attr != null) { // //Create type // prefix = attr.Prefix; //Get any generic type parameters of the type List <string> typeParameters = new List <string>(); if (t.IsGenericType) { var ga = t.GetGenericArguments(); for (int i = 0; i < ga.Length; i++) { typeParameters.Add(ga[i].Name); } } var st = SmallType.RegisterType(pNode.Alias, prefix, true, typeParameters); st.SetSystemType(t); foreach (var f in t.GetFields()) { SmallType fieldType = null; if (f.FieldType.IsGenericParameter) { //If it's a generic type parameter, use the generic type foreach (var s in st.GenericTypeParameters) { if (s.Name.Equals(f.FieldType.Name, StringComparison.OrdinalIgnoreCase)) { fieldType = s; } } } else { fieldType = SmallType.FromSystemType(f.FieldType); } typeParameters.Clear(); //Get field type parameters if (f.FieldType.ContainsGenericParameters) { var typeArguments = t.GetGenericArguments(); foreach (var tp in typeArguments) { if (tp.IsGenericParameter) { typeParameters.Add(tp.Name); } } } st.AddField(f.Name, typeParameters, fieldType); } //Check if we have an initializer function var m = t.GetMethod("Initialize"); if (m != null) { var ii = new InitializerInfo(null); ii.SetMethod(m); st.SetInitializer(ii); } } } } foreach (var t in asm.GetTypes()) { foreach (var m in t.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)) { var p = m.GetParameters(); MethodDefinition.Parameter[] parameters = new MethodDefinition.Parameter[p.Length]; for (int i = 0; i < p.Length; i++) { parameters[i] = new MethodDefinition.Parameter(SmallType.FromSystemType(p[i].ParameterType), p[i].Name, p[i].ParameterType.IsByRef); } SmallType[] returnType; if (m.ReturnType.IsConstructedGenericType) { var types = m.ReturnType.GetGenericArguments(); returnType = new SmallType[types.Length]; for (int i = 0; i < types.Length; i++) { returnType[i] = SmallType.FromSystemType(types[i]); } } else if (m.ReturnType.IsGenericParameter) { returnType = new SmallType[] { SmallType.CreateGenericParameter(m.ReturnType.Name) }; } else if (m.ReturnType != typeof(void)) { returnType = new SmallType[] { SmallType.FromSystemType(m.ReturnType) } } ; else { returnType = new SmallType[0]; } List <SmallType> typeHints = new List <SmallType>(); if (m.IsGenericMethodDefinition) { var typeParameters = m.GetGenericArguments(); foreach (var tp in typeParameters) { if (tp.IsGenericParameter) { typeHints.Add(SmallType.CreateGenericParameter(tp.Name)); } } } MethodDefinition md = null; if (returnType.Length == 1 && parameters.Length == 1 && m.Name == MetadataCache.CastFunction(parameters[0].Type, returnType[0])) { md = MetadataCache.AddImportedCast(pNode.Alias, parameters[0].Type, parameters[0].Name, returnType[0]); } else { md = MetadataCache.AddImportedMethod(pNode.Alias, m.Name, parameters, returnType, typeHints); } md.SetExternMethod(m); } } } if (MetadataCache.ImportedNamespaces().Contains(pNode.Alias)) { Compiler.ReportError(CompilerErrorType.DuplicateImportAlias, pNode, pNode.Alias); } else { MetadataCache.AddNamespace(pNode.Alias); } }
protected override void VisitMethodCallSyntax(MethodCallSyntax pNode) { base.VisitMethodCallSyntax(pNode); SmallType[] types = new SmallType[pNode.Arguments.Count]; for (int i = 0; i < types.Length; i++) { types[i] = pNode.Arguments[i].Type; if (types[i] == SmallTypeCache.NoValue) { CompilerErrors.ExpressionNoValue(pNode.Arguments[i].Span); } } if (SyntaxHelper.HasUndefinedCastAsArg(pNode)) { IList <MethodDefinition> matches = _unit.GetAllMatches(Namespace, pNode.Value, pNode.Arguments.Count); if (matches.Count > 1) { //If multiple matches are found the implicit cast could map to either method, so we can't tell CompilerErrors.InferImplicitCast(pNode.Span); return; } else if (matches.Count == 1) { //Check if we can determine implicit cast type yet for (int j = 0; j < Math.Min(matches[0].ArgumentTypes.Count, pNode.Arguments.Count); j++) { if (SyntaxHelper.IsUndefinedCast(pNode.Arguments[j])) { TrySetImplicitCastType(pNode.Arguments[j], matches[0].ArgumentTypes[j]); types[j] = pNode.Arguments[j].Type; } } } } //Check to ensure this method exists var result = SyntaxHelper.FindMethodOnType(out MethodDefinition m, _unit, Namespace, pNode.Value, CurrentType, types); switch (result) { case Compiler.FindResult.NotFound: CompilerErrors.MethodNotFound(m, Struct, pNode.Value, pNode.Arguments, pNode.Span); return; case Compiler.FindResult.IncorrectScope: CompilerErrors.MethodNotInScope(m, Struct, pNode.Value, pNode.Arguments, pNode.Span); return; } for (int i = 0; i < m.ArgumentTypes.Count; i++) { ForceCastLiteral(m.ArgumentTypes[i], pNode.Arguments[i]); } //Poly our method definition to match any generic types m = m.MakeConcreteDefinition(CurrentType); pNode.SetType(m.ReturnType); }
public override T FromNode <T>(T pNode) { _type = pNode.Type; return(base.FromNode(pNode)); }
public override void Visit(MethodSyntax pNode) { //Create any generic type parameters to the function Dictionary <string, SmallType> typeArgs = new Dictionary <string, SmallType>(); foreach (var t in pNode.TypeHints) { typeArgs.Add(t, SmallType.CreateGenericParameter(t)); } // //Create types for method // //Infer parameter types now that structs have been defined foreach (var p in pNode.Parameters) { var st = SmallType.FromString(p.Namespace, p.Value); if (p.TypeParameters.Count > 0) { SmallType[] types = new SmallType[p.TypeParameters.Count]; for (int i = 0; i < types.Length; i++) { //If the type parameter is one on the method definition, use that type if (typeArgs.ContainsKey(p.TypeParameters[i])) { types[i] = typeArgs[p.TypeParameters[i]]; } else { types[i] = SmallType.FromString("", p.TypeParameters[i]); } } if (!p.Type.IsVariant) { st = st.MakeGenericType(types); } else { //vnt types are transformed to the actual type parameter if (p.TypeParameters.Count > 1) { SmallType[] typeParameters = new SmallType[p.TypeParameters.Count]; for (int i = 0; i < typeParameters.Length; i++) { typeParameters[i] = SmallType.CreateGenericParameter(p.TypeParameters[i]); } st = SmallType.CreateTupleOf(typeParameters); } else { st = SmallType.CreateGenericParameter(p.TypeParameters[0]); } } } p.SetType(st); } foreach (var r in pNode.ReturnValues) { //If the type parameter is one on the method definition, use that type if (typeArgs.ContainsKey(r.Value)) { r.SetType(SmallType.CreateGenericParameter(r.Value)); } else { r.SetType(SmallType.FromString(r.Namespace, r.Value)); } } // //Create method definition // //Create parameters MethodDefinition.Parameter[] parameters = new MethodDefinition.Parameter[pNode.Parameters.Count]; for (int i = 0; i < pNode.Parameters.Count; i++) { parameters[i] = new MethodDefinition.Parameter(pNode.Parameters[i]); } //Create return types SmallType[] returnTypes = new SmallType[pNode.ReturnValues.Count]; for (int i = 0; i < pNode.ReturnValues.Count; i++) { returnTypes[i] = pNode.ReturnValues[i].Type; } var d = MetadataCache.AddMethod(pNode.Name, parameters, returnTypes, typeArgs.Values.ToList()); if (pNode.Annotations.Count > 0) { //Process any standard annotations //run //export //external info foreach (var a in pNode.Annotations) { if (a.Value.Equals("run", StringComparison.OrdinalIgnoreCase)) { if (_mainFound) { Compiler.ReportError(CompilerErrorType.DuplicateRun, pNode); } else { d.IsMain = true; } if (pNode.Parameters.Count > 0 || pNode.ReturnValues.Count > 0) { Compiler.ReportError(CompilerErrorType.InvalidRun, pNode); } _mainFound = true; } else if (a.Value.Equals("export", StringComparison.OrdinalIgnoreCase)) { d.SetScope(Scope.Public); } else if (pNode.External) { var s = a.Value.Split(';'); if (s.Length != 3) { Compiler.ReportError(CompilerErrorType.InvalidExternalAnnotation, pNode); } d.SetExternInfo(s[0], s[1], s[2]); } } if (d.ExternMethod != null && d.Scope == Scope.Public) { Compiler.ReportError(CompilerErrorType.ExportExternal, pNode, pNode.Name); } } pNode.SetDefinition(d); }