1 / 29

Smalltalk in a .NET World

Smalltalk in a .NET World. How to write a Smalltalk compiler without writing a VM John Brant brant@refactory.com. #Smalltalk. Open source Smalltalk compiler Complete Source Available Self hosting Compiles Smalltalk directly to .NET executables and libraries. Building Smalltalk.

bradley-albert
Télécharger la présentation

Smalltalk in a .NET World

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Smalltalk in a .NET World How to write a Smalltalk compiler without writing a VM John Brant brant@refactory.com

  2. #Smalltalk • Open source Smalltalk compiler • Complete Source Available • Self hosting • Compiles Smalltalk directly to .NET executables and libraries

  3. Building Smalltalk • Virtual Machine • .NET Virtual Machine • Compiler • RB parser • Class Library • ANSI Standard • Development tools (debuggers, browsers, etc.)

  4. What’s .NET Anyway? • Common class library (collections, GUI, sockets, database, etc.) • Common virtual machine and byte code instruction set • Language isn’t supposed to matter

  5. Why .NET?(business reasons) • Backed by Microsoft • Lots of existing code • Allow Smalltalk to be used for applications that “require .NET”

  6. Why .NET?(personal reasons) • Build a Smalltalk compiler • Make an experimental platform • Learn .NET • Unemployed

  7. Smalltalk vs. .NET

  8. Smalltalk vs. .NET II

  9. Dynamic Typing • Root super type • Understands every message • Sends #doesNotUnderstand: printString ^self doesNotUnderstand: (Message selector: #printString arguments: #()) printString | stream | stream := WriteStream with: String new. self printOn: stream. ^stream contents

  10. method: aBoolean | temp one | aBoolean ifTrue: [temp := 5]. one := 1. ^temp + one temp := nil. null vs. nil • Special object for nil • Class constructor initializes variables to nil • Method temporaries initialized to nil only if they could be read before written

  11. 2r00001011 2r00000010 SmallIntegers • No support for tagged integers • Real integer objects • 10x slower than tagged integers VW Tagged #Smalltalk

  12. Blocks • Create class for each block • Create object from block class at runtime method ^#(1) collect: (Method-Block new) MonadicBlock subclass: Method-Block instanceVariableNames: ‘’ … value: each ^each + 1 method ^#(1) collect: [:each | each + 1]

  13. method arg block block temp arg temp temp value Block Variables • Variable references • Copied values (method/block arguments) • Active variables (temporaries) arg method: arg | block temp | block := [temp + arg]. temp := 5. ^block value 5

  14. method1 self method2: [^1] method2: aBlock #(2) do: [:each | aBlock value. ^each] method1[ ] method2[ ] do: method2 method1 Block Returns • Simulate using .NET exceptions • 100x slower • Tag object (integer)

  15. Primitives • Some actions aren’t representable (e.g., identityHash, +, etc.) • Primitive tag • Only one per method • Compiler primitive: [] • Used anywhere in method • User can add new primitives • Block code evaluated at compile time

  16. Primitive Example identityHash ^Compiler primitive: [:codeGenerator | codeGenerator call: (System.Object getMethod: 'GetHashCode'); constructNewObject: codeGenerator smalltalk smallIntegerClass initializedConstructor] evaluate: self

  17. Optimized Messages • Certain messages aren’t sent (e.g., ifTrue:, whileTrue:, to:do:) • Can hard code in compiler • Instead use macros and “Compiler primitive: []” syntax

  18. Macros • RB’s rewrite rules • ``@node ifTrue: ``@block Compiler primitive: [:codeGen :block | …] evaluate: ``@node uses: ``@block • Allows arbitrary optimizations (e.g., ifNil:  isNil ifTrue:) • Copy source interval for debugger

  19. Connecting with .NET • Over 2500 classes provided • Seamless integration | algorithm stream | algorithm := HashAlgorithm create: ‘MD5’. stream := FileStream read: ‘rb.im’. [algorithm computeHash: stream] ensure: [stream close]

  20. Connecting Smalltalk to .NET • Class references (Convert or System.Convert) • Typed Variables (System.Int32) • Generic ObjectWrapper • Messages for field, property, and method access • Constructors – #new* messages

  21. Method arguments • First keyword for method name/rest can be anything • Arguments converted to .NET objects • is-a tests for arguments • Overloaded methods left-to-right, specific-to-generic • System.Console::Write(int/char/…/object)

  22. Console Example System.Console write: anObject (anObject isKindOf: SmallInteger) ifTrue: [System.Console write: anObject integer] ifFalse: [(anObject isKindOf: Character) ifTrue: [System.Console write: anObject character] ifFalse: [(anObject isKindOf: String) ifTrue: [System.Console write: anObject string] ifFalse: [System.Console write: anObject]]]

  23. Connecting .NET to Smalltalk • Events use add_EventName: / remove_EventName: methods • Delegates (#asDelegate:) Button new add_Click: ([:obj :args | …] asDelegate: EventHandler) • Exported Properties/Methods (specified by annotations) • Interfaces & subclasses (to do)

  24. #Smalltalk Development (Version 1) • Proof of concept • VisualWorks program • Compiled generated text file with ilasm (.NET’s assembler) • Not seamless

  25. #Smalltalk Development (Version 2) • Read .SIF files • VisualWorks DLL connection to .NET • Override qualified name lookup in VW to use .NET DLL • System.Int32 Parse: ‘1234’ • System.Reflection.Emit generate .exe file directly

  26. #Smalltalk Development (Version 3) • Code based on Version 2 • Self hosting • Complete .exe compiler • Compile three times (fixed point) • Old code compiling new code • New code compiling new code • Verify new code compiled new code valid

  27. Benchmarks

  28. Future work • IDE (GUI builders, Browsers, etc.) • Add Subclassing/Interfaces • Optimizations • Reusing intermediate numerical values (e.g., i + j + k) • Type inferencing – eliminating SmallIntegers (e.g., 1 to: 10 do: [:i | ]) • Write programs

  29. Contact Information • #Smalltalk • http://www.refactory.com/Software/SharpSmalltalk/ • VisualWorks .NET DLL • http://www.rileywhite.com/software/assemblyconnect.html • .NET • http://www.microsoft.com/net/ • http://www.go-mono.com/

More Related