Imported Upstream version 5.0.0.42

Former-commit-id: fd56571888259555122d8a0f58c68838229cea2b

external/linker/cecil/symbols/mdb/Mono.CompilerServices.SymbolWriter/MonoSymbolWriter.cs

@@ -0,0 +1,238 @@
+//
+// Mono.CSharp.Debugger/MonoSymbolWriter.cs
+//
+// Author:
+//   Martin Baulig (martin@ximian.com)
+//
+// This is the default implementation of the System.Diagnostics.SymbolStore.ISymbolWriter
+// interface.
+//
+// (C) 2002 Ximian, Inc.  http://www.ximian.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.
+//
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Mono.CompilerServices.SymbolWriter
+{
+	public class MonoSymbolWriter
+	{
+		List<SourceMethodBuilder> methods;
+		List<SourceFileEntry> sources;
+		List<CompileUnitEntry> comp_units;
+		protected readonly MonoSymbolFile file;
+		string filename;
+
+		private SourceMethodBuilder current_method;
+		Stack<SourceMethodBuilder> current_method_stack = new Stack<SourceMethodBuilder> ();
+
+		public MonoSymbolWriter (string filename)
+		{
+			this.methods = new List<SourceMethodBuilder> ();
+			this.sources = new List<SourceFileEntry> ();
+			this.comp_units = new List<CompileUnitEntry> ();
+			this.file = new MonoSymbolFile ();
+
+			this.filename = filename + ".mdb";
+		}
+
+		public MonoSymbolFile SymbolFile {
+			get { return file; }
+		}
+
+		public void CloseNamespace ()
+		{ }
+
+		public void DefineLocalVariable (int index, string name)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.AddLocal (index, name);
+		}
+
+		public void DefineCapturedLocal (int scope_id, string name, string captured_name)
+		{
+			file.DefineCapturedVariable (scope_id, name, captured_name,
+						     CapturedVariable.CapturedKind.Local);
+		}
+
+		public void DefineCapturedParameter (int scope_id, string name, string captured_name)
+		{
+			file.DefineCapturedVariable (scope_id, name, captured_name,
+						     CapturedVariable.CapturedKind.Parameter);
+		}
+
+		public void DefineCapturedThis (int scope_id, string captured_name)
+		{
+			file.DefineCapturedVariable (scope_id, "this", captured_name,
+						     CapturedVariable.CapturedKind.This);
+		}
+
+		public void DefineCapturedScope (int scope_id, int id, string captured_name)
+		{
+			file.DefineCapturedScope (scope_id, id, captured_name);
+		}
+
+		public void DefineScopeVariable (int scope, int index)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.AddScopeVariable (scope, index);
+		}
+
+		public void MarkSequencePoint (int offset, SourceFileEntry file, int line, int column,
+					       bool is_hidden)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.MarkSequencePoint (offset, file, line, column, is_hidden);
+		}
+
+		public SourceMethodBuilder OpenMethod (ICompileUnit file, int ns_id, IMethodDef method)
+		{
+			SourceMethodBuilder builder = new SourceMethodBuilder (file, ns_id, method);
+			current_method_stack.Push (current_method);
+			current_method = builder;
+			methods.Add (current_method);
+			return builder;
+		}
+
+		public void CloseMethod ()
+		{
+			current_method = (SourceMethodBuilder) current_method_stack.Pop ();
+		}
+
+		public SourceFileEntry DefineDocument (string url)
+		{
+			SourceFileEntry entry = new SourceFileEntry (file, url);
+			sources.Add (entry);
+			return entry;
+		}
+
+		public SourceFileEntry DefineDocument (string url, byte[] guid, byte[] checksum)
+		{
+			SourceFileEntry entry = new SourceFileEntry (file, url, guid, checksum);
+			sources.Add (entry);
+			return entry;
+		}
+
+		public CompileUnitEntry DefineCompilationUnit (SourceFileEntry source)
+		{
+			CompileUnitEntry entry = new CompileUnitEntry (file, source);
+			comp_units.Add (entry);
+			return entry;
+		}
+
+		public int DefineNamespace (string name, CompileUnitEntry unit,
+					    string[] using_clauses, int parent)
+		{
+			if ((unit == null) || (using_clauses == null))
+				throw new NullReferenceException ();
+
+			return unit.DefineNamespace (name, using_clauses, parent);
+		}
+
+		public int OpenScope (int start_offset)
+		{
+			if (current_method == null)
+				return 0;
+
+			current_method.StartBlock (CodeBlockEntry.Type.Lexical, start_offset);
+			return 0;
+		}
+
+		public void CloseScope (int end_offset)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.EndBlock (end_offset);
+		}
+
+		public void OpenCompilerGeneratedBlock (int start_offset)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.StartBlock (CodeBlockEntry.Type.CompilerGenerated,
+						   start_offset);
+		}
+
+		public void CloseCompilerGeneratedBlock (int end_offset)
+		{
+			if (current_method == null)
+				return;
+
+			current_method.EndBlock (end_offset);
+		}
+
+		public void StartIteratorBody (int start_offset)
+		{
+			current_method.StartBlock (CodeBlockEntry.Type.IteratorBody,
+						   start_offset);
+		}
+
+		public void EndIteratorBody (int end_offset)
+		{
+			current_method.EndBlock (end_offset);
+		}
+
+		public void StartIteratorDispatcher (int start_offset)
+		{
+			current_method.StartBlock (CodeBlockEntry.Type.IteratorDispatcher,
+						   start_offset);
+		}
+
+		public void EndIteratorDispatcher (int end_offset)
+		{
+			current_method.EndBlock (end_offset);
+		}
+
+		public void DefineAnonymousScope (int id)
+		{
+			file.DefineAnonymousScope (id);
+		}
+
+		public void WriteSymbolFile (Guid guid)
+		{
+			foreach (SourceMethodBuilder method in methods)
+				method.DefineMethod (file);
+
+			try {
+				// We mmap the file, so unlink the previous version since it may be in use
+				File.Delete (filename);
+			} catch {
+				// We can safely ignore
+			}
+			using (FileStream fs = new FileStream (filename, FileMode.Create, FileAccess.Write)) {
+				file.CreateSymbolFile (guid, fs);
+			}
+		}
+	}
+}

external/linker/cecil/symbols/mdb/Mono.CompilerServices.SymbolWriter/SourceMethodBuilder.cs

@@ -0,0 +1,190 @@
+//
+// SourceMethodBuilder.cs
+//
+// Authors:
+//   Martin Baulig (martin@ximian.com)
+//   Marek Safar (marek.safar@gmail.com)
+//
+// (C) 2002 Ximian, Inc.  http://www.ximian.com
+// Copyright (C) 2012 Xamarin Inc (http://www.xamarin.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.
+//
+
+using System.Collections.Generic;
+
+namespace Mono.CompilerServices.SymbolWriter
+{
+	public class SourceMethodBuilder
+	{
+		List<LocalVariableEntry> _locals;
+		List<CodeBlockEntry> _blocks;
+		List<ScopeVariable> _scope_vars;
+		Stack<CodeBlockEntry> _block_stack;
+		readonly List<LineNumberEntry> method_lines;
+
+		readonly ICompileUnit _comp_unit;
+		readonly int ns_id;
+		readonly IMethodDef method;
+
+		public SourceMethodBuilder (ICompileUnit comp_unit)
+		{
+			this._comp_unit = comp_unit;
+			method_lines = new List<LineNumberEntry> ();
+		}
+
+		public SourceMethodBuilder (ICompileUnit comp_unit, int ns_id, IMethodDef method)
+			: this (comp_unit)
+		{
+			this.ns_id = ns_id;
+			this.method = method;
+		}
+
+		public void MarkSequencePoint (int offset, SourceFileEntry file, int line, int column, bool is_hidden)
+		{
+			MarkSequencePoint (offset, file, line, column, -1, -1, is_hidden);
+		}
+
+		public void MarkSequencePoint (int offset, SourceFileEntry file, int line, int column, int end_line, int end_column, bool is_hidden)
+		{
+			int file_idx = file != null ? file.Index : 0;
+			var lne = new LineNumberEntry (file_idx, line, column, end_line, end_column, offset, is_hidden);
+
+			if (method_lines.Count > 0) {
+				var prev = method_lines[method_lines.Count - 1];
+
+				//
+				// Same offset cannot be used for multiple lines
+				//
+				if (prev.Offset == offset) {
+					//
+					// Use the new location because debugger will adjust
+					// the breakpoint to next line with sequence point
+					//
+					if (LineNumberEntry.LocationComparer.Default.Compare (lne, prev) > 0)
+						method_lines[method_lines.Count - 1] = lne;
+
+					return;
+				}
+			}
+
+			method_lines.Add (lne);
+		}
+
+		public void StartBlock (CodeBlockEntry.Type type, int start_offset)
+		{
+			if (_block_stack == null) {
+				_block_stack = new Stack<CodeBlockEntry> ();
+			}
+
+			if (_blocks == null)
+				_blocks = new List<CodeBlockEntry> ();
+
+			int parent = CurrentBlock != null ? CurrentBlock.Index : -1;
+
+			CodeBlockEntry block = new CodeBlockEntry (
+				_blocks.Count + 1, parent, type, start_offset);
+
+			_block_stack.Push (block);
+			_blocks.Add (block);
+		}
+
+		public void EndBlock (int end_offset)
+		{
+			CodeBlockEntry block = (CodeBlockEntry) _block_stack.Pop ();
+			block.Close (end_offset);
+		}
+
+		public CodeBlockEntry[] Blocks {
+			get {
+				if (_blocks == null)
+					return new CodeBlockEntry [0];
+
+				CodeBlockEntry[] retval = new CodeBlockEntry [_blocks.Count];
+				_blocks.CopyTo (retval, 0);
+				return retval;
+			}
+		}
+
+		public CodeBlockEntry CurrentBlock {
+			get {
+				if ((_block_stack != null) && (_block_stack.Count > 0))
+					return (CodeBlockEntry) _block_stack.Peek ();
+				else
+					return null;
+			}
+		}
+
+		public LocalVariableEntry[] Locals {
+			get {
+				if (_locals == null)
+					return new LocalVariableEntry [0];
+				else {
+					return _locals.ToArray ();
+				}
+			}
+		}
+
+		public ICompileUnit SourceFile {
+			get {
+				return _comp_unit;
+			}
+		}
+
+		public void AddLocal (int index, string name)
+		{
+			if (_locals == null)
+				_locals = new List<LocalVariableEntry> ();
+			int block_idx = CurrentBlock != null ? CurrentBlock.Index : 0;
+			_locals.Add (new LocalVariableEntry (index, name, block_idx));
+		}
+
+		public ScopeVariable[] ScopeVariables {
+			get {
+				if (_scope_vars == null)
+					return new ScopeVariable [0];
+
+				return _scope_vars.ToArray ();
+			}
+		}
+
+		public void AddScopeVariable (int scope, int index)
+		{
+			if (_scope_vars == null)
+				_scope_vars = new List<ScopeVariable> ();
+			_scope_vars.Add (
+				new ScopeVariable (scope, index));
+		}
+
+		public void DefineMethod (MonoSymbolFile file)
+		{
+			DefineMethod (file, method.Token);
+		}
+
+		public void DefineMethod (MonoSymbolFile file, int token)
+		{
+			MethodEntry entry = new MethodEntry (
+				file, _comp_unit.Entry, token, ScopeVariables,
+				Locals, method_lines.ToArray (), Blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);
+
+			file.AddMethod (entry);
+		}
+	}
+}

external/linker/cecil/symbols/mdb/Mono.CompilerServices.SymbolWriter/SymbolWriterImpl.cs

@@ -0,0 +1,349 @@
+//
+// SymbolWriterImpl.cs
+//
+// Author:
+//   Lluis Sanchez Gual (lluis@novell.com)
+//
+// (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.
+//
+
+
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Collections;
+using System.IO;
+using System.Diagnostics.SymbolStore;
+
+namespace Mono.CompilerServices.SymbolWriter
+{
+	public class SymbolWriterImpl: ISymbolWriter
+	{
+		MonoSymbolWriter msw;
+
+		int nextLocalIndex;
+		int currentToken;
+		string methodName;
+		Stack namespaceStack = new Stack ();
+		bool methodOpened;
+
+		Hashtable documents = new Hashtable ();
+
+#if !CECIL
+		ModuleBuilder mb;
+		delegate Guid GetGuidFunc (ModuleBuilder mb);
+		GetGuidFunc get_guid_func;
+
+		public SymbolWriterImpl (ModuleBuilder mb)
+		{
+			this.mb = mb;
+		}
+
+		public void Close ()
+		{
+			MethodInfo mi = typeof (ModuleBuilder).GetMethod (
+				"Mono_GetGuid",
+				BindingFlags.Static | BindingFlags.NonPublic);
+			if (mi == null)
+				return;
+
+			get_guid_func = (GetGuidFunc) System.Delegate.CreateDelegate (
+				typeof (GetGuidFunc), mi);
+
+			msw.WriteSymbolFile (get_guid_func (mb));
+		}
+#else
+		Guid guid;
+
+		public SymbolWriterImpl (Guid guid)
+		{
+			this.guid = guid;
+		}
+
+		public void Close ()
+		{
+			msw.WriteSymbolFile (guid);
+		}
+#endif
+
+		public void CloseMethod ()
+		{
+			if (methodOpened) {
+				methodOpened = false;
+				nextLocalIndex = 0;
+				msw.CloseMethod ();
+			}
+		}
+
+		public void CloseNamespace ()
+		{
+			namespaceStack.Pop ();
+			msw.CloseNamespace ();
+		}
+
+		public void CloseScope (int endOffset)
+		{
+			msw.CloseScope (endOffset);
+		}
+
+		public ISymbolDocumentWriter DefineDocument (
+			string url,
+			Guid language,
+			Guid languageVendor,
+			Guid documentType)
+		{
+			SymbolDocumentWriterImpl doc = (SymbolDocumentWriterImpl) documents [url];
+			if (doc == null) {
+				SourceFileEntry entry = msw.DefineDocument (url);
+				CompileUnitEntry comp_unit = msw.DefineCompilationUnit (entry);
+				doc = new SymbolDocumentWriterImpl (comp_unit);
+				documents [url] = doc;
+			}
+			return doc;
+		}
+
+		public void DefineField (
+			SymbolToken parent,
+			string name,
+			FieldAttributes attributes,
+			byte[] signature,
+			SymAddressKind addrKind,
+			int addr1,
+			int addr2,
+			int addr3)
+		{
+		}
+
+		public void DefineGlobalVariable (
+			string name,
+			FieldAttributes attributes,
+			byte[] signature,
+			SymAddressKind addrKind,
+			int addr1,
+			int addr2,
+			int addr3)
+		{
+		}
+
+		public void DefineLocalVariable (
+			string name,
+			FieldAttributes attributes,
+			byte[] signature,
+			SymAddressKind addrKind,
+			int addr1,
+			int addr2,
+			int addr3,
+			int startOffset,
+			int endOffset)
+		{
+			msw.DefineLocalVariable (nextLocalIndex++, name);
+		}
+
+		public void DefineParameter (
+			string name,
+			ParameterAttributes attributes,
+			int sequence,
+			SymAddressKind addrKind,
+			int addr1,
+			int addr2,
+			int addr3)
+		{
+		}
+
+		public void DefineSequencePoints (
+			ISymbolDocumentWriter document,
+			int[] offsets,
+			int[] lines,
+			int[] columns,
+			int[] endLines,
+			int[] endColumns)
+		{
+			SymbolDocumentWriterImpl doc = (SymbolDocumentWriterImpl) document;
+			SourceFileEntry file = doc != null ? doc.Entry.SourceFile : null;
+
+			for (int n=0; n<offsets.Length; n++) {
+				if (n > 0 && offsets[n] == offsets[n-1] && lines[n] == lines[n-1] && columns[n] == columns[n-1])
+					continue;
+				msw.MarkSequencePoint (offsets[n], file, lines[n], columns[n], false);
+			}
+		}
+
+		public void Initialize (IntPtr emitter, string filename, bool fFullBuild)
+		{
+			msw = new MonoSymbolWriter (filename);
+		}
+
+		public void OpenMethod (SymbolToken method)
+		{
+			currentToken = method.GetToken ();
+		}
+
+		public void OpenNamespace (string name)
+		{
+			NamespaceInfo n = new NamespaceInfo ();
+			n.NamespaceID = -1;
+			n.Name = name;
+			namespaceStack.Push (n);
+		}
+
+		public int OpenScope (int startOffset)
+		{
+			return msw.OpenScope (startOffset);
+		}
+
+		public void SetMethodSourceRange (
+			ISymbolDocumentWriter startDoc,
+			int startLine,
+			int startColumn,
+			ISymbolDocumentWriter endDoc,
+			int endLine,
+			int endColumn)
+		{
+			int nsId = GetCurrentNamespace (startDoc);
+			SourceMethodImpl sm = new SourceMethodImpl (methodName, currentToken, nsId);
+			msw.OpenMethod (((ICompileUnit)startDoc).Entry, nsId, sm);
+			methodOpened = true;
+		}
+
+		public void SetScopeRange (int scopeID, int startOffset, int endOffset)
+		{
+		}
+
+		public void SetSymAttribute (SymbolToken parent, string name, byte[] data)
+		{
+			// This is a hack! but MonoSymbolWriter needs the method name
+			// and ISymbolWriter does not have any method for providing it
+			if (name == "__name")
+				methodName = System.Text.Encoding.UTF8.GetString (data);
+		}
+
+		public void SetUnderlyingWriter (IntPtr underlyingWriter)
+		{
+		}
+
+		public void SetUserEntryPoint (SymbolToken entryMethod)
+		{
+		}
+
+		public void UsingNamespace (string fullName)
+		{
+			if (namespaceStack.Count == 0) {
+				OpenNamespace ("");
+			}
+
+			NamespaceInfo ni = (NamespaceInfo) namespaceStack.Peek ();
+			if (ni.NamespaceID != -1) {
+				NamespaceInfo old = ni;
+				CloseNamespace ();
+				OpenNamespace (old.Name);
+				ni = (NamespaceInfo) namespaceStack.Peek ();
+				ni.UsingClauses = old.UsingClauses;
+			}
+			ni.UsingClauses.Add (fullName);
+		}
+
+		int GetCurrentNamespace (ISymbolDocumentWriter doc)
+		{
+			if (namespaceStack.Count == 0) {
+				OpenNamespace ("");
+			}
+
+			NamespaceInfo ni = (NamespaceInfo) namespaceStack.Peek ();
+			if (ni.NamespaceID == -1)
+			{
+				string[] usings = (string[]) ni.UsingClauses.ToArray (typeof(string));
+
+				int parentId = 0;
+				if (namespaceStack.Count > 1) {
+					namespaceStack.Pop ();
+					parentId = ((NamespaceInfo) namespaceStack.Peek ()).NamespaceID;
+					namespaceStack.Push (ni);
+				}
+
+				ni.NamespaceID = msw.DefineNamespace (ni.Name, ((ICompileUnit)doc).Entry, usings, parentId);
+			}
+			return ni.NamespaceID;
+		}
+
+	}
+
+	class SymbolDocumentWriterImpl: ISymbolDocumentWriter, ISourceFile, ICompileUnit
+	{
+		CompileUnitEntry comp_unit;
+
+		public SymbolDocumentWriterImpl (CompileUnitEntry comp_unit)
+		{
+			this.comp_unit = comp_unit;
+		}
+
+		public void SetCheckSum (Guid algorithmId, byte[] checkSum)
+		{
+		}
+
+		public void SetSource (byte[] source)
+		{
+		}
+
+		SourceFileEntry ISourceFile.Entry {
+			get { return comp_unit.SourceFile; }
+		}
+
+		public CompileUnitEntry Entry {
+			get { return comp_unit; }
+		}
+	}
+
+	class SourceMethodImpl: IMethodDef
+	{
+		string name;
+		int token;
+		int namespaceID;
+
+		public SourceMethodImpl (string name, int token, int namespaceID)
+		{
+			this.name = name;
+			this.token = token;
+			this.namespaceID = namespaceID;
+		}
+
+		public string Name {
+			get { return name; }
+		}
+
+		public int NamespaceID {
+			get { return namespaceID; }
+		}
+
+		public int Token {
+			get { return token; }
+		}
+	}
+
+	class NamespaceInfo
+	{
+		public string Name;
+		public int NamespaceID;
+		public ArrayList UsingClauses = new ArrayList ();
+	}
+}