2
0

Kernel-Methods.st 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726
  1. Smalltalk createPackage: 'Kernel-Methods'!
  2. Object subclass: #BlockClosure
  3. instanceVariableNames: ''
  4. package: 'Kernel-Methods'!
  5. !BlockClosure commentStamp!
  6. I represent a lexical closure.
  7. I am is directly mapped to JavaScript Function.
  8. ## API
  9. 1. Evaluation
  10. My instances get evaluated with the `#value*` methods in the 'evaluating' protocol.
  11. Example: ` [ :x | x + 1 ] value: 3 "Answers 4" `
  12. 2. Control structures
  13. Blocks are used (together with `Boolean`) for control structures (methods in the `controlling` protocol).
  14. Example: `aBlock whileTrue: [ ... ]`
  15. 3. Error handling
  16. I provide the `#on:do:` method for handling exceptions.
  17. Example: ` aBlock on: MessageNotUnderstood do: [ :ex | ... ] `!
  18. !BlockClosure methodsFor: 'accessing'!
  19. compiledSource
  20. <return self.toString()>
  21. !
  22. numArgs
  23. <return self.length>
  24. !
  25. receiver
  26. ^ nil
  27. ! !
  28. !BlockClosure methodsFor: 'controlling'!
  29. whileFalse
  30. self whileFalse: []
  31. !
  32. whileFalse: aBlock
  33. <while(!!smalltalk.assert(self._value())) {aBlock._value()}>
  34. !
  35. whileTrue
  36. self whileTrue: []
  37. !
  38. whileTrue: aBlock
  39. <while(smalltalk.assert(self._value())) {aBlock._value()}>
  40. ! !
  41. !BlockClosure methodsFor: 'converting'!
  42. asCompiledMethod: aString
  43. <return smalltalk.method({selector:aString, fn:self});>
  44. !
  45. currySelf
  46. "Transforms [ :selfarg :x :y | stcode ] block
  47. which represents JS function (selfarg, x, y, ...) {jscode}
  48. into function (x, y, ...) {jscode} that takes selfarg from 'this'.
  49. IOW, it is usable as JS method and first arg takes the receiver."
  50. <
  51. return function () {
  52. var args = [ this ];
  53. args.push.apply(args, arguments);
  54. return self.apply(null, args);
  55. }
  56. >
  57. ! !
  58. !BlockClosure methodsFor: 'error handling'!
  59. on: anErrorClass do: aBlock
  60. "All exceptions thrown in the Smalltalk stack are cought.
  61. Convert all JS exceptions to JavaScriptException instances."
  62. ^ self try: self catch: [ :error | | smalltalkError |
  63. smalltalkError := Smalltalk asSmalltalkException: error.
  64. (smalltalkError isKindOf: anErrorClass)
  65. ifTrue: [ aBlock value: smalltalkError ]
  66. ifFalse: [ smalltalkError resignal ] ]
  67. ! !
  68. !BlockClosure methodsFor: 'evaluating'!
  69. applyTo: anObject arguments: aCollection
  70. <return self.apply(anObject, aCollection)>
  71. !
  72. ensure: aBlock
  73. <try{return self._value()}finally{aBlock._value()}>
  74. !
  75. new
  76. "Use the receiver as a JS constructor.
  77. *Do not* use this method to instanciate Smalltalk objects!!"
  78. <return new self()>
  79. !
  80. newValue: anObject
  81. ^ self newWithValues: { anObject }
  82. !
  83. newValue: anObject value: anObject2
  84. ^ self newWithValues: { anObject. anObject2 }.
  85. !
  86. newValue: anObject value: anObject2 value: anObject3
  87. ^ self newWithValues: { anObject. anObject2. anObject3 }.
  88. !
  89. newWithValues: aCollection
  90. "Use the receiver as a JavaScript constructor with a variable number of arguments.
  91. Answer the object created using the operator `new`.
  92. This algorithm was inspired by http://stackoverflow.com/a/6069331.
  93. Here's a general breakdown of what's going on:
  94. 1) Create a new, empty constructor function.
  95. 2) Set it's prototype to the receiver's prototype. Because the receiver is a `BlockClosure`, it is also a JavaScript function.
  96. 3) Instantiate a new object using the constructor function just created.
  97. This forces the interpreter to set the internal [[prototype]] property to what was set on the function before.
  98. This has to be done, as we have no access to the [[prototype]] property externally.
  99. 4) Apply `self` to the object I just instantiated."
  100. <
  101. var constructor = function() {};
  102. constructor.prototype = self.prototype;
  103. var object = new constructor;
  104. var result = self.apply(object, aCollection);
  105. return typeof result === "object" ? result : object;
  106. >
  107. !
  108. timeToRun
  109. "Answer the number of milliseconds taken to execute this block."
  110. ^ Date millisecondsToRun: self
  111. !
  112. value
  113. <return self();>
  114. !
  115. value: anArg
  116. <return self(anArg);>
  117. !
  118. value: firstArg value: secondArg
  119. <return self(firstArg, secondArg);>
  120. !
  121. value: firstArg value: secondArg value: thirdArg
  122. <return self(firstArg, secondArg, thirdArg);>
  123. !
  124. valueWithPossibleArguments: aCollection
  125. <return self.apply(null, aCollection);>
  126. ! !
  127. !BlockClosure methodsFor: 'timeout/interval'!
  128. fork
  129. ForkPool default fork: self
  130. !
  131. valueWithInterval: aNumber
  132. <
  133. var interval = setInterval(self, aNumber);
  134. return smalltalk.Timeout._on_(interval);
  135. >
  136. !
  137. valueWithTimeout: aNumber
  138. <
  139. var timeout = setTimeout(self, aNumber);
  140. return smalltalk.Timeout._on_(timeout);
  141. >
  142. ! !
  143. Object subclass: #CompiledMethod
  144. instanceVariableNames: ''
  145. package: 'Kernel-Methods'!
  146. !CompiledMethod commentStamp!
  147. I represent a class method of the system. I hold the source and compiled code of a class method.
  148. ## API
  149. My instances can be accessed using `Behavior >> #methodAt:`
  150. Object methodAt: 'asString'
  151. Source code access:
  152. (String methodAt: 'lines') source
  153. Referenced classes:
  154. (String methodAt: 'lines') referencedClasses
  155. Messages sent from an instance:
  156. (String methodAt: 'lines') messageSends!
  157. !CompiledMethod methodsFor: 'accessing'!
  158. arguments
  159. <return self.args || []>
  160. !
  161. category
  162. ^ self protocol
  163. !
  164. fn
  165. ^ self basicAt: 'fn'
  166. !
  167. fn: aBlock
  168. self basicAt: 'fn' put: aBlock
  169. !
  170. messageSends
  171. ^ self basicAt: 'messageSends'
  172. !
  173. methodClass
  174. ^ self basicAt: 'methodClass'
  175. !
  176. protocol
  177. ^ (self basicAt: 'protocol') ifNil: [ self defaultProtocol ]
  178. !
  179. protocol: aString
  180. | oldProtocol |
  181. oldProtocol := self protocol.
  182. self basicAt: 'protocol' put: aString.
  183. SystemAnnouncer current announce: (MethodMoved new
  184. method: self;
  185. oldProtocol: oldProtocol;
  186. yourself).
  187. self methodClass ifNotNil: [ :methodClass |
  188. methodClass organization addElement: aString.
  189. methodClass removeProtocolIfEmpty: oldProtocol ]
  190. !
  191. referencedClasses
  192. ^ self basicAt: 'referencedClasses'
  193. !
  194. selector
  195. ^ self basicAt: 'selector'
  196. !
  197. selector: aString
  198. self basicAt: 'selector' put: aString
  199. !
  200. source
  201. ^ (self basicAt: 'source') ifNil: [ '' ]
  202. !
  203. source: aString
  204. self basicAt: 'source' put: aString
  205. ! !
  206. !CompiledMethod methodsFor: 'defaults'!
  207. defaultProtocol
  208. ^ 'as yet unclassified'
  209. ! !
  210. !CompiledMethod methodsFor: 'evaluating'!
  211. sendTo: anObject arguments: aCollection
  212. ^ self fn applyTo: anObject arguments: aCollection
  213. ! !
  214. !CompiledMethod methodsFor: 'testing'!
  215. isCompiledMethod
  216. ^ true
  217. !
  218. isOverridden
  219. | selector |
  220. selector := self selector.
  221. self methodClass allSubclassesDo: [ :each |
  222. (each includesSelector: selector)
  223. ifTrue: [ ^ true ] ].
  224. ^ false
  225. !
  226. isOverride
  227. | superclass |
  228. superclass := self methodClass superclass.
  229. superclass ifNil: [ ^ false ].
  230. ^ (self methodClass superclass lookupSelector: self selector) notNil
  231. ! !
  232. Object subclass: #ForkPool
  233. instanceVariableNames: 'poolSize maxPoolSize queue worker'
  234. package: 'Kernel-Methods'!
  235. !ForkPool commentStamp!
  236. I am responsible for handling forked blocks.
  237. The pool size sets the maximum concurrent forked blocks.
  238. ## API
  239. The default instance is accessed with `#default`.
  240. The maximum concurrent forked blocks can be set with `#maxPoolSize:`.
  241. Forking is done via `BlockClosure >> #fork`!
  242. !ForkPool methodsFor: 'accessing'!
  243. maxPoolSize
  244. ^ maxPoolSize ifNil: [ self defaultMaxPoolSize ]
  245. !
  246. maxPoolSize: anInteger
  247. maxPoolSize := anInteger
  248. ! !
  249. !ForkPool methodsFor: 'actions'!
  250. fork: aBlock
  251. poolSize < self maxPoolSize ifTrue: [ self addWorker ].
  252. queue nextPut: aBlock
  253. ! !
  254. !ForkPool methodsFor: 'defaults'!
  255. defaultMaxPoolSize
  256. ^ self class defaultMaxPoolSize
  257. ! !
  258. !ForkPool methodsFor: 'initialization'!
  259. initialize
  260. super initialize.
  261. poolSize := 0.
  262. queue := Queue new.
  263. worker := self makeWorker
  264. !
  265. makeWorker
  266. | sentinel |
  267. sentinel := Object new.
  268. ^ [ | block |
  269. poolSize := poolSize - 1.
  270. block := queue nextIfAbsent: [ sentinel ].
  271. block == sentinel ifFalse: [
  272. [ block value ] ensure: [ self addWorker ] ]]
  273. ! !
  274. !ForkPool methodsFor: 'private'!
  275. addWorker
  276. worker valueWithTimeout: 0.
  277. poolSize := poolSize + 1
  278. ! !
  279. ForkPool class instanceVariableNames: 'default'!
  280. !ForkPool class methodsFor: 'accessing'!
  281. default
  282. ^ default ifNil: [ default := self new ]
  283. !
  284. defaultMaxPoolSize
  285. ^ 100
  286. !
  287. resetDefault
  288. default := nil
  289. ! !
  290. Object subclass: #Message
  291. instanceVariableNames: 'selector arguments'
  292. package: 'Kernel-Methods'!
  293. !Message commentStamp!
  294. In general, the system does not use instances of me for efficiency reasons.
  295. However, when a message is not understood by its receiver, the interpreter will make up an instance of it in order to capture the information involved in an actual message transmission.
  296. This instance is sent it as an argument with the message `#doesNotUnderstand:` to the receiver.
  297. See boot.js, `messageNotUnderstood` and its counterpart `Object >> #doesNotUnderstand:`
  298. ## API
  299. Besides accessing methods, `#sendTo:` provides a convenient way to send a message to an object.!
  300. !Message methodsFor: 'accessing'!
  301. arguments
  302. ^ arguments
  303. !
  304. arguments: anArray
  305. arguments := anArray
  306. !
  307. selector
  308. ^ selector
  309. !
  310. selector: aString
  311. selector := aString
  312. ! !
  313. !Message methodsFor: 'actions'!
  314. sendTo: anObject
  315. ^ anObject perform: self selector withArguments: self arguments
  316. ! !
  317. !Message methodsFor: 'printing'!
  318. printOn: aStream
  319. super printOn: aStream.
  320. aStream
  321. nextPutAll: '(';
  322. nextPutAll: self selector;
  323. nextPutAll: ')'
  324. ! !
  325. !Message class methodsFor: 'instance creation'!
  326. selector: aString arguments: anArray
  327. ^ self new
  328. selector: aString;
  329. arguments: anArray;
  330. yourself
  331. ! !
  332. Object subclass: #MessageSend
  333. instanceVariableNames: 'receiver message'
  334. package: 'Kernel-Methods'!
  335. !MessageSend commentStamp!
  336. I encapsulate message sends to objects. Arguments can be either predefined or supplied when the message send is performed.
  337. ## API
  338. Use `#value` to perform a message send with its predefined arguments and `#value:*` if additonal arguments have to supplied.!
  339. !MessageSend methodsFor: 'accessing'!
  340. arguments
  341. ^ message arguments
  342. !
  343. arguments: aCollection
  344. message arguments: aCollection
  345. !
  346. receiver
  347. ^ receiver
  348. !
  349. receiver: anObject
  350. receiver := anObject
  351. !
  352. selector
  353. ^ message selector
  354. !
  355. selector: aString
  356. message selector: aString
  357. ! !
  358. !MessageSend methodsFor: 'evaluating'!
  359. value
  360. ^ message sendTo: self receiver
  361. !
  362. value: anObject
  363. ^ message
  364. arguments: { anObject };
  365. sendTo: self receiver
  366. !
  367. value: firstArgument value: secondArgument
  368. ^ message
  369. arguments: { firstArgument. secondArgument };
  370. sendTo: self receiver
  371. !
  372. value: firstArgument value: secondArgument value: thirdArgument
  373. ^ message
  374. arguments: { firstArgument. secondArgument. thirdArgument };
  375. sendTo: self receiver
  376. !
  377. valueWithPossibleArguments: aCollection
  378. self arguments: aCollection.
  379. ^ self value
  380. ! !
  381. !MessageSend methodsFor: 'initialization'!
  382. initialize
  383. super initialize.
  384. message := Message new
  385. ! !
  386. !MessageSend methodsFor: 'printing'!
  387. printOn: aStream
  388. super printOn: aStream.
  389. aStream
  390. nextPutAll: '(';
  391. nextPutAll: self receiver;
  392. nextPutAll: ' >> ';
  393. nextPutAll: self selector;
  394. nextPutAll: ')'
  395. ! !
  396. Object subclass: #MethodContext
  397. instanceVariableNames: ''
  398. package: 'Kernel-Methods'!
  399. !MethodContext commentStamp!
  400. I hold all the dynamic state associated with the execution of either a method activation resulting from a message send. I am used to build the call stack while debugging.
  401. My instances are JavaScript `SmalltalkMethodContext` objects defined in `boot.js`.!
  402. !MethodContext methodsFor: 'accessing'!
  403. evaluatedSelector
  404. <return self.evaluatedSelector>
  405. !
  406. home
  407. <return self.homeContext>
  408. !
  409. index
  410. <return self.index || 0>
  411. !
  412. locals
  413. <return self.locals || {}>
  414. !
  415. method
  416. ^ self methodContext ifNotNil: [
  417. self methodContext receiver class lookupSelector: self methodContext selector ]
  418. !
  419. methodContext
  420. self isBlockContext ifFalse: [ ^ self ].
  421. ^ self outerContext ifNotNil: [ :outer |
  422. outer methodContext ]
  423. !
  424. outerContext
  425. <return self.outerContext || self.homeContext>
  426. !
  427. receiver
  428. <return self.receiver>
  429. !
  430. selector
  431. <
  432. if(self.selector) {
  433. return smalltalk.convertSelector(self.selector);
  434. } else {
  435. return nil;
  436. }
  437. >
  438. !
  439. sendIndexAt: aSelector
  440. <return self.sendIdx[aSelector] || 0>
  441. !
  442. sendIndexes
  443. <return self.sendIdx>
  444. !
  445. temps
  446. self deprecatedAPI.
  447. ^ self locals
  448. ! !
  449. !MethodContext methodsFor: 'converting'!
  450. asString
  451. ^ self isBlockContext
  452. ifTrue: [ 'a block (in ', self methodContext asString, ')' ]
  453. ifFalse: [ self receiver class name, ' >> ', self selector ]
  454. ! !
  455. !MethodContext methodsFor: 'printing'!
  456. printOn: aStream
  457. super printOn: aStream.
  458. aStream
  459. nextPutAll: '(';
  460. nextPutAll: self asString;
  461. nextPutAll: ')'
  462. ! !
  463. !MethodContext methodsFor: 'testing'!
  464. isBlockContext
  465. "Block context do not have selectors."
  466. ^ self selector isNil
  467. ! !
  468. Object subclass: #NativeFunction
  469. instanceVariableNames: ''
  470. package: 'Kernel-Methods'!
  471. !NativeFunction commentStamp!
  472. I am a wrapper around native functions, such as `WebSocket`.
  473. For 'normal' functions (whose constructor is the JavaScript `Function` object), use `BlockClosure`.
  474. ## API
  475. See the class-side `instance creation` methods for instance creation.
  476. Created instances will most probably be instance of `JSObjectProxy`.
  477. ## Usage example:
  478. | ws |
  479. ws := NativeFunction constructor: 'WebSocket' value: 'ws://localhost'.
  480. ws at: 'onopen' put: [ ws send: 'hey there from Amber' ]!
  481. !NativeFunction class methodsFor: 'instance creation'!
  482. constructor: aString
  483. <
  484. var native=eval(aString);
  485. return new native();
  486. >
  487. !
  488. constructor: aString value:anObject
  489. <
  490. var native=eval(aString);
  491. return new native(anObject);
  492. >
  493. !
  494. constructor: aString value:anObject value: anObject2
  495. <
  496. var native=eval(aString);
  497. return new native(anObject,anObject2);
  498. >
  499. !
  500. constructor: aString value:anObject value: anObject2 value:anObject3
  501. <
  502. var native=eval(aString);
  503. return new native(anObject,anObject2, anObject3);
  504. >
  505. ! !
  506. !NativeFunction class methodsFor: 'testing'!
  507. exists: aString
  508. ^ PlatformInterface existsGlobal: aString
  509. ! !
  510. Object subclass: #Timeout
  511. instanceVariableNames: 'rawTimeout'
  512. package: 'Kernel-Methods'!
  513. !Timeout commentStamp!
  514. I am wrapping the returns from `set{Timeout,Interval}`.
  515. ## Motivation
  516. Number suffices in browsers, but node.js returns an object.!
  517. !Timeout methodsFor: 'accessing'!
  518. rawTimeout: anObject
  519. rawTimeout := anObject
  520. ! !
  521. !Timeout methodsFor: 'timeout/interval'!
  522. clearInterval
  523. <
  524. var interval = self["@rawTimeout"];
  525. clearInterval(interval);
  526. >
  527. !
  528. clearTimeout
  529. <
  530. var timeout = self["@rawTimeout"];
  531. clearTimeout(timeout);
  532. >
  533. ! !
  534. !Timeout class methodsFor: 'instance creation'!
  535. on: anObject
  536. ^ self new rawTimeout: anObject; yourself
  537. ! !