2
0

Kernel-Methods.st 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715
  1. Smalltalk current 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 current 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 basicAt: 'category') ifNil: [ self defaultCategory ]
  163. !
  164. category: aString
  165. | oldProtocol |
  166. oldProtocol := self protocol.
  167. self basicAt: 'category' put: aString.
  168. SystemAnnouncer current announce: (MethodMoved new
  169. method: self;
  170. oldProtocol: oldProtocol;
  171. yourself).
  172. self methodClass ifNotNil: [
  173. self methodClass organization addElement: aString.
  174. (self methodClass methods
  175. select: [ :each | each protocol = oldProtocol ])
  176. ifEmpty: [ self methodClass organization removeElement: oldProtocol ] ]
  177. !
  178. fn
  179. ^self basicAt: 'fn'
  180. !
  181. fn: aBlock
  182. self basicAt: 'fn' put: aBlock
  183. !
  184. messageSends
  185. ^self basicAt: 'messageSends'
  186. !
  187. methodClass
  188. ^self basicAt: 'methodClass'
  189. !
  190. protocol
  191. ^ self category
  192. !
  193. protocol: aString
  194. self category: aString
  195. !
  196. referencedClasses
  197. ^self basicAt: 'referencedClasses'
  198. !
  199. selector
  200. ^self basicAt: 'selector'
  201. !
  202. selector: aString
  203. self basicAt: 'selector' put: aString
  204. !
  205. source
  206. ^(self basicAt: 'source') ifNil: ['']
  207. !
  208. source: aString
  209. self basicAt: 'source' put: aString
  210. ! !
  211. !CompiledMethod methodsFor: 'defaults'!
  212. defaultCategory
  213. ^ 'as yet unclassified'
  214. ! !
  215. !CompiledMethod methodsFor: 'testing'!
  216. isCompiledMethod
  217. ^ true
  218. !
  219. isOverridden
  220. | selector |
  221. selector := self selector.
  222. self methodClass allSubclassesDo: [ :each |
  223. (each includesSelector: selector)
  224. ifTrue: [ ^ true ] ].
  225. ^ false
  226. !
  227. isOverride
  228. | superclass |
  229. superclass := self methodClass superclass.
  230. superclass ifNil: [ ^ false ].
  231. ^ (self methodClass superclass lookupSelector: self selector) notNil
  232. ! !
  233. Object subclass: #ForkPool
  234. instanceVariableNames: 'poolSize maxPoolSize queue worker'
  235. package: 'Kernel-Methods'!
  236. !ForkPool commentStamp!
  237. I am responsible for handling forked blocks.
  238. The pool size sets the maximum concurrent forked blocks.
  239. ## API
  240. The default instance is accessed with `#default`.
  241. The maximum concurrent forked blocks can be set with `#maxPoolSize:`.
  242. Forking is done via `BlockClosure >> #fork`!
  243. !ForkPool methodsFor: 'accessing'!
  244. maxPoolSize
  245. ^ maxPoolSize ifNil: [ self defaultMaxPoolSize ]
  246. !
  247. maxPoolSize: anInteger
  248. maxPoolSize := anInteger
  249. ! !
  250. !ForkPool methodsFor: 'actions'!
  251. fork: aBlock
  252. poolSize < self maxPoolSize ifTrue: [ self addWorker ].
  253. queue nextPut: aBlock
  254. ! !
  255. !ForkPool methodsFor: 'defaults'!
  256. defaultMaxPoolSize
  257. ^ self class defaultMaxPoolSize
  258. ! !
  259. !ForkPool methodsFor: 'initialization'!
  260. initialize
  261. super initialize.
  262. poolSize := 0.
  263. queue := Queue new.
  264. worker := self makeWorker
  265. !
  266. makeWorker
  267. | sentinel |
  268. sentinel := Object new.
  269. ^[ | block |
  270. poolSize := poolSize - 1.
  271. block := queue nextIfAbsent: [ sentinel ].
  272. block == sentinel ifFalse: [
  273. [ block value ] ensure: [ self addWorker ]]]
  274. ! !
  275. !ForkPool methodsFor: 'private'!
  276. addWorker
  277. worker valueWithTimeout: 0.
  278. poolSize := poolSize + 1
  279. ! !
  280. ForkPool class instanceVariableNames: 'default'!
  281. !ForkPool class methodsFor: 'accessing'!
  282. default
  283. ^default ifNil: [ default := self new ]
  284. !
  285. defaultMaxPoolSize
  286. ^100
  287. !
  288. resetDefault
  289. default := nil
  290. ! !
  291. Object subclass: #Message
  292. instanceVariableNames: 'selector arguments'
  293. package: 'Kernel-Methods'!
  294. !Message commentStamp!
  295. In general, the system does not use instances of me for efficiency reasons.
  296. 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.
  297. This instance is sent it as an argument with the message `#doesNotUnderstand:` to the receiver.
  298. See boot.js, `messageNotUnderstood` and its counterpart `Object >> #doesNotUnderstand:`
  299. ## API
  300. Besides accessing methods, `#sendTo:` provides a convenient way to send a message to an object.!
  301. !Message methodsFor: 'accessing'!
  302. arguments
  303. ^arguments
  304. !
  305. arguments: anArray
  306. arguments := anArray
  307. !
  308. selector
  309. ^selector
  310. !
  311. selector: aString
  312. selector := aString
  313. ! !
  314. !Message methodsFor: 'actions'!
  315. sendTo: anObject
  316. ^ anObject perform: self selector withArguments: self arguments
  317. ! !
  318. !Message methodsFor: 'printing'!
  319. printOn: aStream
  320. super printOn: aStream.
  321. aStream
  322. nextPutAll: '(';
  323. nextPutAll: self selector;
  324. nextPutAll: ')'
  325. ! !
  326. !Message class methodsFor: 'instance creation'!
  327. selector: aString arguments: anArray
  328. ^self new
  329. selector: aString;
  330. arguments: anArray;
  331. yourself
  332. ! !
  333. Object subclass: #MessageSend
  334. instanceVariableNames: 'receiver message'
  335. package: 'Kernel-Methods'!
  336. !MessageSend commentStamp!
  337. I encapsulate message sends to objects. Arguments can be either predefined or supplied when the message send is performed.
  338. ## API
  339. Use `#value` to perform a message send with its predefined arguments and `#value:*` if additonal arguments have to supplied.!
  340. !MessageSend methodsFor: 'accessing'!
  341. arguments
  342. ^ message arguments
  343. !
  344. arguments: aCollection
  345. message arguments: aCollection
  346. !
  347. receiver
  348. ^ receiver
  349. !
  350. receiver: anObject
  351. receiver := anObject
  352. !
  353. selector
  354. ^ message selector
  355. !
  356. selector: aString
  357. message selector: aString
  358. ! !
  359. !MessageSend methodsFor: 'evaluating'!
  360. value
  361. ^ message sendTo: self receiver
  362. !
  363. value: anObject
  364. ^ message
  365. arguments: { anObject };
  366. sendTo: self receiver
  367. !
  368. value: firstArgument value: secondArgument
  369. ^ message
  370. arguments: { firstArgument. secondArgument };
  371. sendTo: self receiver
  372. !
  373. value: firstArgument value: secondArgument value: thirdArgument
  374. ^ message
  375. arguments: { firstArgument. secondArgument. thirdArgument };
  376. sendTo: self receiver
  377. !
  378. valueWithPossibleArguments: aCollection
  379. self arguments: aCollection.
  380. ^ self value
  381. ! !
  382. !MessageSend methodsFor: 'initialization'!
  383. initialize
  384. super initialize.
  385. message := Message new
  386. ! !
  387. !MessageSend methodsFor: 'printing'!
  388. printOn: aStream
  389. super printOn: aStream.
  390. aStream
  391. nextPutAll: '(';
  392. nextPutAll: self receiver;
  393. nextPutAll: ' >> ';
  394. nextPutAll: self selector;
  395. nextPutAll: ')'
  396. ! !
  397. Object subclass: #MethodContext
  398. instanceVariableNames: ''
  399. package: 'Kernel-Methods'!
  400. !MethodContext commentStamp!
  401. 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.
  402. My instances are JavaScript `SmalltalkMethodContext` objects defined in `boot.js`.!
  403. !MethodContext methodsFor: 'accessing'!
  404. home
  405. <return self.homeContext>
  406. !
  407. locals
  408. <return self.locals || {}>
  409. !
  410. method
  411. ^ self methodContext ifNotNil: [
  412. self methodContext receiver class lookupSelector: self methodContext selector ]
  413. !
  414. methodContext
  415. self isBlockContext ifFalse: [ ^ self ].
  416. ^ self home ifNotNil: [ :home |
  417. home methodContext ]
  418. !
  419. outerContext
  420. <return self.outerContext || self.homeContext>
  421. !
  422. pc
  423. <return self.pc>
  424. !
  425. receiver
  426. <return self.receiver>
  427. !
  428. selector
  429. <
  430. if(self.selector) {
  431. return smalltalk.convertSelector(self.selector);
  432. } else {
  433. return nil;
  434. }
  435. >
  436. !
  437. temps
  438. self deprecatedAPI.
  439. ^ self locals
  440. ! !
  441. !MethodContext methodsFor: 'converting'!
  442. asString
  443. ^self isBlockContext
  444. ifTrue: [ 'a block (in ', self methodContext asString, ')' ]
  445. ifFalse: [ self receiver class name, ' >> ', self selector ]
  446. ! !
  447. !MethodContext methodsFor: 'printing'!
  448. printOn: aStream
  449. super printOn: aStream.
  450. aStream
  451. nextPutAll: '(';
  452. nextPutAll: self asString;
  453. nextPutAll: ')'
  454. ! !
  455. !MethodContext methodsFor: 'testing'!
  456. isBlockContext
  457. "Block context do not have selectors."
  458. ^ self selector isNil
  459. ! !
  460. Object subclass: #NativeFunction
  461. instanceVariableNames: ''
  462. package: 'Kernel-Methods'!
  463. !NativeFunction commentStamp!
  464. I am a wrapper around native functions, such as `WebSocket`.
  465. For 'normal' functions (whose constructor is the JavaScript `Function` object), use `BlockClosure`.
  466. ## API
  467. See the class-side `instance creation` methods for instance creation.
  468. Created instances will most probably be instance of `JSObjectProxy`.
  469. ## Usage example:
  470. | ws |
  471. ws := NativeFunction constructor: 'WebSocket' value: 'ws://localhost'.
  472. ws at: 'onopen' put: [ ws send: 'hey there from Amber' ]!
  473. !NativeFunction class methodsFor: 'instance creation'!
  474. constructor: aString
  475. <
  476. var native=eval(aString);
  477. return new native();
  478. >
  479. !
  480. constructor: aString value:anObject
  481. <
  482. var native=eval(aString);
  483. return new native(anObject);
  484. >
  485. !
  486. constructor: aString value:anObject value: anObject2
  487. <
  488. var native=eval(aString);
  489. return new native(anObject,anObject2);
  490. >
  491. !
  492. constructor: aString value:anObject value: anObject2 value:anObject3
  493. <
  494. var native=eval(aString);
  495. return new native(anObject,anObject2, anObject3);
  496. >
  497. ! !
  498. !NativeFunction class methodsFor: 'testing'!
  499. exists: aString
  500. ^PlatformInterface existsGlobal: aString
  501. ! !
  502. Object subclass: #Timeout
  503. instanceVariableNames: 'rawTimeout'
  504. package: 'Kernel-Methods'!
  505. !Timeout commentStamp!
  506. I am wrapping the returns from `set{Timeout,Interval}`.
  507. ## Motivation
  508. Number suffices in browsers, but node.js returns an object.!
  509. !Timeout methodsFor: 'accessing'!
  510. rawTimeout: anObject
  511. rawTimeout := anObject
  512. ! !
  513. !Timeout methodsFor: 'timeout/interval'!
  514. clearInterval
  515. <
  516. var interval = self["@rawTimeout"];
  517. clearInterval(interval);
  518. >
  519. !
  520. clearTimeout
  521. <
  522. var timeout = self["@rawTimeout"];
  523. clearTimeout(timeout);
  524. >
  525. ! !
  526. !Timeout class methodsFor: 'instance creation'!
  527. on: anObject
  528. ^self new rawTimeout: anObject; yourself
  529. ! !