hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

removed the containing subdir

Browse Source
This commit is contained in:
hyung-hwan
2023-10-02 21:04:28 +09:00
parent 5b2953c9c7
commit ea73f9f8d2
163 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

382
kernel/Apex.moo Normal file
View File

@ -0,0 +1,382 @@
class Apex(nil)
{
}
class(#limited) Error(Apex)
{
pooldic Code
{
ENOERR := #\E0,
EGENERIC := #\E1,
ENOIMPL := #\E2,
ESYSERR := #\E3,
EINTERN := #\E4,
ESYSMEM := #\E5,
EOOMEM := #\E6,
EINVAL := #\E7,
ENOENT := #\E8,
EPERM := #\E12,
ERANGE := #\E20,
ELIMIT := #\E9999
// add more items...
}
}
/*
pooldic Error.Code
{
ENOERR := #\E0,
EGENERIC := #\E1,
ENOIMPL := #\E2,
ESYSERR := #\E3,
EINTERN := #\E4,
ESYSMEM := #\E5,
EOOMEM := #\E6,
EINVAL := #\E7,
ENOENT := #\E8,
EPERM := #\E12,
ERANGE := #\E20,
ELIMIT := #\E9999
// add more items...
} */
/*pooldic Error.Code2
{
>> CAN I SUPPORT this kind of redefnition? as of now, it's not accepted because
>> Error.Code2.EGENERIC is not a literal. Should i treate pooldic members as a constant
>> and treat it as if it's a literal like? then even if the defined value changes,
>> the definition here won't see the change... what is the best way to tackle this issue?
EGENERIC := Error.Code2.EGENERIC
}*/
extend Apex
{
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual) dump
{
<primitive: #_dump>
}
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual) yourself { ^self }
// -------------------------------------------------------
// INSTANTIATION & INITIALIZATION
// -------------------------------------------------------
method(#class,#primitive,#lenient) _basicNew.
method(#class,#primitive,#lenient) _basicNew: size.
method(#class,#primitive) basicNew.
method(#class,#primitive) basicNew: size.
/* the following definition is almost equivalent to the simpler definition
* method(#class,#primitive) basicNew: size.
* found above.
* in the following defintion, the primitiveFailed method is executed
* from the basicNew: context. but in the simpler definition, it is executed
* in the context of the caller of the basicNew:. the context of the basicNew:
* method is not even created
method(#class) basicNew: size
{
<primitive: #Apex__basicNew:>
self primitiveFailed(thisContext method)
}*/
method(#class) new
{
| x |
x := self basicNew.
x initialize. // TODO: assess if it's good to call 'initialize' from new
^x.
}
method(#class) new: anInteger
{
| x |
x := self basicNew: anInteger.
x initialize. // TODO: assess if it's good to call 'initialize' from new.
^x.
}
method initialize
{
/* a subclass may override this method */
^self.
}
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual,#primitive,#lenient) _shallowCopy.
method(#dual,#primitive) shallowCopy.
method(#dual,#primitive,#lenient) _copy. // alias to _shallowCopy
method(#dual,#primitive) copy. // alias to shallowCopy
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual,#primitive,#lenient) _basicSize.
method(#dual,#primitive) basicSize.
method(#dual,#primitive,#lenient) _basicFirstIndex.
method(#dual,#primitive) basicFirstIndex.
method(#dual,#primitive,#lenient) _basicLastIndex.
method(#dual,#primitive) basicLastIndex.
method(#dual,#primitive) basicAt: index.
// set the slot at the given index to the new value and return the new value.
method(#dual,#primitive) basicAt: index put: newvalue.
// set the slot at the give index to the new value if the existing value is identical to the old value.
// return true if the existing value is identical to the old value and false otherwise.
method(#dual,#primitive) basicAt: index test: oldvalue put: newvalue.
method(#dual,#primitive) basicFillFrom: sindex with: value count: count.
method(#dual,#primitive) basicShiftFrom: sindex to: dindex count: count.
/* ------------------------------------------------------------------
* FINALIZATION SUPPORT
* ------------------------------------------------------------------ */
method(#dual,#primitive) addToBeFinalized.
method(#dual,#primitive) removeToBeFinalized.
/* ------------------------------------------------------------------
* HASHING
* ------------------------------------------------------------------ */
method(#dual,#primitive) hash.
/*
method(#dual) hash
{
<primitive: #Apex_hash>
self subclassResponsibility: #hash
}*/
/* ------------------------------------------------------------------
* IDENTITY TEST
* ------------------------------------------------------------------ */
// check if the receiver is identical to anObject.
// this doesn't compare the contents
method(#dual, #primitive) == anObject.
method(#dual) ~~ anObject
{
<primitive: #'Apex_~~'>
^(self == anObject) not.
}
/* ------------------------------------------------------------------
* EQUALITY TEST
* ------------------------------------------------------------------ */
method(#dual) = anObject
{
<primitive: #'Apex_='>
self subclassResponsibility: #=
}
method(#dual) ~= anObject
{
<primitive: #'Apex_~='>
^(self = anObject) not.
}
/* ------------------------------------------------------------------
* COMMON QUERIES
* ------------------------------------------------------------------ */
method(#dual,#primitive) class.
method(#dual) isNil
{
// ^self == nil.
^false
}
method(#dual) notNil
{
// ^(self == nil) not
// ^self ~= nil.
^true.
}
method(#dual) isError
{
^false
}
method(#dual) notError
{
^true
}
// -------------------------------------------------------
// -------------------------------------------------------
method(#class) inheritsFrom: aClass
{
| c |
c := self superclass.
/* [c notNil] whileTrue: [
[ c == aClass ] ifTrue: [^true].
c := c superclass.
]. */
while (c notNil)
{
if (c == aClass) { ^true }.
c := c superclass.
}.
^false
}
method(#class) isMemberOf: aClass
{
/* a class object is an instance of Class
* but Class inherits from Apex. On the other hand,
* most of ordinary classes are under Object again under Apex.
* special consideration is required here. */
^aClass == Class
}
method isMemberOf: aClass
{
^self class == aClass
}
method(#dual) isKindOf: aClass
{
<primitive: #Apex_isKindOf:>
^(self isMemberOf: aClass) or: [self class inheritsFrom: aClass].
}
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual,#primitive) respondsTo: selector.
// -------------------------------------------------------
// -------------------------------------------------------
method(#dual,#variadic,#primitive) perform(selector).
method(#dual) perform: selector
{
<primitive: #Apex_perform>
self primitiveFailed
}
method(#dual) perform: selector with: arg1
{
<primitive: #Apex_perform>
self primitiveFailed
}
method(#dual) perform: selector with: arg1 with: arg2
{
<primitive: #Apex_perform>
self primitiveFailed
}
method(#dual) perform: selector with: arg1 with: arg2 with: arg3
{
<primitive: #Apex_perform>
self primitiveFailed
}
}
class Object(Apex)
{
}
class UndefinedObject(Apex)
{
method isNil
{
^true
}
method notNil
{
^false.
}
/**
method handleException: exception
{
("### EXCEPTION NOT HANDLED #### " & exception class name & " - " & exception messageText) dump.
// TODO: debug the current process???? "
// TODO: ensure to execute ensure blocks as well....
////Processor activeProcess terminate.
}
**/
}
extend Error
{
/* ----------------------------
TODO: support nested pooldic/constant declaration...
pooldic/const
{
NONE := #\e0,
GENERIC := #\e1
}
-------------------------------- */
method isError
{
^true
}
method notError
{
^false
}
method(#primitive) asCharacter.
method asError { ^self }
method(#primitive) asInteger.
method(#primitive) asString.
/* -----------------------
method signal
{
| exctx exblk retval actpos ctx |
exctx := (thisContext sender) findExceptionContext.
while (exctx notNil)
{
exblk := exctx findExceptionHandler: (self class).
if (exblk notNil and: [actpos := exctx basicSize - 1. exctx basicAt: actpos])
{
exctx basicAt: actpos put: false.
[ retval := exblk value: self ] ensure: [ exctx basicAt: actpos put: true ].
thisContext unwindTo: (exctx sender) return: nil.
System return: retval to: (exctx sender).
}.
exctx := (exctx sender) findExceptionContext.
}.
// -----------------------------------------------------------------
// FATAL ERROR - no exception handler.
// -----------------------------------------------------------------
//thisContext unwindTo: nil return: nil.
//thisContext unwindTo: (Processor activeProcess initialContext) return: nil.
System backtrace.
thisContext unwindTo: (thisProcess initialContext) return: nil.
("### ERROR NOT HANDLED #### " & self class name & " - " & self asString) dump.
// TODO: debug the current process???? "
//Processor activeProcess terminate.
thisProcess terminate.
}
---------------------- */
}