Files
mono/mcs/class/System/System.CodeDom.Compiler/CodeDomConfigurationHandler.cs
T
Miguel de Icaza a5bd130af9 2006-03-11 Miguel de Icaza <[email protected]>
* Uri.cs: Pragma disable warning 612 (Obsolete methods are being
	used by us internally).

	Ponder: should we instead move our methods to use new versions of
	the Obsoleted ones?

2006-03-11  Miguel de Icaza  <[email protected]>

	* CodeNamespaceImportCollection.cs: It turns out that a lot of the
	errors flagged with "!" were just missing explicit interface
	implementations.  

	Implement.

2006-03-11  Miguel de Icaza  <[email protected]>

	* CodeDomConfigurationHandler.cs: Comment out unused methods. 

	* TempFileCollection.cs: Implement explicitly some interface
	methods to get rid of the "!" errors on CorCompare.

2006-03-11  Miguel de Icaza  <[email protected]>

	* Queue.cs: Flag as serializable.

	* LinkedList.cs (OnDeserialization): Fix signature. 

	* SortedList.cs: Implement explicitly a few methods that were
	flagged by corcompare. 

2006-03-11  Miguel de Icaza  <[email protected]>

	* IOrderedDictionary.cs: Flag GetEnumerator as a "new" method to
	avoid warning.

2006-03-11  Miguel de Icaza  <[email protected]>

	* ConfigurationSettings.cs (ChangeConfigurationSettings): Make
	internal to avoid warnings.  This routine is called from
	System.Web with MethodInfo.Invoke.

2006-03-11  Miguel de Icaza  <[email protected]>

	* DeflateStream.cs: Comment out DllImport that was not being
	used. 

2006-03-11  Miguel de Icaza  <[email protected]>

	* y

	* SerialPort.cs: Remove unused variable (writeBuffer). 

	* SerialPortStream.cs (Dispose): override, not new.

2006-03-11  Miguel de Icaza  <[email protected]>

	* WebClient.cs: Only expose the right methods to avoid warnings. 

	* FtpDataStream.cs (Dispose): Fix signature.

	* FtpWebResponse.cs: Comment out keepAlive field (unused, sounds
	like we are missing features here).

	* IPAddress.cs: Move m_HashCode property to the end, and set
	pragmas to disable warnings.

2006-03-11  Miguel de Icaza  <[email protected]>

	* MailAddress.cs: Comment out unused field to remove warning. 

2006-03-11  Miguel de Icaza  <[email protected]>

	* NetworkChange.cs: Use pragmas to eliminate warnings from events
	that we do not trigger yet.

	This is a candidate for using Aaron's NetworkManager code.  But
	would make us depend on d-bus.

	* NetworkInformationException.cs: Use error_code for ErrorCode,
	instead of NativeErrorCode.   Fixes warning. 

2006-03-11  Miguel de Icaza  <[email protected]>

	* AuthenticatedStream.cs: Fixed normative parameter names (yes, we
	need to do this everywhere one day).

	(Close): actually obey the "leaveInnerStreamOpen" setting from the
	constructor. 

2006-03-11  Miguel de Icaza  <[email protected]>

	* NetworkStream.cs (Dispose): Use the right signature depending on
	the profile being built.

2006-03-11  Miguel de Icaza  <[email protected]>

	* X509Chain.cs: Flagged member as internal to avoid unused warning.

	* X500DistinguishedName.cs: Comment out unused names and move
	temporary unused variables inside the comments that were removed 



svn path=/trunk/mcs/; revision=57836
2006-03-11 19:07:56 +00:00

358 lines
9.5 KiB
C#

//
// System.Configuration.CodeDomConfigurationHandler
//
// Authors:
// Gonzalo Paniagua Javier ([email protected])
//
// Copyright (c) 2005 Novell, Inc (http://www.novell.com)
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if NET_2_0
using System;
using System.Collections;
using System.Configuration;
using System.IO;
#if XML_DEP
using System.Xml;
#endif
namespace System.CodeDom.Compiler
{
#if XML_DEP
class CodeDomConfigurationHandler : IConfigurationSectionHandler
{
public object Create (object parent, object context, XmlNode section)
{
return new CompilationConfigurationHandler ().Create (parent, context, section);
}
}
class CompilationConfigurationHandler : IConfigurationSectionHandler
{
public object Create (object parent, object context, XmlNode section)
{
CompilationConfiguration config = new CompilationConfiguration (parent);
config.TempDirectory = AttValue ("tempDirectory", section, true);
config.DefaultLanguage = AttValue ("defaultLanguage", section);
if (config.DefaultLanguage == null)
config.DefaultLanguage = "c#";
config.Debug = AttBoolValue ("debug", section, false);
config.Batch = AttBoolValue ("batch", section, false);
config.Explicit = AttBoolValue ("explicit", section, true);
config.Strict = AttBoolValue ("strict", section, false);
config.BatchTimeout = AttUIntValue ("batchTimeout", section, 0);
config.MaxBatchSize = AttUIntValue ("maxBatchSize", section, 0);
config.MaxBatchFileSize = AttUIntValue ("maxBatchFileSize", section, 0);
config.NumRecompilesBeforeAppRestart =
AttUIntValue ("numRecompilesBeforeAppRestart", section, 15);
if (section.Attributes != null && section.Attributes.Count != 0)
ThrowException ("Unrecognized attribute.", section);
XmlNodeList authNodes = section.ChildNodes;
foreach (XmlNode child in authNodes) {
XmlNodeType ntype = child.NodeType;
if (ntype != XmlNodeType.Element)
continue;
if (child.Name == "compilers") {
ReadCompilers (child.ChildNodes, config);
continue;
}
ThrowException ("Unexpected element", child);
}
return config;
}
static void ReadCompilers (XmlNodeList nodes, CompilationConfiguration config)
{
foreach (XmlNode child in nodes) {
XmlNodeType ntype = child.NodeType;
if (ntype != XmlNodeType.Element)
continue;
if (child.Name != "compiler")
ThrowException ("Unexpected element", child);
CompilerInfo compiler = new CompilerInfo ();
compiler.Languages = AttValue ("language", child);
compiler.Extensions = AttValue ("extension", child);
compiler.TypeName = AttValue ("type", child);
compiler.CompilerOptions = AttValue ("compilerOptions", child, true, true);
compiler.WarningLevel = AttUIntValue ("warningLevel", child, 0);
config.Compilers [compiler.Languages] = compiler;
}
}
static string AttValue (string name, XmlNode node, bool optional)
{
return AttValue (name, node, optional, false);
}
static string AttValue (string name, XmlNode node, bool optional, bool allowEmpty)
{
return ExtractAttributeValue (name, node, optional, allowEmpty);
}
static bool AttBoolValue (string name, XmlNode node, bool _default)
{
string v = AttValue (name, node, true);
if (v == null)
return _default;
bool result = (v == "true");
if (!result && v != "false")
ThrowException ("Invalid boolean value in " + name, node);
return result;
}
static int AttUIntValue (string name, XmlNode node, int _default)
{
string v = AttValue (name, node, true);
if (v == null)
return _default;
int result = 0;
try {
result = (int) UInt32.Parse (v);
} catch {
ThrowException ("Invalid number in " + name, node);
}
return result;
}
static string AttValue (string name, XmlNode node)
{
return ExtractAttributeValue (name, node, true);
}
#if false
// Not used for now
static string ShortAsmName (string long_name)
{
int i = long_name.IndexOf (',');
if (i < 0)
return long_name + ".dll";
return long_name.Substring (0, i) + ".dll";
}
#endif
static void ThrowException (string message, XmlNode node)
{
ThrowException (message, node);
}
static internal string ExtractAttributeValue (string attKey, XmlNode node)
{
return ExtractAttributeValue (attKey, node, false);
}
static internal string ExtractAttributeValue (string attKey, XmlNode node, bool optional)
{
return ExtractAttributeValue (attKey, node, optional, false);
}
static internal string ExtractAttributeValue (string attKey, XmlNode node, bool optional,
bool allowEmpty)
{
if (node.Attributes == null) {
if (optional)
return null;
ThrowException ("Required attribute not found: " + attKey, node);
}
XmlNode att = node.Attributes.RemoveNamedItem (attKey);
if (att == null) {
if (optional)
return null;
ThrowException ("Required attribute not found: " + attKey, node);
}
string value = att.Value;
if (!allowEmpty && value == String.Empty) {
string opt = optional ? "Optional" : "Required";
ThrowException (opt + " attribute is empty: " + attKey, node);
}
return value;
}
}
#endif // XML_DEP
sealed class CompilationConfiguration
{
bool debug;
bool batch;
int batch_timeout;
string default_language = "c#";
bool _explicit = true;
int max_batch_size = 30;
int max_batch_file_size = 3000;
int num_recompiles_before_app_restart = 15;
bool strict;
string temp_directory;
CompilerCollection compilers;
/* Only the config. handler should create instances of this. Use GetInstance (context) */
public CompilationConfiguration (object p)
{
CompilationConfiguration parent = p as CompilationConfiguration;
if (parent != null)
Init (parent);
if (compilers == null)
compilers = new CompilerCollection ();
if (temp_directory == null)
temp_directory = Path.GetTempPath ();
}
public CompilerInfo GetCompilerInfo (string language)
{
return Compilers [language];
}
void Init (CompilationConfiguration parent)
{
debug = parent.debug;
batch = parent.batch;
batch_timeout = parent.batch_timeout;
default_language = parent.default_language;
_explicit = parent._explicit;
max_batch_size = parent.max_batch_size;
max_batch_file_size = parent.max_batch_file_size;
num_recompiles_before_app_restart = parent.num_recompiles_before_app_restart;
strict = parent.strict;
temp_directory = parent.temp_directory;
compilers = new CompilerCollection (parent.compilers);
}
public bool Debug {
get { return debug; }
set { debug = value; }
}
public bool Batch {
get { return batch; }
set { batch = value; }
}
public int BatchTimeout {
get { return batch_timeout; }
set { batch_timeout = value; }
}
public string DefaultLanguage {
get { return default_language; }
set { default_language = value; }
}
public bool Explicit {
get { return _explicit; }
set { _explicit = value; }
}
public int MaxBatchSize {
get { return max_batch_size; }
set { max_batch_size = value; }
}
public int MaxBatchFileSize {
get { return max_batch_file_size; }
set { max_batch_file_size = value; }
}
public int NumRecompilesBeforeAppRestart {
get { return num_recompiles_before_app_restart; }
set { num_recompiles_before_app_restart = value; }
}
public bool Strict {
get { return strict; }
set { strict = value; }
}
public string TempDirectory {
get { return temp_directory; }
set {
if (value != null && !Directory.Exists (value))
throw new ArgumentException ("Directory does not exist");
temp_directory = value;
}
}
public CompilerCollection Compilers {
get { return compilers; }
}
}
sealed class CompilerCollection
{
Hashtable compilers;
public CompilerCollection () : this (null) {}
public CompilerCollection (CompilerCollection parent)
{
compilers = new Hashtable (CaseInsensitiveHashCodeProvider.Default,
CaseInsensitiveComparer.Default);
if (parent != null && parent.compilers != null) {
foreach (DictionaryEntry entry in parent.compilers)
compilers [entry.Key] = entry.Value;
}
}
public CompilerInfo this [string language] {
get { return compilers [language] as CompilerInfo; }
set {
compilers [language] = value;
string [] langs = language.Split (';');
foreach (string s in langs) {
string x = s.Trim ();
if (x != "")
compilers [x] = value;
}
}
}
internal Hashtable Hash {
get { return compilers; }
}
}
}
#endif // NET_2_0