Kernel-Methods.st 14 KB

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