Talk from IWST at ESUG19, Cologne, Germany

1. Illicium
Compiling Pharo to C
1Pierre Misse-Chanabier
Vincent Aranega
Guillermo Polito
Stéphane Ducasse

2. Pharo development
2

3. Code compilation
3

4. Slang
4

5. Slang: Basis
5
anOperator
^ 1 + 2
int anOperator(void)
{
return 1 + 2;
}

6. Slang: Control flow
6
int anIf(void)
{
if(true){
1 + 2;
}
return 0;
}
anIf
true ifTrue:[ 1 + 2 ]

7. Slang: a Macro
7
aMacro
^ 1 between: 2 and: 3
int aMacro(void)
{
return ((1>=2) && (1<=3));
}

8. Slang: an Unknown Message
8
anUnknownMessage
^ 1 even
int anUnknowMessage(void)
{
return even(1);
}

9. Slang: an Unknown Message
9
anUnknownMessage
^ 1 class
int anUnknowMessage(void)
{
return class(1);
}

10. Slang: a Weird Message
10
aWeirdMessage
^ self
between: 1 and: false
int aWeirdMessage(void)
{
return ((self>=1)
&& (self<=0));
}

11. Slang: assign a value to a class variable
11
assignToClassVariable
aClassVariable := 5
#define aClassVariable null
void assignToClassVariable(void)
{
aClassVariable = 5;
}

12. Slang: Code generation
12
generateModulo: msgNode on: aStream indent: level
"Generate the C code for this message onto the given
stream."
self emitCExpression: msgNode receiver on: aStream.
aStream nextPutAll: ' % '.
self emitCExpression: msgNode args first on: aStream

13. 1. No intermediary representation
2. Modularity
3. Blurry language boundaries
Problems
13

14. 14

15. My solution: Illicium
15

16. What’s an AST? A Visitor?
5 modulo: 3
16

17. ● Described by a meta model
● Code generation
○ Class, attributes, accessors [...]
○ Visitors
○ Consistency
Intermediary representation: AST C
17

18. Modularity: Node Translators
18

19. Modularity: Method Translator, a composition
19

20. Modularity: Method Translator visit
20
MethodTranslator >> visitLiteralValueNode: aLiteralValueNode
^ (translators at: #literalValueNodeTranslator)
translateNode: aLiteralValueNode
withMethodTranslator: self

21. Modularity: LiteralNodeTranslator
21
LiteralNodeTranslator >>
TranslateNode: aLiteralNode withMethodTranslator: aTranslator
^ ASTCLiteral new
value: aLiteralNode value

22. Modularity: OverflowSafeLiteralNodeTranslator
OverflowSafeLiteralNodeTranslator >> TranslateNode: aLiteralNode
aLiteralNode value > 255
ifTrue:[ self error: ‘not going to fit in a byte’ ].
^ ASTCLiteral new
value: aLiteralNode value
22

23. Modularity: IntegerOnlyLiteralNodeTranslator
IntegerOnlyLiteralNodeTranslator >>
TranslateNode: aLiteralNode withMethodTranslator: aTranslator
aLiteralNode isInteger
ifFalse:[ self error: ‘Integers are the only real literals!’ ].
^ ASTCLiteral new
value: aLiteralNode value
23

24. Modularity: Configurable Method Translator
24

25. Boundaries: Translation of a MessageNode
25

26. Boundaries: Translation Classes
26

27. Boundaries: MessageNodeTranslator
27
MessageNodeTranslator >>
translateNode: aMessageNode withMethodTranslator: aTranslator
| newReceiver |
newReceiver := TranslationSmallInteger new
value: aMessageNode receiver;
methodTranslator: aTranslator.
ˆ newReceiver perform: aMessageNode selector
withArguments: aMessageNode arguments

28. Boundaries: Regular vs Translation classes
28
modulo: aNumber
^ self - (self // aNumber * aNumber)
modulo: aNumber
^ ASTCModuloOperator new
leftOperand: (self value acceptVisitor: visitor);
rightOperand: (aNumber acceptVisitor: visitor);
yourself.

29. Boundaries: Translation process
29

30. Solution
30
● Better language delimitation
○ Type dependent
○ Browsable
○ Extensible
● Two modularity point
○ Node specialized translator
○ Translation classes

31. Conclusion
● Slang
● (IR) Metamodel approach
● (Modularity) Small, replaceable translators
● (Boundaries) Message translation based on type
● (Modularity + Boundaries) Translation classes
31
Pierre Misse-Chanabier
pierre.misse-chanabier@inria.fr
Hogoww on discord/Github

32. 32

33. 33

34. 34

35. 35