package icode_base
import metamodel
-import mmloader
## UTILITY CLASSES ##
end
end
+# A mark used to associate IEscapes to ISeqs
+class IEscapeMark
+end
+
# A Closure declaration
class IClosureDecl
# The associated closure definition
# A routine is a sequence of icodes with entry iregisters (params) and an exit iregister (result)
class IRoutine
# The parameters of the routine
- readable var _params: IndexedCollection[IRegister]
+ readable var _params: Sequence[IRegister]
# The closure declared
- readable writable var _closure_decls: nullable IndexedCollection[IClosureDecl] = null
+ readable writable var _closure_decls: nullable Sequence[IClosureDecl] = null
+
+ # The local variables (excluding params and result)
+ readable var _registers: Set[IRegister] = new HashSet[IRegister]
# The result of the routine
readable var _result: nullable IRegister
+ # The local escapes marks of the routine
+ readable var _escape_marks: Set[IEscapeMark] = new HashSet[IEscapeMark]
+
# The sequence of icode
readable var _body: ISeq = new ISeq
# The location of the iroutine (if any)
readable writable var _location: nullable Location = null
- init(p: IndexedCollection[IRegister], r: nullable IRegister)
+ init(p: Sequence[IRegister], r: nullable IRegister)
do
_params = p.to_a
_result = r
# A closure definition in a iroutine body
class IClosureDef
-special IRoutine
+ super IRoutine
init(p: Array[IRegister], r: nullable IRegister)
do
super(p, r)
# The location of the icode (if any)
readable writable var _location: nullable Location = null
+
+ # Is the icode side effect free?
+ fun is_pure: Bool do return false
end
# An icode that uses no registers (no args)
abstract class ICode0
-special ICode
+ super ICode
redef fun arity do return 0
end
# An icode that uses a single register (1 arg)
abstract class ICode1
-special ICode
+ super ICode
redef fun arity do return 1
# The single argument
# An icode that uses two single registers (2 args)
abstract class ICode2
-special ICode
+ super ICode
redef fun arity do return 2
# The first argument
# An icode that uses a variable number of registers (n args) and a variable number of closure definitions
abstract class ICodeN
-special ICode
+ super ICode
redef fun arity do return _exprs.length
# All arguments
- readable var _exprs: IndexedCollection[IRegister]
+ readable var _exprs: Sequence[IRegister]
# All closure definition
- readable writable var _closure_defs: nullable IndexedCollection[nullable IClosureDef]
+ readable writable var _closure_defs: nullable Sequence[nullable IClosureDef]
- init(e: nullable IndexedCollection[IRegister])
+ init(e: nullable Sequence[IRegister])
do
if e == null then
_exprs = new Array[IRegister]
# A linear sequence of ICode
class ISeq
-special ICode0
+ super ICode0
# The sequence of icode
readable var _icodes: List[ICode] = new List[ICode]
+
+ # The associated iescape_mark (if any)
+ readable writable var _iescape_mark: nullable IEscapeMark
+
init do end
end
# An infinite loop of ICode
# Use IEscape to exit
class ILoop
-special ISeq
+ super ISeq
init do end
end
# A Condidianal if-then-else statement
# expr is the condition
class IIf
-special ICode1
+ super ICode1
# The 'then' sequence of icode
readable var _then_seq: ISeq = new ISeq
# The 'else' sequence of icode
# Escape to to end of a parent sequence
class IEscape
-special ICode0
+ super ICode0
# The seqeuence to escape
- # The control flow continues at the next icode after the sequence
- readable var _seq: ISeq
- init(seq: ISeq) do _seq = seq
+ # The control flow continues at the next icode after the associated sequence
+ readable var _iescape_mark: IEscapeMark
+ init(mark: IEscapeMark) do _iescape_mark = mark
end
# An abort statement
class IAbort
-special ICode0
+ super ICode0
# The reason the abort occured
# tests.first is the format
readable var _texts: Array[String]
- # The local property that has the abort (if any)
- readable var _property_location: nullable MMLocalProperty
# The module that has the abort
readable var _module_location: MMModule
- init(t: Array[String], pl: nullable MMLocalProperty, ml: MMModule)
+ init(t: Array[String], ml: MMModule)
do
_texts = t
- _property_location = pl
_module_location = ml
end
end
# The root of all method invocations
abstract class IAbsCall
-special ICodeN
+ super ICodeN
# The called method
readable var _property: MMMethod
- init(p: MMMethod, e: IndexedCollection[IRegister])
+ # if this call is to be made from native code
+ var is_explicit_from_extern : Bool writable = false
+
+ init(p: MMMethod, e: Sequence[IRegister])
do
super(e)
_property = p
# A simple procedure or function call
# exprs.first is the reciever, other are arguments
class ICall
-special IAbsCall
+ super IAbsCall
init(p, e) do super
end
# A super method call
# exprs.first is the reciever, other are arguments
class ISuper
-special IAbsCall
+ super IAbsCall
init(p, e) do super
end
# An instantiation
# no reciever, all exprs are arguments
+# Will call in order:
+# - IAllocateInstance
+# - IInitAttributes
+# - IStaticCall -> target Initializer
+# - ICheckInstance
class INew
-special ICall
+ super IAbsCall
# The type to instantiate
readable var _stype: MMType
- init(t: MMType, p: MMMethod, a: IndexedCollection[IRegister])
+ init(t: MMType, p: MMMethod, a: Sequence[IRegister])
do
super(p, a)
_stype = t
end
end
+# An allocation of a new object
+# No receivers, returns a new object of type 't'
+# Will allocate memory and ensure dynamic type and object identity
+class IAllocateInstance
+ super ICode0
+ # The type to allocate
+ readable var _stype: MMType
+ init(t: MMType)
+ do
+ _stype = t
+ end
+end
+
+# A static call to a specific method
+class IStaticCall
+ super IAbsCall
+ init(p: MMMethod, a: Sequence[IRegister]) do super
+end
+
+# A validation of a newly constructed instance
+class ICheckInstance
+ super ICode1
+ # The type to allocate
+ readable var _stype: MMType
+ init(t: MMType, e: IRegister)
+ do
+ super(e)
+ _stype = t
+ end
+end
+
+# Initialisation of default attributes of a new instance
+class IInitAttributes
+ super ICode1
+ # The type to initialize
+ readable var _stype: MMType
+ init(t: MMType, e: IRegister)
+ do
+ super(e)
+ _stype = t
+ end
+end
+
# A closure call
# exprs are the arguments
class IClosCall
-special ICodeN
+ super ICodeN
# The called closure
readable var _closure_decl: IClosureDecl
# The !break sequence (if any)
readable writable var _break_seq: nullable ISeq = null
- init(c: IClosureDecl, e: IndexedCollection[IRegister])
+ init(c: IClosureDecl, e: Sequence[IRegister])
do
super(e)
_closure_decl = c
end
end
-# A native C code
-# Mainly used to implements things that do not have a specific ICode yet
+# A native inlined call
+# Native are associated to local properties to distinguish them
# expr are the arguments
class INative
-special ICodeN
- # The native C code
- # Special character sequence '@@@' will be substitued in order with the arguments
- readable var _code: String
+ super ICodeN
+ # The associated local property
+ readable var _method: MMMethod
- init(c: String, e: nullable IndexedCollection[IRegister])
+ init(m: MMMethod, e: nullable Sequence[IRegister])
do
- super(e)
- _code = c
+ # Checks that arguments contains at least one IRegister element
+ assert e.length == m.signature.arity + 1
+
+ super(e)
+ _method = m
end
+
+ redef readable writable var _is_pure: Bool = false
+end
+
+# A literal Int value
+class IIntValue
+ super ICode0
+ # The value
+ readable var _value: String
+
+ init(v: String) do _value = v
+
+ redef fun is_pure do return true
+end
+
+# A literal Bool value
+class IBoolValue
+ super ICode0
+ # The value
+ readable var _value: Bool
+
+ init(v: Bool) do _value = v
+
+ redef fun is_pure do return true
+end
+
+# A literal NativeString value
+class IStringValue
+ super ICode0
+ # The value
+ readable var _value: String
+
+ init(v: String) do _value = v
+
+ redef fun is_pure do return true
+end
+
+# A literal Float value
+class IFloatValue
+ super ICode0
+ # The value
+ readable var _value: String
+
+ init(v: String) do _value = v
+
+ redef fun is_pure do return true
+end
+
+# A literal Char value
+class ICharValue
+ super ICode0
+ # The value
+ readable var _value: String
+
+ init(v: String) do _value = v
+
+ redef fun is_pure do return true
end
# A register assigment
# expr is the assigned value
# result is the register assigned
class IMove
-special ICode1
+ super ICode1
init(r: IRegister, e: IRegister)
do
super(e)
_result = r
end
+
+ redef fun is_pure do return true
end
# An attribute read access
# expr is the reciever
class IAttrRead
-special ICode1
+ super ICode1
# The accessed attribute
readable var _property: MMAttribute
super(r)
_property = p
end
+
+ redef fun is_pure do return true
end
# An attribute assignment
# expr1 is the receiver, expr2 is the assigned value
class IAttrWrite
-special ICode2
+ super ICode2
# The accessed attribute
readable var _property: MMAttribute
# An attribute is_set check
# expr is the reciever
class IAttrIsset
-special ICode1
+ super ICode1
# The accessed attribute
readable var _property: MMAttribute
super(r)
_property = p
end
+
+ redef fun is_pure do return true
end
# A type check
-# expr is the expression checked
+# expr1 is the type reciever (self)
+# expr2 is the expression checked
class ITypeCheck
-special ICode1
+ super ICode2
# The static type checkes to
readable var _stype: MMType
- init(e: IRegister, t: MMType)
+ init(e1, e2: IRegister, t: MMType)
do
- super(e)
+ super(e1, e2)
_stype = t
end
+
+ redef fun is_pure do return true
end
# The 'is' operator
# expr1 and expr2 are both operands
class IIs
-special ICode2
+ super ICode2
init(e1, e2: IRegister)
do
super
end
+
+ redef fun is_pure do return true
end
# The unary 'not' operation
# expr is the operand
class INot
-special ICode1
+ super ICode1
init(e: IRegister)
do
super
end
+
+ redef fun is_pure do return true
end
# Evaluate body once them return the same value again and again
# if result is not null, then it must also be assigned in the body
class IOnce
-special ICode0
+ super ICode0
readable var _body: ISeq = new ISeq
init do end
end
# Is a closure given as a parameter?
class IHasClos
-special ICode0
+ super ICode0
# The called closure
readable var _closure_decl: IClosureDecl
do
_closure_decl = c
end
+
+ redef fun is_pure do return true
end
#################################################