contrib/pep8analysis/src/model/vars.nit

   1 module vars
   2
   3 import ast
   4
   5 import operands
   6
   7 class Var
   8 end
   9
  10 class RegisterVar
  11         super Var
  12
  13         init (register: Char) do self.register = register
  14
  15         var register: Char
  16
  17         redef fun to_s do return "r{register}"
  18
  19         redef fun ==(o) do return o isa RegisterVar and register == o.register
  20         redef fun hash do return 128 + register.hash
  21 end
  22
  23 class StackVar
  24         super Var
  25
  26         init (offset: Int) do self.offset = offset
  27
  28         var offset: Int
  29
  30         redef fun ==(o) do return o isa StackVar and offset == o.offset
  31         redef fun hash do return 512 + offset.hash
  32 end
  33
  34 class MemVar
  35         super Var
  36
  37         init (index: Int) do self.index = index
  38
  39         var index: Int
  40
  41         # need Object::AnalysisManager
  42         #redef fun to_s is abstract
  43
  44         redef fun ==(o) do return o isa MemVar and index == o.index
  45         redef fun hash do return 1024 + index.hash
  46 end
  47
  48 redef class AInstruction
  49         fun def_var: nullable Var is abstract
  50         fun src_var: nullable Var is abstract
  51 end
  52
  53 redef class ABinaryInstruction
  54         fun mem_var: nullable Var do return n_operand.to_var
  55 end
  56
  57 redef class ALoadInstruction
  58         redef fun def_var do return new RegisterVar(register)
  59         redef fun src_var do return n_operand.to_var
  60 end
  61
  62 redef class AStoreInstruction
  63         redef fun def_var do return n_operand.to_var
  64         redef fun src_var do return new RegisterVar(register)
  65 end
  66
  67 redef class AInputInstruction
  68         redef fun def_var do return n_operand.to_var
  69 end
  70
  71 redef class ARegisterSuffixed
  72         fun reg_var: Var do return new RegisterVar(register)
  73 end
  74
  75 redef class AArithmeticInstruction
  76 end
  77
  78 redef class AOperand
  79         fun to_var: nullable Var is abstract
  80 end
  81
  82 redef class AImmediateOperand
  83         redef fun to_var do return null
  84 end
  85
  86 redef class AAnyOperand
  87         fun addressing_mode: String do return n_id.text
  88         redef fun to_var
  89         do
  90                 if addressing_mode == "i" then
  91                 else if addressing_mode == "d" then
  92                         return new MemVar(n_value.to_i)
  93                 else if addressing_mode == "n" then
  94                 else if addressing_mode == "s" then
  95                         return new StackVar(n_value.to_i)
  96                 else if addressing_mode == "sf" then
  97                 else if addressing_mode == "x" then
  98                 else if addressing_mode == "sx" then
  99                 else if addressing_mode == "sxf" then
 100                 end
 101
 102                 return null
 103         end
 104 end
 105