pygments.rb-jruby 0.5.4

data/vendor/pygments-main/tests/examplefiles/test.bmx

@@ -0,0 +1,145 @@
+
+Rem
+foobar
+EndRem
+
+Rem
+	foobar!
+End Rem
+
+Rem
+End Rem
+
+SuperStrict
+
+Framework brl.blitz
+Import brl.standardio
+
+'Import "blah.bmx"
+'Import "blah/blah.bmx"
+'Include "blurg/blurg.bmx"
+
+Const ca:Long = $10000000 ' Hex
+Const cb:Int = %10101010 ' Binary
+Global ga:String = "blargh"
+Local a:Int = 124, b$ = "abcdef"
+?Not Debug
+Print(_name123(ga, a, 100.2))
+?
+
+Function _name123  : Float  (zorp:String, ll:Int = False, blah#, waffles% = 100)
+	Return 235.7804 ' Single-line comment
+End Function
+Function TestString:String()
+End Function
+Function TestByte:Byte()
+End Function
+
+Function hub(blah:String, ..
+				abc:Int = Pi)
+End Function
+Function Blar%()
+	Local aa !, ab @ ,ac @@, ad# ,ae$,af% ' Intentional mangling
+	Local ba:Double, bb :Byte, bc: Short,bd:Float,be: String,ff:Int = True
+End Function
+
+?Win32
+abc()
+?Linux
+abc()
+?
+
+Function abc()
+	Print "abc"	' I cannot find a way to parse these as function calls without messing something up
+	Print		' Anyhow, they're generally not used in this way
+	Goto Eww_Goto
+	#Eww_Goto
+End Function
+
+Type TBlarf Abstract
+End Type
+
+Type TFooBar
+End Type
+
+New MyClass.TestMethod()
+New(MyClass).TestMethod()
+Local myinst:MyClass = New MyClass
+myinst.TestMethod()
+
+Type MyClass Extends TFooBar
+	
+	Field m_foo:MyClass
+	Field m_bar:MyClass
+	
+	Rem
+		abc
+		def
+	End Rem
+	Method New()
+		Rem
+			abcdef
+		endrem
+	End Method
+	
+	Method TestMethod() ' foobar
+		m_foo = Self
+		m_bar = MyClass(m_foo)
+		m_foo.m_bar.m_foo.m_bar.Yell()
+	End Method
+	
+	Method Yell()
+		Print("huzzah!")
+	End Method
+	
+	Function Wakka$(foo:String)
+		Return foo + "bar"
+	End Function
+	
+End Type
+
+Extern "c"
+	Function vesper!(a:Int) = "vesper@4"
+	Function bubbles@@(a%)
+End Extern
+
+Print("blah " + ..
+	"blah " + ..
+	"blah.")
+
+Try
+	Throw("blar!")
+Catch exception:String
+	Print("Caught: " + exception)
+End Try
+
+For Local i:Int = 0 To 10 Step 1
+	Print("Index: " + i)
+Next
+Local array:String[] = ["foo", "bar", "11", "22", "33"]
+For Local value:String = EachIn array
+	Print("Value: " + value)
+Next
+
+Local foobar:Int = Not (1 Or (2 And (4 Shl 5 Shr 6)) Sar 7) Mod (8+2)
+Local az:Int = 1234567890
+az : + 1
+az: - 2
+az :* 3
+az:/ 4
+az:& 5
+az:| 6
+az: ~ 7
+az : Shl 8
+az:  Shr 9
+az :Sar 10
+az:Mod 11
+az = ((10-5+2/4*2)>(((8^2)) < 2)) & 12|2
+
+Function flub(fah Ptr, eah:Int Ptr, blu@@ Ptr)
+End Function
+Function Foob:Int Ptr(blar:Byte Ptr, Saffon@Ptr, blaus#Ptr)
+End Function
+Function zauus@Ptr()
+End Function
+

data/vendor/pygments-main/tests/examplefiles/test.boo

@@ -0,0 +1,39 @@
+import System
+import Boo.Lang.Interpreter from Boo.Lang.Interpreter
+
+class ObjectInterpreter(AbstractInterpreter):
+
+        _context as object
+
+        [getter(Value)]
+        _value as object
+
+        def constructor(context):
+            _context = context
+            self.RememberLastValue = true
+
+        override def Lookup(name as string):
+            property = _context.GetType().GetProperty(name)
+            return property.PropertyType if property is not null
+
+        override def GetValue(name as string):
+            return _context.GetType().GetProperty(name).GetValue(
+                                          _context, null)
+
+        override def SetLastValue(value):
+            _value = value
+
+        override def SetValue(name as string, value):
+            raise InvalidOperationException()
+
+        override def Declare(name as string, type as Type):
+            raise InvalidOperationException()
+
+class Person:
+        [property(FirstName)]
+        _fname as string = ""
+
+p = Person(FirstName: "Homer")
+i = ObjectInterpreter(p)
+i.Eval('"Hello, ${FirstName.ToUpper()}!"')
+print i.Value

data/vendor/pygments-main/tests/examplefiles/test.bro

@@ -0,0 +1,250 @@
+@load notice
+@load utils/thresholds
+
+module SSH;
+
+export {
+	redef enum Log::ID += { SSH };
+
+	redef enum Notice::Type += {
+		Login,
+		Password_Guessing,
+		Login_By_Password_Guesser,
+		Login_From_Interesting_Hostname,
+		Bytecount_Inconsistency,
+	};
+
+	type Info: record {
+		ts:              time         &log;
+		uid:             string       &log;
+		id:              conn_id      &log;
+		status:          string       &log &optional;
+		direction:       string       &log &optional;
+		remote_location: geo_location &log &optional;
+		client:          string       &log &optional;
+		server:          string       &log &optional;
+		resp_size:       count        &log &default=0;
+		
+		## Indicate if the SSH session is done being watched.
+		done:            bool         &default=F;
+	};
+
+	const password_guesses_limit = 30 &redef;
+	
+	# The size in bytes at which the SSH connection is presumed to be
+	# successful.
+	const authentication_data_size = 5500 &redef;
+	
+	# The amount of time to remember presumed non-successful logins to build
+	# model of a password guesser.
+	const guessing_timeout = 30 mins &redef;
+
+	# The set of countries for which you'd like to throw notices upon successful login
+	#   requires Bro compiled with libGeoIP support
+	const watched_countries: set[string] = {"RO"} &redef;
+
+	# Strange/bad host names to originate successful SSH logins
+	const interesting_hostnames =
+			/^d?ns[0-9]*\./ |
+			/^smtp[0-9]*\./ |
+			/^mail[0-9]*\./ |
+			/^pop[0-9]*\./  |
+			/^imap[0-9]*\./ |
+			/^www[0-9]*\./  |
+			/^ftp[0-9]*\./  &redef;
+
+	# This is a table with orig subnet as the key, and subnet as the value.
+	const ignore_guessers: table[subnet] of subnet &redef;
+	
+	# If true, we tell the event engine to not look at further data
+	# packets after the initial SSH handshake. Helps with performance
+	# (especially with large file transfers) but precludes some
+	# kinds of analyses (e.g., tracking connection size).
+	const skip_processing_after_detection = F &redef;
+	
+	# Keeps count of how many rejections a host has had
+	global password_rejections: table[addr] of TrackCount 
+		&write_expire=guessing_timeout
+		&synchronized;
+
+	# Keeps track of hosts identified as guessing passwords
+	# TODO: guessing_timeout doesn't work correctly here.  If a user redefs
+	#       the variable, it won't take effect.
+	global password_guessers: set[addr] &read_expire=guessing_timeout+1hr &synchronized;
+	
+	global log_ssh: event(rec: Info);
+}
+
+# Configure DPD and the packet filter
+redef capture_filters += { ["ssh"] = "tcp port 22" };
+redef dpd_config += { [ANALYZER_SSH] = [$ports = set(22/tcp)] };
+
+redef record connection += {
+	ssh: Info &optional;
+};
+
+event bro_init()
+{
+	Log::create_stream(SSH, [$columns=Info, $ev=log_ssh]);
+}
+
+function set_session(c: connection)
+	{
+	if ( ! c?$ssh )
+		{
+		local info: Info;
+		info$ts=network_time();
+		info$uid=c$uid;
+		info$id=c$id;
+		c$ssh = info;
+		}
+	}
+
+function check_ssh_connection(c: connection, done: bool)
+	{
+	# If done watching this connection, just return.
+	if ( c$ssh$done )
+		return;
+	
+	# If this is still a live connection and the byte count has not
+	# crossed the threshold, just return and let the resheduled check happen later.
+	if ( !done && c$resp$size < authentication_data_size )
+		return;
+
+	# Make sure the server has sent back more than 50 bytes to filter out
+	# hosts that are just port scanning.  Nothing is ever logged if the server
+	# doesn't send back at least 50 bytes.
+	if ( c$resp$size < 50 )
+		return;
+
+	local status = "failure";
+	local direction = Site::is_local_addr(c$id$orig_h) ? "to" : "from";
+	local location: geo_location;
+	location = (direction == "to") ? lookup_location(c$id$resp_h) : lookup_location(c$id$orig_h);
+	
+	if ( done && c$resp$size < authentication_data_size )
+		{
+		# presumed failure
+		if ( c$id$orig_h !in password_rejections )
+			password_rejections[c$id$orig_h] = new_track_count();
+			
+		# Track the number of rejections
+		if ( !(c$id$orig_h in ignore_guessers &&
+		       c$id$resp_h in ignore_guessers[c$id$orig_h]) )
+			++password_rejections[c$id$orig_h]$n;
+			
+		if ( default_check_threshold(password_rejections[c$id$orig_h]) )
+			{
+			add password_guessers[c$id$orig_h];
+			NOTICE([$note=Password_Guessing,
+			        $conn=c,
+			        $msg=fmt("SSH password guessing by %s", c$id$orig_h),
+			        $sub=fmt("%d failed logins", password_rejections[c$id$orig_h]$n),
+			        $n=password_rejections[c$id$orig_h]$n]);
+			}
+		} 
+	# TODO: This is to work around a quasi-bug in Bro which occasionally 
+	#       causes the byte count to be oversized.
+	#   Watch for Gregors work that adds an actual counter of bytes transferred.
+	else if ( c$resp$size < 20000000 ) 
+		{ 
+		# presumed successful login
+		status = "success";
+		c$ssh$done = T;
+
+		if ( c$id$orig_h in password_rejections &&
+		     password_rejections[c$id$orig_h]$n > password_guesses_limit &&
+		     c$id$orig_h !in password_guessers )
+			{
+			add password_guessers[c$id$orig_h];
+			NOTICE([$note=Login_By_Password_Guesser,
+			        $conn=c,
+			        $n=password_rejections[c$id$orig_h]$n,
+			        $msg=fmt("Successful SSH login by password guesser %s", c$id$orig_h),
+			        $sub=fmt("%d failed logins", password_rejections[c$id$orig_h]$n)]);
+			}
+		
+		local message = fmt("SSH login %s %s \"%s\" \"%s\" %f %f %s (triggered with %d bytes)",
+		              direction, location$country_code, location$region, location$city,
+		              location$latitude, location$longitude,
+		              id_string(c$id), c$resp$size);
+		NOTICE([$note=Login,
+		        $conn=c,
+		        $msg=message,
+		        $sub=location$country_code]);
+		
+		# Check to see if this login came from an interesting hostname
+		when ( local hostname = lookup_addr(c$id$orig_h) )
+			{
+			if ( interesting_hostnames in hostname )
+				{
+				NOTICE([$note=Login_From_Interesting_Hostname,
+				        $conn=c,
+				        $msg=fmt("Strange login from %s", hostname),
+				        $sub=hostname]);
+				}
+			}
+			
+		if ( location$country_code in watched_countries )
+			{
+			
+			}
+			
+		}
+	else if ( c$resp$size >= 200000000 ) 
+		{
+		NOTICE([$note=Bytecount_Inconsistency,
+		        $conn=c,
+		        $msg="During byte counting in SSH analysis, an overly large value was seen.",
+		        $sub=fmt("%d",c$resp$size)]);
+		}
+
+	c$ssh$remote_location = location;
+	c$ssh$status = status;
+	c$ssh$direction = direction;
+	c$ssh$resp_size = c$resp$size;
+	
+	Log::write(SSH, c$ssh);
+	
+	# Set the "done" flag to prevent the watching event from rescheduling
+	# after detection is done.
+	c$ssh$done;
+	
+	# Stop watching this connection, we don't care about it anymore.
+	if ( skip_processing_after_detection )
+		{
+		skip_further_processing(c$id);
+		set_record_packets(c$id, F);
+		}
+	}
+
+event connection_state_remove(c: connection) &priority=-5
+	{
+	if ( c?$ssh )
+		check_ssh_connection(c, T);
+	}
+
+event ssh_watcher(c: connection)
+	{
+	local id = c$id;
+	# don't go any further if this connection is gone already!
+	if ( !connection_exists(id) )
+		return;
+
+	check_ssh_connection(c, F);
+	if ( ! c$ssh$done )
+		schedule +15secs { ssh_watcher(c) };
+	}
+
+event ssh_server_version(c: connection, version: string) &priority=5
+	{
+	set_session(c);
+	c$ssh$server = version;
+	}
+	
+event ssh_client_version(c: connection, version: string) &priority=5
+	{
+	set_session(c);
+	c$ssh$client = version;
+	schedule +15secs { ssh_watcher(c) };
+	}

data/vendor/pygments-main/tests/examplefiles/test.cs

@@ -0,0 +1,374 @@
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// MIT X11 license, Copyright (c) 2005-2006 by:                               //
+//                                                                            //
+// Authors:                                                                   //
+//      Michael Dominic K. <michaldominik@gmail.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.                                     //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+namespace Diva.Core {
+        
+        using System;
+        using Widgets;
+        using System.Xml;
+        using Util;
+        using System.Collections.Generic;
+        using System.Collections;
+        using Basics;
+
+        public class OpenerTask : Task, IBoilProvider {
+
+                // Private structs ////////////////////////////////////////////
+                
+                struct ObjectInfo {
+
+                        public ObjectContainer Container;
+                        public int[] Depends;
+                        public string SystemType;
+                        public int RefId;
+                        
+                        /* CONSTRUCTOR */
+                        public ObjectInfo (ObjectContainer container)
+                        {
+                                Container = container;
+                                Depends = container.Depends.ToArray ();
+                                SystemType = container.SystemType;
+                                RefId = container.RefId;
+                        }
+                        
+                        public override string ToString ()
+                        {
+                                return String.Format ("Type: {0} Deps count: {1} Id: {2}",
+                                                      SystemType, Depends.Length, RefId);
+                        }
+                        
+                        public bool IsUnBoilable (IBoilProvider provider)
+                        {
+                                if (Depends.Length == 0)
+                                        return true;
+                                
+                                foreach (int id in Depends)
+                                        if (! (provider.Contains (id)))
+                                                return false;
+                                
+                                return true;
+                        }
+                        
+                }
+                                 
+                // Enums //////////////////////////////////////////////////////
+                
+                enum OpenerTaskStep { Init, Header, ProjectInfoRead, ObjectListRead,
+                                      ObjectListParse, ObjectListUnBoil, FindRoots,
+                                      Finished };
+                
+                // Fields /////////////////////////////////////////////////////
+                
+                string fileName;                         // Filename we're reading
+                XmlDocument xmlDocument;                 // Our document
+                //XmlNode projectInfoNode;               // <projectinfo> node
+                IEnumerator objectsEnumerator;           // Enumerator
+                List <ObjectInfo> objectsList;           // Objects list
+                ObjectListContainer objectListContainer;
+                OpenerTaskStep currentStep;              // Our current step
+                
+                Dictionary <int, object> idToObject;     // Id -> object
+                Dictionary <object, int> objectToId;     // Object -> Id
+
+                string projectName = String.Empty;
+                string projectDirectory = String.Empty;
+                TagList projectTagList;
+                StuffList projectStuffList;
+                TrackList projectTrackList;
+                ClipList projectClipList;
+                MediaItemList projectMediaItemList;
+                Commander projectCommander;
+                Gdv.Pipeline projectPipeline;
+                Gdv.ProjectFormat projectFormat;
+                
+                // Properties /////////////////////////////////////////////////
+                
+                public string ProjectName {
+                        get { return projectName; }
+                }
+                
+                public string ProjectDirectory {
+                        get { return projectDirectory; }
+                }
+                
+                public TagList ProjectTagList {
+                        get { return projectTagList; }
+                }
+                
+                public StuffList ProjectStuffList {
+                        get { return projectStuffList; }
+                }
+                
+                public TrackList ProjectTrackList {
+                        get { return projectTrackList; }
+                }
+
+                public ClipList ProjectClipList {
+                        get { return projectClipList; }
+                }
+                
+                public MediaItemList ProjectMediaItemList {
+                        get { return projectMediaItemList; }
+                }
+                
+                public Commander ProjectCommander {
+                        get { return projectCommander; }
+                }
+                
+                public Gdv.Pipeline ProjectPipeline {
+                        get { return projectPipeline; }
+                }
+
+                public Gdv.ProjectFormat ProjectFormat {
+                        get { return projectFormat; }
+                }
+
+                // Public methods /////////////////////////////////////////////
+                
+                /* CONSTRUCTOR */
+                public OpenerTask (string fileName)
+                {
+                        this.fileName = fileName;
+                        var verbatimString = @"c:\test\";
+
+                        var verbatimStringWithNewline = @"test \\ \n \t \r
+a
+b
+c";
+                        var verbatimStringWithEscapedQuotes = @"He said
+""she says \"" is not an escaped character in verbatimstrings""
+";
+
+                        int[] numbers = { 5,6,4,2,4,6,8,9,7,0 };
+                        var linqExample = from n in numbers
+                                          where n > 5
+                                          select n;
+
+                        var anotherlinqExample = from n in numbers
+                                                 orderby n descending
+                                                 select n;
+
+                        int[] someMoreNumbers = { 8,2,17,34,8,9,9,5,3,4,2,1,5 };
+                        var moreLinq = from n in numbers
+                                       join mn in moreNumbers on n equals mn + 2
+                                       select new {n, mn};
+                }
+                
+                public override void Reset ()
+                {
+                        objectToId = new Dictionary <object, int> ();
+                        idToObject = new Dictionary <int, object> ();
+                        
+                        xmlDocument = null;
+                        //projectInfoNode = null;
+                        
+                        currentStep = OpenerTaskStep.Init;
+                        
+                        base.Reset ();
+                }
+                
+                public int GetIdForObject (object o)
+                {
+                        return objectToId [o];
+                }
+                
+                public object GetObjectForId (int id)
+                {
+                        return idToObject [id];
+                }
+                
+                public bool Contains (int id)
+                {
+                        return idToObject.ContainsKey (id);
+                }
+                
+                // Private methods ////////////////////////////////////////////
+                
+                protected override TaskStatus ExecuteStep (int s)
+                {
+                        bool cont = true;
+                        
+                        // Main
+                        switch (currentStep) {
+                                        
+                                case OpenerTaskStep.Init:
+                                        objectsList = new List <ObjectInfo> ();
+                                        xmlDocument = new XmlDocument ();
+                                        xmlDocument.Load (fileName);
+                                        currentStep = OpenerTaskStep.Header;
+                                        break;
+                                        
+                                case OpenerTaskStep.Header:
+                                        //ReadHeader ();
+                                        currentStep = OpenerTaskStep.ProjectInfoRead;
+                                        break;
+
+                                case OpenerTaskStep.ProjectInfoRead:
+                                        foreach (XmlNode node in xmlDocument.DocumentElement.ChildNodes)
+                                                if (node.Name == "projectinfo") 
+                                                        ResolveProjectInfoNode (node);
+
+                                        // FIXME: Fail if not found/not resolved
+                                        currentStep = OpenerTaskStep.ObjectListRead;
+                                        break;
+                                        
+                                case OpenerTaskStep.ObjectListRead:
+                                        foreach (XmlNode node in xmlDocument.DocumentElement.ChildNodes)
+                                                if (node.Name == "objectlist") 
+                                                        objectListContainer = (ObjectListContainer)
+                                                                DataFactory.MakeDataElement  (node as XmlElement);
+                                                        
+                                        if (objectListContainer == null)
+                                                throw new Exception ("ObjectListContainer not found!");
+
+                                        currentStep = OpenerTaskStep.ObjectListParse;
+                                        break;
+
+                                case OpenerTaskStep.ObjectListParse:
+                                        bool flush = EnumerateSomeObjects ();
+                                        if (flush)
+                                                currentStep = OpenerTaskStep.ObjectListUnBoil;
+                                        break;
+
+                                case OpenerTaskStep.ObjectListUnBoil:
+                                        bool done = UnBoilSomeObjects ();
+                                        if (done)
+                                                currentStep = OpenerTaskStep.FindRoots;
+                                        break;
+                                        
+                                        
+                                case OpenerTaskStep.FindRoots:
+                                        projectTrackList = (TrackList) FindRoot ("tracklist");
+                                        projectTagList = (TagList) FindRoot ("taglist");
+                                        projectStuffList = (StuffList) FindRoot ("stufflist");
+                                        projectClipList = (ClipList) FindRoot ("cliplist");
+                                        projectMediaItemList = (MediaItemList) FindRoot ("mediaitemlist");
+                                        projectPipeline = (Gdv.Pipeline) FindRoot ("pipeline");
+                                        projectCommander = (Commander) FindRoot ("commander");
+                                        projectFormat = (Gdv.ProjectFormat) FindRoot ("projectformat");
+                                        
+                                        currentStep = OpenerTaskStep.Finished;
+                                        break;
+                                        
+                                case OpenerTaskStep.Finished:
+                                        cont = false;
+                                        break;
+                                        
+                                default:
+                                        break;
+                        }
+                                                
+                        // Post 
+                        if (cont) 
+                                return TaskStatus.Running;
+                        else
+                                return TaskStatus.Done;
+                }
+
+                /*
+                void ReadHeader ()
+                {
+                        // FIXME: Read all the attributes from the <divaproject> element
+                        }*/
+
+                void ResolveProjectInfoNode (XmlNode node)
+                {
+                        foreach (XmlNode childNode in node) {
+                                
+                                switch (childNode.Name) {
+                                        
+                                        case "name":
+                                                projectName = childNode.FirstChild.Value;
+                                                break;
+                                        
+                                        case "directory":
+                                                projectDirectory = childNode.FirstChild.Value;
+                                                break;
+
+                                                // FIXME: Duration etc.
+                                }
+                        }
+                }
+                
+                bool EnumerateSomeObjects ()
+                {
+                        if (objectsEnumerator == null)
+                                objectsEnumerator = objectListContainer.FindAllObjects ().GetEnumerator ();
+                        
+                        for (int i = 0; i < 10; i++) {
+                                if (objectsEnumerator.MoveNext () == false)
+                                        return true;
+
+                                ObjectContainer container = (ObjectContainer)
+                                        objectsEnumerator.Current;
+                                
+                                ObjectInfo newInfo = new ObjectInfo (container);
+                                objectsList.Add (newInfo);
+                        }
+                        
+                        return false;
+                }
+
+                ObjectInfo GetNextCandidate ()
+                {
+                        foreach (ObjectInfo objInfo in objectsList)
+                                if (objInfo.IsUnBoilable (this))
+                                        return objInfo;
+                        
+                        throw new Exception ("FIXME: No more unboilable objects found. Recursive?");
+                }
+                
+                bool UnBoilSomeObjects ()
+                {
+                        for (int i = 0; i < 5; i++) {
+                                // All unboiled
+                                if (objectsList.Count == 0)
+                                        return true;
+                                
+                                ObjectInfo objInfo = GetNextCandidate ();
+
+                                object o = BoilFactory.UnBoil (objInfo.Container, this);
+                                objectsList.Remove (objInfo);
+
+                                // Add
+                                idToObject [objInfo.RefId] = o;
+                                objectToId [o] = objInfo.RefId;
+
+                        }
+                        
+                        return false;
+                }
+
+                object FindRoot (string rootString)
+                {
+                        ObjectContainer container = objectListContainer.FindObjectContainer (rootString);
+                        return idToObject [container.RefId];
+                }
+                
+        }
+        
+}