public static CompletionItem Build(CodeObject m) { if(m is CodeMemberMethodEx) { var method = m as CodeMemberMethodEx; return new CompletionItemMethod(method.Name, string.Format("Method {0}({1})\n{2}", method.Name, method.GetParamInfo(), GetDocumentCommentString(method.Comments))); }else if(m is CodeTypeDeclaration && ((CodeTypeDeclaration)m).IsClass) { var classdecl = ((CodeTypeDeclaration)m); return new CompletionItemClass(classdecl.Name, string.Format("class {0}\n{1}", classdecl.Name, GetDocumentCommentString(classdecl.Comments))); }else if(m is CodeMemberProperty) { var prop = ((CodeMemberProperty)m); if((prop.Attributes & MemberAttributes.Static) == MemberAttributes.Static) return new CompletionItemPropertyStatic(prop.Name, string.Format("Property {0}\n{1}", prop.Name, GetDocumentCommentString(prop.Comments))); else return new CompletionItemProperty(prop.Name, string.Format("Property {0}\n{1}", prop.Name, GetDocumentCommentString(prop.Comments))); }else if(m is CodeMemberField) { var prop = ((CodeMemberField)m); return new CompletionItemField(prop.Name, string.Format("Field {0}\n{1}", prop.Name, GetDocumentCommentString(prop.Comments))); } else if(m is CodeParameterDeclarationExpression) { var argument = m as CodeParameterDeclarationExpression; return new CompletionItemField(argument.Name, string.Format("Argument {0}", argument.Name)); } else throw new NotSupportedException("Cant handle obj type: " + m.GetType().ToString()); //return /* new CompletionItem(m.ToString(), ""); */ }
internal void ValidateIdentifiers(CodeObject e) { if (e is CodeCompileUnit) { ValidateCodeCompileUnit((CodeCompileUnit)e); } else if (e is CodeComment) { ValidateComment((CodeComment)e); } else if (e is CodeExpression) { ValidateExpression((CodeExpression)e); } else if (e is CodeNamespace) { ValidateNamespace((CodeNamespace)e); } else if (e is CodeNamespaceImport) { ValidateNamespaceImport((CodeNamespaceImport)e); } else if (e is CodeStatement) { ValidateStatement((CodeStatement)e); } else if (e is CodeTypeMember) { ValidateTypeMember((CodeTypeMember)e); } else if (e is CodeTypeReference) { ValidateTypeReference((CodeTypeReference)e); } else if (e is CodeDirective) { ValidateCodeDirective((CodeDirective) e); } else { throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e"); } }
private void Process(ref CodeObject target, CodeObject parent, int indent) { CodeMethodInvokeExpression methodInvokeExpr = target as CodeMethodInvokeExpression; if (methodInvokeExpr != null && methodInvokeExpr.Method.TargetObject == null && StringUtils.CaseInsensitiveEquals(methodInvokeExpr.Method.MethodName, "CreateObject") && methodInvokeExpr.Parameters.Count == 1) { CodePrimitiveExpression primitiveExpr = methodInvokeExpr.Parameters[0] as CodePrimitiveExpression; if (primitiveExpr != null) { string progId = primitiveExpr.Value as string; if (progId != null) { Type type = (_importer == null ? Type.GetTypeFromProgID(progId) : _importer.ImportProgId(progId)); if (type != null) { target = new CodeObjectCreateExpression(Utils.CreateTypeReference(type)); } } } } }
public override void Generate(CodeObject codeObject, Entity entity) { var contentType = (ContentType) entity; var type = (CodeTypeDeclaration) codeObject; AddStructure(type, contentType); }
public CodeDomWalker(CodeObject rootObject) { _rootObjects = new object[] { rootObject }; }
static string Dump(CodeObject co) { var cse = co as CodeSnippetExpression; if(cse != null) return cse.Value; throw new NotImplementedException(); }
internal static void CloneUserData(CodeObject original, CodeObject result) { foreach (object obj2 in original.UserData.Keys) { object key = CloneObject(obj2); object obj4 = CloneObject(original.UserData[obj2]); result.UserData.Add(key, obj4); } }
public override void Generate(CodeObject codeObject, Entity entity) { var type = (CodeTypeDeclaration)codeObject; var contentType = (ContentType) entity; var info = contentType.Info; AddFieldIfNotEmpty(type, "icon", info.Icon); AddFieldIfNotEmpty(type, "thumbnail", info.Thumbnail); AddFieldIfTrue(type, "allowAtRoot", info.AllowAtRoot); }
public override void Generate(CodeObject codeObject, Entity entity) { var description = (EntityDescription) entity; var type = (CodeTypeMember)codeObject; ValidateAlias(description); SetName(type, description); AddDisplayNameIfDifferent(type, description); AddDescription(type, description); }
public override void Generate(CodeObject codeObject, Entity entity) { var propNode = (CodeMemberProperty) codeObject; var property = (GenericProperty) entity; var contentRef = new CodePropertyReferenceExpression(null, "Content"); var getPropertyValueMethod = new CodeMethodReferenceExpression(contentRef, "GetPropertyValue", propNode.Type); var getPropertyValueCall = new CodeMethodInvokeExpression(getPropertyValueMethod, new CodePrimitiveExpression(property.Alias)); propNode.GetStatements.Add(new CodeMethodReturnStatement(getPropertyValueCall)); }
public override void Generate(CodeObject codeObject, Entity entity) { var contentType = (ContentType) entity; var info = (DocumentTypeInfo) contentType.Info; var type = (CodeTypeDeclaration) codeObject; base.Generate(type, contentType); AddFieldIfNotEmpty(type, "defaultTemplate", info.DefaultTemplate); AddAllowedTemplates(type, info); }
private void WalkList(IList list, CodeObject parent, int indent) { for (int i = 0; i < list.Count; i++) { CodeObject obj = list[i] as CodeObject; if (obj != null && WalkObject(ref obj, parent, indent)) { list[i] = obj; } } }
public override void Generate(CodeObject codeObject, Entity entity) { var compileUnit = (CodeCompileUnit) codeObject; if (String.IsNullOrWhiteSpace(Config.Namespace)) throw new Exception("ContentType namespace not configured."); var ns = new CodeNamespace(Config.Namespace); compileUnit.Namespaces.Add(ns); foreach(var generator in memberGenerators) generator.Generate(ns, entity); }
public override void Generate(CodeObject codeObject, Entity entity) { var type = (CodeTypeDeclaration) codeObject; var contentType = (ContentType) entity; foreach (var property in contentType.GenericProperties) { var propNode = new CodeMemberProperty(); foreach(var generator in propertyGenerators) generator.Generate(propNode, property); type.Members.Add(propNode); } }
public override void Generate(CodeObject codeObject, Entity entity) { var property = (GenericProperty)entity; var propNode = (CodeMemberProperty) codeObject; SetType(propNode, property); foreach (var generator in memberGenerators) generator.Generate(codeObject, property); AddDataType(propNode, property); AddCategory(propNode, property); AddRequired(propNode, property); AddValidation(propNode, property); }
public override void Generate(CodeObject codeObject, Entity entity) { var contentType = (ContentType) entity; var info = contentType.Info; var ns = (CodeNamespace)codeObject; var type = new CodeTypeDeclaration(); ns.Types.Add(type); entityDescriptionGenerator.Generate(type, info); SetBaseClass(type, info); if (memberGenerators != null) foreach(var generator in memberGenerators) generator.Generate(type, contentType); }
public override void Generate(CodeObject codeObject, Entity entity) { var type = (CodeTypeDeclaration) codeObject; var ctor = new CodeConstructor { Attributes = MemberAttributes.Public }; ctor.Parameters.Add( new CodeParameterDeclarationExpression( "IPublishedContent", "content" ) ); ctor.BaseConstructorArgs.Add( new CodeVariableReferenceExpression("content") ); type.Members.Add(ctor); }
private void Localize(ref CodeObject target, CodeObject parent, int indent) { CodeMethodInvokeExpression methodInvokeExpr = target as CodeMethodInvokeExpression; if (methodInvokeExpr != null && methodInvokeExpr.Parameters.Count == 1 && methodInvokeExpr.Method.TargetObject != null) { CodeObjectSource source = CodeObjectMetaData.GetExpressionSource(methodInvokeExpr.Method.TargetObject); if (source != null && source.Target == typeof (ITranslator) && source.ArrayRanks.Length == 0) { CodePrimitiveExpression primitiveExpr = methodInvokeExpr.Parameters[0] as CodePrimitiveExpression; if (primitiveExpr != null) { string value = primitiveExpr.Value as string; if (value != null) { string baseName = GenerateResourceName(value); int counter = 0; string name = baseName; string existingValue; while (_localizedStrings.TryGetValue(name, out existingValue) && value != existingValue) { name = baseName + (++counter); } target = new CodePropertyReferenceExpression( new CodeTypeReferenceExpression( new CodeTypeReference( _namespaceName + (string.IsNullOrEmpty(_namespaceName) ? string.Empty : ".") + "Properties.Resources")), name); if (existingValue == null) { _localizedStrings.Add(name, value); } } } } } }
public void Convert(CodeObject code) { if (code is CodeCompileUnit) { foreach (CodeTypeMember member in ((CodeCompileUnit)code).Namespaces[0].Types[0].Members) { if (member is CodeEntryPointMethod) EmitStatements(((CodeEntryPointMethod)member).Statements); else EmitMethod((CodeMemberMethod)member); } } else if (code is CodeEntryPointMethod || code is CodeMemberMethod) EmitMethod((CodeMemberMethod)code); else if (code is CodeStatement) EmitStatement((CodeStatement)code); writer.WriteLine(); }
public static string GenerateCode(CodeObject codeObj) { var provider = new CSharpCodeProvider(); using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { if (codeObj is CodeCompileUnit) { provider.GenerateCodeFromCompileUnit(codeObj as CodeCompileUnit, writer, null); } else if (codeObj is CodeExpression) { provider.GenerateCodeFromExpression(codeObj as CodeExpression, writer, null); } else if (codeObj is CodeStatement) { provider.GenerateCodeFromStatement(codeObj as CodeStatement, writer, null); } else if (codeObj is CodeTypeMember) { provider.GenerateCodeFromMember(codeObj as CodeTypeMember, writer, null); } else if (codeObj is CodeNamespace) { provider.GenerateCodeFromNamespace(codeObj as CodeNamespace, writer, null); } else { throw new InvalidOperationException(); } writer.Flush(); stream.Position = 0; using (var reader = new StreamReader(stream)) { return reader.ReadToEnd(); } } }
private void Factorize(ref CodeObject target, CodeObject parent, int indent) { CodeTypeReference typeRef = target as CodeTypeReference; if (typeRef != null) { CodeObjectSource source = Utils.GetTypeReferenceSource(typeRef); if (source != null) { Type type = source.Target as Type; if (type != null && type != typeof (void) && type != typeof (object) && type != typeof (string) && type != typeof (decimal) && !type.IsPrimitive) { string baseType = typeRef.BaseType; int pos = baseType.LastIndexOf('.'); if (pos >= 0) { string name = baseType.Substring(0, pos); if (name != _currentNameSpaceName) { _namespaceNames.Add(name); } typeRef.BaseType = baseType.Substring(pos + 1); } } } } }
private void Gather(ref CodeObject target, CodeObject parent, int depth) { CodeTypeReference typeRef = target as CodeTypeReference; if (typeRef != null) { CodeObjectSource source = Utils.GetTypeReferenceSource(typeRef); if (source != null) { Type type = source.Target as Type; if (type != null) { Assembly assembly = type.Assembly; if (assembly != _mscorlibAssembly && assembly != _thisAssembly && !_references.ContainsKey(assembly.FullName)) { _references.Add(assembly.FullName, (assembly.GlobalAssemblyCache ? null : assembly.Location)); } } } } }
private void Correct(ref CodeObject target, CodeObject parent, int indent) { if (target is CodeVariableReferenceExpression) { CodeVariableReferenceExpression variableExpr = (CodeVariableReferenceExpression) target; if (StringUtils.CaseInsensitiveEquals(variableExpr.VariableName, _setValueName)) { variableExpr.VariableName = _propertyName; } } else if (target is CodeMethodInvokeExpression) { CodeMethodInvokeExpression methodInvokeExpr = (CodeMethodInvokeExpression) target; if (methodInvokeExpr.Method.TargetObject == null && StringUtils.CaseInsensitiveEquals(methodInvokeExpr.Method.MethodName, _setValueName)) { CodeIndexerExpression indexerExpr = new CodeIndexerExpression( new CodeVariableReferenceExpression(_propertyName)); indexerExpr.Indices.AddRange(methodInvokeExpr.Parameters); target = indexerExpr; } } }
/// <summary> /// Set the user data with key 'MethodMemberInfo' of the specified CodeObject to a method /// from the <see cref="InfoApe"/> class. The MethodInfo resolution is done /// through a <see cref="MethodInfo.GetMethod(string)"/> signature. /// </summary> /// <param name="codeTypeMember">The code type member which gets the <see cref="MethodInfo.UserData"/> 'MethodMemberInfo' set.</param> /// <param name="methodSignature">The signature of the desired method.</param> private static MethodInfo SetUserData(CodeObject codeTypeMember, string methodSignature) { MethodInfo methodInfo = typeof(InfoApe).GetMethod(methodSignature); codeTypeMember.UserData[NStubConstants.TestMemberMethodInfoKey] = methodInfo; return methodInfo; }
public override void Generate(CodeObject codeObject, Entity entity) { var ns = (CodeNamespace) codeObject; AddImports(ns); }
/// <summary> /// Set the parameter index on the CodeExpression using /// EvaluationData. /// </summary> /// <param name="toSet">CodeExpression on which to set the /// parameter index.</param> /// <param name="parameterIndex">Index to set.</param> public static void SetParameterIndex(CodeObject toSet, int parameterIndex) { EvaluationData data = toSet.UserData[typeof(EvaluationData)] as EvaluationData; if (data == null) { data = new EvaluationData(); toSet.UserData.Add(typeof(EvaluationData), data); } data.ParameterIndex = parameterIndex; }
/// <summary> /// Get the CodeExpression object's corresponding index /// into the IExpressionEvaluator's parameter list using /// EvaluationData. /// </summary> /// <param name="toGet">Expression for which to get the /// parameter.</param> /// <param name="throwIfNotExist">Whether to throw an /// exception if the parameter cannot be found. True to /// throw.</param> /// <returns>The index into the parameter list for this /// expression's replacement value.</returns> public static int GetParameterIndex(CodeObject toGet, bool throwIfNotExist) { EvaluationData data = toGet.UserData[typeof(EvaluationData)] as EvaluationData; if (data == null) { if (throwIfNotExist) { throw new ApplicationException("No EvaluationData from which to extract the parameter."); } return -1; } else { return data.ParameterIndex; } }
/// <summary> /// Helper method used for getting the type of /// a CodeExpression through use of EvaluationData. /// </summary> /// <param name="toGet">CodeExpression which is adorned /// with type information.</param> /// <param name="throwIfNotExist">Whether to throw an /// exception if the type data is not available. True to /// throw.</param> /// <returns>The type of the result of the CodeExpression.</returns> public static Type GetType(CodeObject toGet, bool throwIfNotExist) { EvaluationData data = toGet.UserData[typeof(EvaluationData)] as EvaluationData; if (data == null) { if (throwIfNotExist) { throw new ApplicationException("The expression did not contain an EvaluationData object."); } return null; } else { return data.Type; } }
/// <summary> /// Helper method used for setting the type of /// a CodeExpression through use of EvaluationData. /// </summary> /// <param name="toSet">CodeExpression to adorn with /// type information.</param> /// <param name="newType">Type of the CodeExpression's result.</param> public static void SetType(CodeObject toSet, Type newType) { EvaluationData data = toSet.UserData[typeof(EvaluationData)] as EvaluationData; if (data == null) { data = new EvaluationData(); toSet.UserData.Add(typeof(EvaluationData), data); } data.Type = newType; }
private bool GetUserData(CodeObject e, string property, bool defaultValue) { object obj2 = e.UserData[property]; if ((obj2 != null) && (obj2 is bool)) { return (bool)obj2; } return defaultValue; }