public MethodRegistration(string className, string luaMethodName, string nativeMethodName, string registrationMethodName, FilePosition filePosition) { ClassName = className; LuaMethodName = luaMethodName; NativeMethodName = nativeMethodName; RegistrationMethodName = registrationMethodName; MethodPosition = new MethodPosition(filePosition, className, registrationMethodName); }
private static void CheckTextAnnotation(Annotation[] annotations, MethodPosition methodPosition, WarningList warnings) { int textAnnotationCount = annotations.OfType <TextAnnotation>().Count(); if (textAnnotationCount == 0) { warnings.Add(methodPosition, WarningType.MissingAnnotation, "Missing @text annotation."); } else if (textAnnotationCount > 1) { warnings.Add(methodPosition, WarningType.UnexpectedAnnotation, "Multiple @text annotations."); } }
public static void ParseMethodDefinitions(string code, FilePosition filePosition, TypeCollection types, WarningList warnings) { // Find all method definitions var matches = methodDefinitionRegex.Matches(code); // Parse method definitions foreach (Match match in matches) { string className = match.Groups["className"].Value; string nativeMethodName = match.Groups["methodName"].Value; var methodPosition = new MethodPosition(filePosition, className, nativeMethodName); // Parse annotations, filtering out unknown ones Annotation[] annotations = match.Groups["annotation"].Captures .Cast <Capture>() .Select(capture => Annotation.Create(capture.Value, methodPosition, warnings)) .ToArray(); foreach (var unknownAnnotation in annotations.OfType <UnknownAnnotation>()) { warnings.Add(methodPosition, WarningType.UnexpectedAnnotation, "Unknown annotation command '{0}'.", unknownAnnotation.Command); } annotations = annotations .Where(annotation => !(annotation is UnknownAnnotation)) .ToArray(); // Get method body int openingBraceIndex = match.Index + match.Length - 1; int blockLength = BlockParser.GetBlockLength(code, openingBraceIndex); string methodBody = code.Substring(openingBraceIndex + 1, blockLength - 2); // Parse annotation block MoaiClass moaiClass = types.GetOrCreate(className, methodPosition) as MoaiClass; if (moaiClass != null) { if (annotations.Any()) { ParseMethodDocumentation(moaiClass, annotations, methodBody, methodPosition, types, warnings); } else if (nativeMethodName.StartsWith("_")) { warnings.Add(methodPosition, WarningType.MissingAnnotation, "Missing method documentation."); } } } }
private static void ParseMethodDocumentation(MoaiClass moaiClass, Annotation[] annotations, string methodBody, MethodPosition methodPosition, TypeCollection types, WarningList warnings) { Method method = CreateMethod(moaiClass, annotations, methodPosition, types, warnings); if (method == null) { return; } // Fill method body method.Body = methodBody; // Create compact method signature CreateCompactSignature(method, warnings); // Determine if overloads are static foreach (MethodOverload overload in method.Overloads) { var firstInParam = overload.InParameters.FirstOrDefault(); overload.IsStatic = firstInParam == null || firstInParam.Name != "self"; } }
private static LuaNameAnnotation GetNameAnnotation(MoaiClass moaiClass, Annotation[] annotations, MethodPosition methodPosition, WarningList warnings) { // Check that there is a single @lua annotation and that it isn't a duplicate. Otherwise exit. int luaNameAnnotationCount = annotations.OfType <LuaNameAnnotation>().Count(); if (luaNameAnnotationCount == 0) { warnings.Add(methodPosition, WarningType.MissingAnnotation, "Missing @lua annotation."); return(null); } if (luaNameAnnotationCount > 1) { warnings.Add(methodPosition, WarningType.UnexpectedAnnotation, "Multiple @lua annotations."); } var nameAnnotation = annotations.OfType <LuaNameAnnotation>().First(); if (moaiClass.Members.Any(member => member.Name == nameAnnotation.Value)) { warnings.Add(methodPosition, WarningType.UnexpectedValue, "There is already a member with Lua name '{0}'.", nameAnnotation.Value); return(null); } return(nameAnnotation); }
private static Method CreateMethod(MoaiClass moaiClass, Annotation[] annotations, MethodPosition methodPosition, TypeCollection types, WarningList warnings) { // Get @lua annotation var luaNameAnnotation = GetNameAnnotation(moaiClass, annotations, methodPosition, warnings); if (luaNameAnnotation == null) { return(null); } // Check that there is a single @text annotation CheckTextAnnotation(annotations, methodPosition, warnings); // Parse annotations var method = new Method { MethodPosition = methodPosition, Name = luaNameAnnotation.Value, OwningClass = moaiClass, }; moaiClass.Members.Add(method); MethodOverload currentOverload = null; foreach (var annotation in annotations) { if (annotation is LuaNameAnnotation) { // Nothing to do - name has already been set. } else if (annotation is TextAnnotation) { // Set method description method.Description = ((TextAnnotation)annotation).Value; } else if (annotation is ParameterAnnotation) { if (currentOverload == null) { currentOverload = new MethodOverload { OwningMethod = method }; method.Overloads.Add(currentOverload); } var parameterAnnotation = (ParameterAnnotation)annotation; string paramName = parameterAnnotation.Name; if (annotation is InParameterAnnotation | annotation is OptionalInParameterAnnotation) { // Add input parameter if (currentOverload.InParameters.Any(param => param.Name == paramName)) { warnings.Add(methodPosition, WarningType.UnexpectedValue, "Found multiple params with name '{0}' for single overload.", paramName); } var inParameter = new InParameter { Name = paramName, Description = parameterAnnotation.Description, Type = types.GetOrCreate(parameterAnnotation.Type, methodPosition), IsOptional = annotation is OptionalInParameterAnnotation }; currentOverload.InParameters.Add(inParameter); } else { // Add output parameter var outParameter = new OutParameter { Name = paramName, Type = types.GetOrCreate(parameterAnnotation.Type, methodPosition), Description = parameterAnnotation.Description }; currentOverload.OutParameters.Add(outParameter); } } else if (annotation is OverloadAnnotation) { // Let the next parameter annotation start a new override currentOverload = null; } else { warnings.Add(methodPosition, WarningType.UnexpectedAnnotation, "Unexpected {0} annotation.", annotation.Command); } } return(method); }