end
end
+# A mark used to associate IEscapes to ISeqs
+class IEscapeMark
+end
+
# A Closure declaration
class IClosureDecl
# The associated closure definition
readable writable var _closure_decls: nullable Sequence[IClosureDecl] = null
# The local variables (excluding params and result)
- readable var _registers: Set[IRegister] = new ArraySet[IRegister]
+ 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
# A closure definition in a iroutine body
class IClosureDef
-special IRoutine
+ super IRoutine
init(p: Array[IRegister], r: nullable IRegister)
do
super(p, r)
# 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
# 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 root of all method invocations
abstract class IAbsCall
-special ICodeN
+ super ICodeN
# The called method
readable var _property: MMMethod
# 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 IAbsCall
+ super IAbsCall
# The type to instantiate
readable var _stype: MMType
init(t: MMType, p: MMMethod, a: Sequence[IRegister])
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
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 Sequence[IRegister])
+ init(m: MMMethod, e: nullable Sequence[IRegister])
do
super(e)
- _code = c
+ _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)
# An attribute read access
# expr is the reciever
class IAttrRead
-special ICode1
+ super ICode1
# The accessed attribute
readable var _property: MMAttribute
# 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
# A type check
# expr is the expression checked
class ITypeCheck
-special ICode1
+ super ICode1
# The static type checkes to
readable var _stype: MMType
# The 'is' operator
# expr1 and expr2 are both operands
class IIs
-special ICode2
+ super ICode2
init(e1, e2: IRegister)
do
super
# The unary 'not' operation
# expr is the operand
class INot
-special ICode1
+ super ICode1
init(e: IRegister)
do
super
# 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
nitlanguage / nit.git / blobdiff