[csdoc-patches] csdoc/src/mcsdoc/mcs mcsdoc.exe.config,NONE,1.1 mcsdoc.exe.sources,NONE,1.1 MCSDocUtils.cs,NONE,1.1 ChangeLog.mcsdoc,1.1,1.2

[<mas...@us...>]

Update of /cvsroot/csdoc/csdoc/src/mcsdoc/mcs
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5473

Modified Files:
	ChangeLog.mcsdoc 
Added Files:
	mcsdoc.exe.config mcsdoc.exe.sources MCSDocUtils.cs 
Log Message:
2004-10-30    Gaurav Vaish <mastergaurav AT users DOT sf DOT net>

* mcsdoc.exe.config,
* mcsdoc.exe.sources,
* MCSDocUtils.cs          : Added new files.


--- NEW FILE: mcsdoc.exe.config ---
<configuration>
	<startup>
		<supportedRuntime version="v1.1.4322"/>
	</startup>
  <system.diagnostics>
    <trace autoflush="true" indentsize="4">
      <listeners>
        <add name="compilerLogListener" type="System.Diagnostics.TextWriterTraceListener,System"
             initializeData="mcs.log" />
        <remove type="System.Diagnostics.DefaultTraceListener,System"/>
      </listeners>
    </trace>
  </system.diagnostics>
</configuration>

--- NEW FILE: mcsdoc.exe.sources ---
AssemblyInfo.cs
anonymous.cs
assign.cs
attribute.cs
driver.cs
cs-tokenizer.cs
cfold.cs
class.cs
codegen.cs
const.cs
constant.cs
convert.cs
decl.cs
delegate.cs
enum.cs
ecore.cs
expression.cs
flowanalysis.cs
iterators.cs
literal.cs
location.cs
modifiers.cs
namespace.cs
parameter.cs
pending.cs
report.cs
rootcontext.cs
statement.cs
support.cs
typemanager.cs
symbolwriter.cs
tree.cs
../class/Mono.CSharp.Debugger/MonoSymbolFile.cs
../class/Mono.CSharp.Debugger/MonoSymbolTable.cs
../class/Mono.CSharp.Debugger/MonoSymbolWriter.cs
../class/corlib/Mono.Security.Cryptography/CryptoConvert.cs
MCSDocUtils.cs

--- NEW FILE: MCSDocUtils.cs ---
#region Copyright Notice
/**
 * $Id: MCSDocUtils.cs,v 1.1 2004/10/30 13:45:59 mastergaurav Exp $
 * (C) 2004, Gaurav Vaish
 */
#endregion

using System;
using System.Collections;
using Mono.CSharp;

namespace MCSDoc
{
	internal class MCSDocUtils
	{
		public static void ManageAttributeTypes(ArrayList types)
		{
			if(types == null || types.Count == 0)
				return;
			Console.WriteLine("\nRoot Type:");
			foreach(TypeContainer tc in types)
			{
				Console.WriteLine("           " + tc.Name);
			}
			Console.WriteLine();
		}

		public static void ManageTypeContainer(TypeContainer container)
		{
			//ManageTypeContainer("", tc);
			ListAllMembers(container);
		}

		static void ListAllMembers(TypeContainer root)
		{
			if(root.NamespaceEntry != null && root.NamespaceEntry.FullName.Length > 0)
			{
				Console.WriteLine("Root Namespace: " + root.NamespaceEntry.FullName);
				Console.WriteLine();
			} else
			{
				Console.WriteLine("No root namespace.\n");
			}
			ListTCs("", root, true);
		}

		static void ListTCs(string tab, TypeContainer tc, bool root)
		{
			if(!root)
			{
				string ttype = "Struct: ";
				if(tc is Class)
					ttype = "Class:  ";
				Console.WriteLine(ttype + /*tab + */ tc.Name);// + " -:- " + objs.BaseType);
				//Console.WriteLine("Documentation: \n" + tc.Documentation);
				//Console.WriteLine();
			}
			if(tc.Types != null && tc.Types.Count > 0)
			{
				foreach(TypeContainer objs in tc.Types)
				{
					if(objs.Documentation.Trim().Length > 0)
					{
						string type = "Struct: ";
						if(objs is Class)
							type = "Class:  ";
						Console.WriteLine(type + /*tab + */ objs.Name);// + " -:- " + objs.BaseType);
						/*
						if(IsException(objs))
						{
							Console.WriteLine("\t\t" + objs.Name + " is Exception");
						} else if(IsAttribute(objs))
						{
							Console.WriteLine("\t\t" + objs.Name + " is Attribute");
						}
						*/
						//Console.WriteLine("Documentation: \n" + objs.Documentation);
						//Console.WriteLine();
					}
					ListTCs(tab + "\t", objs, false);
				}
			}
			ListEnums(tab, tc.Enums);
			ListInterfaces(tab, tc.Interfaces);
			ListDelegates(tab, tc.Delegates);
		}

		static bool IsException(TypeContainer tc)
		{
			Type baseType = tc.BaseType;
			return (baseType == TypeManager.exception_type ||
				   baseType.IsSubclassOf(TypeManager.exception_type));
		}

		static bool IsAttribute(TypeContainer tc)
		{
			Type baseType = tc.BaseType;
			return (baseType == TypeManager.attribute_type ||
				   baseType.IsSubclassOf(TypeManager.attribute_type));
		}

		static void ListEnums(string tab, ArrayList enums)
		{
			if(enums != null && enums.Count > 0)
			{
				foreach(Mono.CSharp.Enum e in enums)
				{
					if(e.Documentation.Length > 0)
					{
						Console.WriteLine("Enum:   " + /* tab + */ e.Name);
						//Console.WriteLine("Documentation: \n" + e.Documentation);
						//Console.WriteLine();
					}
				}
			}
		}

		static void ListInterfaces(string tab, ArrayList interfaces)
		{
			if(interfaces != null && interfaces.Count > 0)
			{
				foreach(Interface i in interfaces)
				{
					if(i.Documentation.Length > 0)
					{
						Console.WriteLine("Iface:  " + /* tab + */ i.Name);
						//Console.WriteLine("Documentation: \n" + i.Documentation);
						//Console.WriteLine();
					}
				}
			}
		}

		static void ListDelegates(string tab, ArrayList delegs)
		{
			if(delegs != null && delegs.Count > 0)
			{
				foreach(Mono.CSharp.Delegate d in delegs)
				{
					if(d.Documentation.Length > 0)
					{
						Console.WriteLine("Deleg:  " + /* tab + */ d.Name);
						//Console.WriteLine("Documentation: \n" + d.Documentation);
						//Console.WriteLine();
					}
				}
			}
		}
	}
}
Index: ChangeLog.mcsdoc
===================================================================
RCS file: /cvsroot/csdoc/csdoc/src/mcsdoc/mcs/ChangeLog.mcsdoc,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** ChangeLog.mcsdoc	30 Oct 2004 07:17:23 -0000	1.1
--- ChangeLog.mcsdoc	30 Oct 2004 13:45:59 -0000	1.2
***************
*** 2,5 ****
--- 2,11 ----
  2004-10-30    Gaurav Vaish <mastergaurav AT users DOT sf DOT net>
  
+ 	* mcsdoc.exe.config,
+ 	* mcsdoc.exe.sources,
+ 	* MCSDocUtils.cs          : Added new files.
+ 
+ 2004-10-30    Gaurav Vaish <mastergaurav AT users DOT sf DOT net>
+ 
  	* ChangeLog.mcsdoc        : Will contain all changes done by me. ChangeLog
  	                            contains all modifications by mono team.