package icode_base
import metamodel
-import mmloader
## UTILITY CLASSES ##
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 ArraySet[IEscapeMark]
+ 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]
# 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 associated sequence
readable var _iescape_mark: IEscapeMark
# 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
+ # 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)
# 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
# - 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])
# No receivers, returns a new object of type 't'
# Will allocate memory and ensure dynamic type and object identity
class IAllocateInstance
-special ICode0
+ super ICode0
# The type to allocate
readable var _stype: MMType
init(t: MMType)
# A static call to a specific method
class IStaticCall
-special IAbsCall
+ super IAbsCall
init(p: MMMethod, a: Sequence[IRegister]) do super
end
# A validation of a newly constructed instance
class ICheckInstance
-special ICode1
+ super ICode1
# The type to allocate
readable var _stype: MMType
init(t: MMType, e: IRegister)
# Initialisation of default attributes of a new instance
class IInitAttributes
-special ICode1
+ super ICode1
# The type to initialize
readable var _stype: MMType
init(t: MMType, e: IRegister)
# A closure call
# exprs are the arguments
class IClosCall
-special ICodeN
+ super ICodeN
# The called closure
readable var _closure_decl: IClosureDecl
# Native are associated to local properties to distinguish them
# expr are the arguments
class INative
-special ICodeN
+ super ICodeN
# The associated local property
readable var _method: MMMethod
init(m: MMMethod, e: nullable Sequence[IRegister])
do
- super(e)
+ # Checks that arguments contains at least one IRegister element
+ assert e.length == m.signature.arity + 1
+
+ super(e)
_method = m
end
# A literal Int value
class IIntValue
-special ICode0
+ super ICode0
# The value
readable var _value: String
# A literal Bool value
class IBoolValue
-special ICode0
+ super ICode0
# The value
readable var _value: Bool
# A literal NativeString value
class IStringValue
-special ICode0
+ super ICode0
# The value
readable var _value: String
# A literal Float value
class IFloatValue
-special ICode0
+ super ICode0
# The value
readable var _value: String
# A literal Char value
class ICharValue
-special ICode0
+ super ICode0
# The value
readable var _value: String
# 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
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
# 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