1. The document discusses compiling Pharo code to C using a technique called Illicium. Illicium uses an intermediate representation (IR) based on an abstract syntax tree (AST) metamodel to represent Pharo code. 2. Illicium provides modularity through small, replaceable node translators that each handle translating a specific node type to the IR. Larger method translators are composed of these node translators. 3. Illicium handles boundaries between Pharo and C by translating messages to method calls based on the receiver type. Regular Pharo classes are translated differently than special translation classes used during code generation.

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