moo/kernel/Mill.moo

#include 'Moo.moo'.

class Mill(Object)
{
	var registrar.
	var obj.

	method initialize
	{
		self.registrar := Dictionary new.
	}

	method register: name call: callable
	{
		| k | 
		(k := self.registrar at: name) isNil ifTrue: [
			self.registrar at: name put: [
				self.obj isNil ifTrue: [
					self.obj := callable value.
				].
				self.obj
			].
		].

		^k
	}

	method make: name
	{
		| k |

		(k := self.registrar at: name) notNil ifTrue: [
			^k value.
		].

		^nil.
	}
}

class MyObject(Object)
{
	method(#class) mainxx
	{
		| d a ffi |

		/*k := Mill new.
		k register: #abc call: [ Dictionary new ].
		a := k make: #abc.
		//a dump.*/
		
		d := Dictionary new.
		d at: #abc put: 20.
		d at: #dddd put: 40.
		d at: #jjjj put: "hello world".
		d at: #moo put: "good?".
		d at: #moo put: "not good?".

		/* (d at: #abc) dump.
		/* (d at: #dddd) dump. */
		/*d do: [:v | v dump].*/

		d keysAndValuesDo: [:k :v| System logNl: (k asString) & " => " & (v asString) ].

		//(d includesAssociation: (Association key: #moo value: "not good?")) dump.
		"-------------------------" dump.
		//(System at: #MyObject) dump.
		(d removeKey: #moo) dump.
		d removeKey: #abc ifAbsent: [System logNl: "#moo not found"].
		d keysAndValuesDo: [:k :v| System logNl: (k asString) & " => " & (v asString) ].

		"-------------------------" dump.
		(d at: #jjjj) dump.
		(d at: #jjjja) dump.
		
		/* 
		System keysAndValuesDo: [:k :v| 
				System logNl: (k asString) & " => " & (v asString) 
		].
		*/
		
		//System keysDo: [:k| System logNl: (k asString)]
		
		/*[
			[Exception hash dump] ensure: ["xxxx" dump].
		] on: Exception do: [:ex | ("Exception caught - " & ex asString) dump ].*/

		ffi := FFI new: "/lib64/libc.so.6".
		if (ffi isError)
		{
			System logNl: "cannot open libc.so"
		}
		else
		{
			(ffi call: #getpid  signature: ">i" arguments: nil) dump.
			(ffi call: #printf signature: "s|iis>i" arguments: #("A=>%d B=>%d Hello, world %s\n" 1 2 "fly away")) dump.
			(ffi call: #printf signature: "s|iis>i" arguments: #("A=>%d B=>%d Hello, world %s\n" 1 2 "jump down")) dump.
			ffi close.
		}. 

		(("abcd" == "abcd") ifTrue: [1] ifFalse: [2]) dump.

	}
	
	
	method(#class) main_xx
	{
		|a k|

		"BEGINNING OF main..........." dump.
		a := 
			if ([System logNl: "xxxx". "abcd" == "bcde". false] value) 
			{ 
				System logNl: "XXXXXXXXX".
				1111 
			}
			elif ("abcd" ~= "abcd")
			{
				System logNl: "second if".
			}
			elif ([k := 20. System logNl: "k => " & (k asString). k + 20. true] value)
			{
				System logNl: "THIRID forever............." & (k asString)
			}
			elif (true = true)
			{
				System logNl: "forever............."
			}
			else
			{
				System logNl: "NO MATCH".
				[true] value.
			}.
		
		a dump.
		
		(if (false) { 10 } else { 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}) dump.
		
		System logNl: "DONE DONE DONE...".
		
		
		(if (false) {} else {1.} ) dump.
		
		"TESTING ^^...." dump.
		a := 10.
		([
			a := a + 3.
			if (a > 10) {^^99 }
		] value) dump.

		a := 5.
		//((a < 20) ifTrue: [ 1. if (a < 20) { ^^50 }. 90. ]) dump.
		([true] whileTrue: [
			[true] whileTrue: [
				[
				"aaa" dump.
				if (a > 20) { ^^506070 }.
				a := a + 1.
				"bbb" dump.
				] ensure: [("xxxxx" & a asString) dump].
			]
		]) dump.

		/*
		a := 5.
		while (true) {
			System logNl: a asString.
			a := a + 100000000000000.
		}.*/
		
		
		a := if(false) { 10 } elif (false) { 20 } elif (false) { 30} else { 40}.
		//a := if(false) { 999 } else { 888 }.
		a dump.

		a := 5.
		a := while (true)
		{
			a := a + 1.
			//if (a > 20) { break if (true) { break. }. }.
			if (a > 20) { 
				^if (true) { break } else {10}.   // return gets ignored for break.
			}.
			a dump.
		}.
		a dump.
		
		a := 5.
		do {
			a := do {
				("in loop....." & a asString) dump.
				//if (a > 5) { break }.
				a := a + 1.
			} while(a < 10).
		} while (false).
		a dump.

		// these should be elimited by the compiler.
		nil.
		1.
		0.
		self.
		thisProcess.
		thisContext.
		nil.
		nil.
		// end of elimination.

		// PROBLEM: the following double loop will exhaust the stack 
		while (true)
		{
			while (true) 
			{ 
				//[:j :q | (j + q) dump] value: (if (true) { 20 }) value: (if (true) { break }).
				(1 + (if (false) {} else { break })) dump.
			}.
		}.

		
		a :=999.
		a := ##(
			1, 
			2,
			a,
			4,
			1 + 1,
			##( 1, 2, ##(a, a := a + 1, a, if (a > 10) { a + 20 } ), 3),
			2 + 2,
			#"a b c"
		).
		
		/* Dictionary ???
		a := ##{ 
			key -> value ,
			key -> value ,
			key -> value ,
			key -> value
		),.
		*/

		a do: [ :v | v dump].

/*
		// how to handle return inside 'if' like the following???
		// what happens to the stack?
		a := if ((k := 20) == 10) {99} else { 100}.
		k dump.
		a dump.
*/
		"---------- END ------------" dump.
		//System sleepForSecs: 20.
	}
	
	
	
	method(#class) main
	{
		|a i|

//#self main_xx.

		a := 100.
			// PROBLEM: the following double loop will exhaust the stack 
			/*
		while (true)
		{
		//111 dump.
			while (true) 
			{ 
				//[:j :q | (j + q) dump] value: (if (true) { 20 }) value: (if (true) { break }).
				(1 + (if (false) {} else { break })) dump.
				//break.
				//[:j :q | (j + q) dump] value: 10 value: 20.
				//if (false) {} else { break }.
			}.
		}.*/


		a := ##{
			"aaa" -> 10,
			"bbb" -> 20,
			"bbb" -> 30,
			#bbb -> 40,
			Association key: 12343 value: 129908123,
			//5 -> 99,
			"ccc" -> 890
		}.

		/*a removeKey: "bbb".
		a remove: :(#bbb).*/

		//1 to: 100 do: [ :i | a at: i put: (i * 2) ].
		a keysAndValuesDo: [:k :v |
			k dump.
			v dump.
			"------------" dump.
		].

		(a associationAt: (#aaa -> nil)) dump.
		/*
		while (true) 
		{
			while (true)
			{
				[:j :q | (j + q) dump] value: (if (true) { 20 }) value: (if (true) { break }).
				(1 + (if (false) {} else { break })) dump.
			}
		}*/

		
		

		/* basicAt: 12 to access the nsdic field. use a proper method once it"s defined in Class */
	//	(System nsdic) keysAndValuesDo: [:k :v |
	//		k dump.
	//		v dump.
	//		"------------" dump.
	//	].

		
		(System at: #Processor) dump.
		System logNl: "Sleeping start now....".

		
a := System malloc(200).
i := 0.
while (i < 26)
{
	a putUint8(i, ($A asInteger + i)).
	System putUint8(a, i, ($A asInteger + i)).
	i := i + 1.
}.
while (i > 0)
{
	i := i - 1.
	a getUint8(i) asCharacter dump.
}.
a getUint32(0) dump.
a getUint32(1) dump.

//a dump.
//System free(a).
a free.

		System sleepForSecs: 2.
	}
	
	/*
	#method(#class) main
	{
		| event |
		
		Timer fire: [ "Timer job" dump. ] in: 3000.
		
		GUI on: #XXX do: [:evt | ... ].
		GUI on: #YYYY do: [:evt | ... ].

		while (true)
		{
			event := GUI waitForEvent.
			GUI dispatchEvent: event.
		}
	}*/
}

/*
pooldic XXD {
	#abc := #(1 2 3),
	#def := ##( 1, 3, 4 ) // syntax error - literal expected where ##( is
}
*/