removed the containing subdir

kernel/Magnitu.moo

@@ -0,0 +1,431 @@
+class Magnitude(Object)
+{
+	method <  aMagnitude { self subclassResponsibility: #<	}
+	method >  aMagnitude { ^aMagnitude < self }
+	method <= aMagnitude { ^(aMagnitude < self) not }
+	method >= aMagnitude { ^(self < aMagnitude) not }
+    
+	method between: min and: max 
+	{
+		^self >= min and self <= max
+	}
+
+	method min: aMagnitude
+	{
+		//^self < aMagnitude ifTrue: [self] ifFalse: [aMagnitude]
+		^if (self < aMagnitude) { self } else { aMagnitude }.
+	}
+
+	method max: aMagnitude
+	{
+		//^self > aMagnitude ifTrue: [self] ifFalse: [aMagnitude]
+		^if (self > aMagnitude) { self } else { aMagnitude }.
+		
+	}
+}
+
+class Association(Magnitude)
+{
+	var key, value.
+
+	method(#class) key: key value: value
+	{
+		^self new key: key value: value
+	}
+
+	method key: key value: value
+	{
+		self.key := key.
+		self.value := value.
+	}
+
+	method value: value
+	{
+		self.value := value
+	}
+
+	method key
+	{
+		^self.key
+	}
+
+	method value
+	{
+		^self.value
+	}
+
+	method = ass
+	{
+		^(self.key = ass key) and (self.value = ass value)
+	}
+
+	method hash
+	{
+		^(self.key hash) + (self.value hash)
+	}
+}
+
+class(#limited) Character(Magnitude)
+{
+//	method(#primitive,#class) codePoint: code.
+//	method(#primitive) codePoint.
+
+	method asCharacter { ^self }
+	method(#primitive) asError.
+	method(#primitive) asInteger.
+
+	method(#primitive) < char.
+	method(#primitive) > char.
+	method(#primitive) <= char.
+	method(#primitive) >= char.
+
+	method digitValue: anInteger
+	{
+		^'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' at: anInteger
+	}
+
+	method digitValue
+	{
+		//<primitive: #Character_digitValue>
+
+		if ((self >= $0) and (self <= $9))
+		{
+			^self asInteger - $0 asInteger
+		}
+		elif ((self >= $A) and (self <= $Z))
+		{
+			^self asInteger - $A asInteger + 10
+		}
+		elif ((self >= $a) and (self <= $z))
+		{
+			^self asInteger - $a asInteger + 10
+		}.
+
+		//Exception signal: 'not a digit character'.
+		^-1
+	}
+}
+
+class(#limited) Number(Magnitude)
+{
+	method + aNumber
+	{
+		<primitive: #_number_add>
+		self primitiveFailed.
+	}
+
+	method - aNumber
+	{
+		<primitive: #_number_sub>
+		self primitiveFailed.
+	}
+
+	method * aNumber
+	{
+		<primitive: #_number_mul>
+		self primitiveFailed.
+	}
+
+	method mul: aNumber
+	{
+		<primitive: #_number_mul>
+		self primitiveFailed.
+	}
+
+	method mlt: aNumber
+	{
+		<primitive: #_number_mlt>
+		self primitiveFailed.
+	}
+
+	method div: aNumber
+	{
+		// integer division rounded toward zero
+		<primitive: #_number_div>
+		self primitiveFailed.
+	}
+
+	method rem: aNumber
+	{
+		// integer remainder rounded toward zero
+		<primitive: #Integer_rem>
+		self primitiveFailed.
+	}
+
+	method mdiv: aNumber
+	{
+		// integer division quotient
+		<primitive: #_number_mdiv>
+		self primitiveFailed.
+	}
+	
+	method mod: aNumber
+	{
+		// integer division remainder
+		<primitive: #Integer_mod>
+		self primitiveFailed.
+	}
+	
+	//method / aNumber
+	//{
+	//	// fraction? fixed-point decimal? floating-point?
+	//}
+
+	method = aNumber
+	{
+		<primitive: #_number_eq>
+		self primitiveFailed.
+	}
+
+	method ~= aNumber
+	{
+		<primitive: #_number_ne>
+		self primitiveFailed.
+	}
+
+	method < aNumber
+	{
+		<primitive: #_number_lt>
+		self primitiveFailed.
+	}
+
+	method > aNumber
+	{
+		<primitive: #_number_gt>
+		self primitiveFailed.
+	}
+
+	method <= aNumber
+	{
+		<primitive: #_number_le>
+		self primitiveFailed.
+	}
+
+	method >= aNumber
+	{
+		<primitive: #_number_ge>
+		self primitiveFailed.
+	}
+
+	method negated
+	{
+		<primitive: #_number_negated>
+		^0 - self.
+	}
+
+	method bitAt: index
+	{
+		<primitive: #Integer_bitat>
+		^(self bitShift: index negated) bitAnd: 1.
+	}
+
+	method(#variadic) bitAnd(operand)
+	{
+		<primitive: #Integer_bitand>
+		self primitiveFailed.
+	}
+
+	method bitAnd: aNumber
+	{
+		<primitive: #Integer_bitand>
+		self primitiveFailed.
+	}
+
+	method(#variadic) bitOr(operand)
+	{
+		<primitive: #Integer_bitor>
+		self primitiveFailed.
+	}
+
+	method bitOr: aNumber
+	{
+		<primitive: #Integer_bitor>
+		self primitiveFailed.
+	}
+
+	method(#variadic) bitXor(operand)
+	{
+		<primitive: #Integer_bitxor>
+		self primitiveFailed.
+	}
+
+	method bitXor: aNumber
+	{
+		<primitive: #Integer_bitxor>
+		self primitiveFailed.
+	}
+
+	method bitInvert
+	{
+		<primitive: #Integer_bitinv>
+		^-1 - self.
+	}
+
+	method bitShift: aNumber
+	{
+		/* positive number for left shift. 
+		 * negative number for right shift */
+
+		<primitive: #Integer_bitshift>
+		self primitiveFailed.
+	}
+
+	method asString
+	{
+		^self printStringRadix: 10
+	}
+
+	method printStringRadix: aNumber
+	{
+		<primitive: #_number_numtostr>
+		self primitiveFailed.
+	}
+
+	method to: end by: step do: block
+	{
+		| i |
+		i := self.
+		/*
+		(step > 0) 
+			ifTrue: [
+				[ i <= end ] whileTrue: [ 
+					block value: i.
+					i := i + step.
+				].
+			]
+			ifFalse: [
+				[ i >= end ] whileTrue: [
+					block value: i.
+					i := i - step.
+				].
+			].
+		*/
+		if (step > 0)
+		{
+			while (i <= end)
+			{
+				block value: i.
+				i := i + step.
+			}
+		}
+		else
+		{
+			while ( i => end)
+			{
+				block value: i.
+				i := i - step.
+			}
+		}
+	}
+
+	method to: end do: block
+	{
+		^self to: end by: 1 do: block.
+	}
+
+	method priorTo: end by: step do: block
+	{
+		| i |
+		i := self.
+		/*
+		(step > 0) 
+			ifTrue: [
+				[ i < end ] whileTrue: [ 
+					block value: i.
+					i := i + step.
+				].
+			]
+			ifFalse: [
+				[ i > end ] whileTrue: [
+					block value: i.
+					i := i - step.
+				].
+			].
+		*/
+		if (step > 0)
+		{
+			while (i < end)
+			{
+				block value: i.
+				i := i + step.
+			}
+		}
+		else
+		{
+			while ( i > end)
+			{
+				block value: i.
+				i := i - step.
+			}
+		}
+	}
+	
+	method priorTo: end do: block
+	{
+		^self priorTo: end by: 1 do: block.
+	}
+
+	method abs
+	{
+		/*self < 0 ifTrue: [^self negated].
+		^self.*/
+		^if (self < 0) { self negated } else { self }
+	}
+
+	method sign
+	{
+		/* self < 0 ifTrue: [^-1].
+		self > 0 ifTrue: [^1].
+		^0.*/
+		^if (self < 0) { -1 } elif (self > 0) { 1 } else { 0 }
+	}
+}
+
+class(#limited) Integer(Number)
+{
+	method timesRepeat: aBlock
+	{
+		// 1 to: self by: 1 do: [ :count | aBlock value ].
+		| count |
+		count := 0.
+		while (count < self) { aBlock value. count := count + 1 }
+	}
+	
+	method asInteger { ^self }
+
+	// integer has the scale of 0.
+	method scale { ^0 }
+
+	// non-zero positive scale converts integer to fixed-point decimal
+	method(#primitive) scale: ndigits.
+}
+
+class(#limited) SmallInteger(Integer)
+{
+	method(#primitive) asCharacter.
+	method(#primitive) asError.
+}
+
+class(#limited,#immutable,#liword) LargeInteger(Integer)
+{
+}
+
+class(#limited,#immutable,#liword) LargePositiveInteger(LargeInteger)
+{
+	method abs { ^self }
+	method sign { ^1 }
+}
+
+class(#limited,#immutable,#liword) LargeNegativeInteger(LargeInteger)
+{
+	method abs { ^self negated }
+	method sign { ^-1 }
+}
+
+class(#limited,#immutable) FixedPointDecimal(Number)
+{
+	var value.
+	var(#get) scale.
+
+	method(#primitive) scale: ndigits.
+}