rlang 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45f6d0c347cfcf901dcd935e2b979098759f2c9b435ff5d900f77a830d5b2101
-  data.tar.gz: 88c0e8f7b79f3cb784f0dd0c85fc10b68427958893f3401998f9866fa9a9b50a
+  metadata.gz: a7fd26f4ab304200f0319e23e1e8529e538ea058a58fe4571e0e3525c2c5ce14
+  data.tar.gz: 88bb4ec22b5a2571944693da8ea21d0e1379fb41b3c9ae85d91851a2f8569d9b
 SHA512:
-  metadata.gz: d6f959bc61a5f4f9548455244662a8b3d9482d9e4670fdb66fd9d5ea1101e062bb93d5fbaffabac5e24852c85058130f92680e76f7d01bbe1745914bee25640b
-  data.tar.gz: 30e4ecce3b01f850fd9515ab614e75d3cd915545b172bab7174872d0d5fab4875a96ade32dac2f1b7a95a3ca0f58ef0ef891544b926ba0e6c23fa38c4cb6fca2
+  metadata.gz: f6c92dcfec61a4df573d2c911882f346fb242315596220e25aa547998f137b8578f18ca62467c77af2b75e92ea73d87a21cbc37eae1bd56e89038bc62fca2264
+  data.tar.gz: b9e09724905b3175904258174c834b8d52b9f7ae99c7046e81e13f97e699d94b53f110b70763283992e71c7d6a2f3d0eb9d9cba60a30a1ef319338f1ec580919

data/CHANGELOG.md

@@ -1,6 +1,9 @@
-## 0.4.1
+## 0.5.0
 * Class attributes syntac now identical to plain Ruby
 * Very preliminary version of Rlang String class
+* Class in class definition and module supported
+* Class inheritance
+* Basic array class
 
 ## 0.4.0
 * Object instances, instance methods and instance variables now supported

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rlang (0.4.0)
+    rlang (0.5.0)
       parser
 
 GEM

data/README.md

@@ -1,12 +1,19 @@
-# Rlang : a (subset of) Ruby to WebAssembly compiler
+# Rlang : a native Ruby to WebAssembly compiler
 
 Rlang is meant to generate fast and uncluttered [WebAssembly](https://webassembly.org) code from the comfort of the Ruby language.
 
-Rlang is actually two things: 1) a supported subset of the Ruby language and 2) a **compiler** transforming this Ruby subset in a valid, fully runnable and native WebAssembly module.
+Rlang is actually two things: 1) a subset of the Ruby language and 2) a **compiler** transforming this Ruby subset in a native, fully runnable WebAssembly module.
+
+So in summary what Rlang does is:
+<p align="center"><b>
+Ruby source code &rarr; Rlang compiler &rarr; WebAssembly bytecode
+</b></p>
+
+Rlang must not be confused with other projects claiming to "compile" Ruby to WebAssembly. What they really do is to actually compile a mruby VM written in C in Webassembly (using tools like emscripten) and then run that VM in a Webassembly runtime.
 
 Rlang can be seen as a foundational language that can help you quickly develop and debug high performance WebAssembly modules. For the rationale behind the creation of Rlang see [below](#why-rlang).
 
-This is still a young project but Rlang has already been successfully tested with some real code such as the dynamic memory allocator provided with the Rlang library. It will keep mproving over time, always with the goal of generating crisp and uncluttered WAT code.
+This is still a young project but Rlang has already been successfully tested with some real code such as the dynamic memory allocator provided with the Rlang library. It will keep mproving over time, always with the goal of generating crisp and uncluttered WebAssembly code.
 
 If you want to help with Rlang see [How you can help](#how-you-can-help).
 
@@ -22,7 +29,7 @@ Rlang is available as a gem from rubygems.org. So simply run the following comma
 ```
 $ gem install rlang
 ```
-Alternatively, if you clone this git repo and play with the Rlang source code you can generate your own local gem and install it like this:
+Alternatively, if you clone this git repo and play with the Rlang source code you can generate your own local gem and install it as follows:
 
 ```
 $ bundle install
@@ -33,7 +40,7 @@ $ gem install --local rlang-x.y.z.gem
 To check that the installation went well, run `rlang --help` and see if the help message displays correctly.
 
 ## A Quick example
-An example is always worth a thousand words, so here is a quick one that'll show you how to compile some Rang code and run it from your browser. Since Chrome, Chromium, Firefox and Safari all natively embed a WebAssembly runtime it is the easiest way to test compiled Rlang code.
+An example is always worth a thousand words, so here is a quick one showing you how to compile some Rang code and run it from your browser. Since Chrome, Chromium, Firefox and Safari embed a WebAssembly runtime it is the easiest way to test your compiled Rlang code.
 
 Navigate to the Fibonacci directory in [examples/fib](https://github.com/ljulliar/rlang/blob/master/examples/fib/) and download the three files from this directory: fib.rb, index.html, server.rb. Alternatively you can git clone the repo and go directly in that directory.
 
@@ -50,15 +57,14 @@ Point your browser to [http://localhost:8080](http://localhost:8080), a simple p
 
 That was easy, right ?
 
-
 ## The Rlang language
 Ruby features supported by Rlang are detailed in the [Rlang Manual](https://github.com/ljulliar/rlang/blob/master/docs/RlangManual.md)
 
 You can look at the rlang test suite in [test/rlang_test_files](https://github.com/ljulliar/rlang/blob/master/test/rlang_test_files/) to get a flavor of the subset of Ruby currently supported.
 
-For a more involved example of Ruby code, I invite you to look at the [dynamic memory allocator](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.rb) provided with the Rlang library.
+For a more involved example of Rlang code, I invite you to look at the [dynamic memory allocator](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.rb) provided with the Rlang library.
 
-## rlang compiler
+## The rlang compiler
 The Rlang compiler can be invoked through the `rlang` command. See the [Rlang Compiler Documentation](https://github.com/ljulliar/rlang/blob/master/docs/RlangCompiler.md) for more details about the command line options.
 
 Keep in mind that Rlang is **NOT** a Ruby interpreter or a Ruby VM executing some kind of bytecode. It does actually statically **compile** the Rlang language to WebAssembly code pretty much like gcc or llvm compiles C/C++ code to machine assembly language.
@@ -70,7 +76,7 @@ One of the big benefits of Rlang being a subset of the Ruby language is that you
 ## Why Rlang?
 This project was created out of the need to develop a Virtual Machine written in WebAssembly capable of interpreting the [Rubinius](https://github.com/rubinius/rubinius) bytecode. And yes, ultimately run a native Ruby VM in a browser :-)
 
-After a first proof of concept written directly by hand in WebAssembly (WAT code) it became clear that writing a full fledged VM directly in WebAssembly was going to be tedious, complex and unnecessarily painful.
+After a first proof of concept written directly by hand in WebAssembly (WAT source code) it became clear that writing a full fledged VM directly in WebAssembly was going to be tedious, complex and unnecessarily painful.
 
 Sure I could have written this VM in any of the language that can already be compiled directly to WebAssembly (C, C++, Rust, Go,...) but being fond of Ruby since 2000 I decided that I would go for a compiler capable of transforming a subset of the Ruby language directly into WebAssembly with a minimum overhead. So in a nutshell: the goal of Rlang is to let you develop efficient WebAssembly code with a reasonably high level of abstraction while keeping the generated WebAssembly code straightforward and human readable.
 

data/docs/RlangManual.md

@@ -14,6 +14,7 @@ In Rlang you can define classes and those classes can be instantiated either sta
 
 Rlang provides:
 * Classes, class attributes and class variables
+* Modules
 * Object instantiation, attribute accessors and instance variables
 * Method definition and method calls
 * Integers and booleans 
@@ -46,8 +47,6 @@ calling that method later in your code is as simple as invoking `Math.fib(20)`
 ## Classes
 Classes are core constructs of Rlang and are very similar to Ruby classes.
 
-In Rlang, all methods must be defined within the scope of a class. In other words you can not define a method at the top level of your Rlang code (not a very good practice anyway, even in plain Ruby). Also there is no inheritance mechanism in Rlang in the current version.
-
 Here is an example of a class definition and the initialization and use of a class variable written in Rlang (note: this example uses only class methods on purpose. Instance methods are covered later in this document):
 
 ```ruby
@@ -70,6 +69,22 @@ This short piece of code shows several interesting points:
 1. Methods in this example are class methods, hence the use of `self.take_one` and `self.refill` in method definitions but instance methods are also supported (more on this later)
 1. In `MyClass::take_one` you can see that Rlang also supports convenient syntactic sugar like `if` as a modifier or combined operation and assignment as in Ruby (here the `-=` operator)
 
+### Class scope and inheritance
+Rlang supports the definition of classes in class at any depth and class naming follows the exact same convention as in Ruby. In the example below the `B` class can be referred to as `A::B`. 
+
+```ruby
+class A
+  class B
+  end
+end
+
+def main
+  new_object = A::B.new
+end
+```
+A Class in RLang can also inherit from another class as in Ruby. Whan a superclass is not specified, a newly defined class automatically inherits from the Object class.
+
+
 ### Class attributes and instance variables
 Rlang support both the use of class attributes and instance variables. Class attribute declaration is happening through the `attr_accessor`, `attr_reader` or `attr_writer` directives as in plain Ruby. It actually defines a couple of things for you:
 
@@ -113,6 +128,8 @@ class Square
   end
 end
 ```
+## Modules
+Modules in Rlang behaves exactly like modules in Ruby. Modules can be included, extended or prepended in other classes and modules. .
 
 ## Object instantiation
 Starting with version 0.4.0, Rlang is equipped with a dynamic memory allocator (see [Rlang library](#the-rlang-library) section). It is therefore capable of allocating objects in a dynamic way at *runtime*. Prior versions were only capable of allocating objects statically at *compile* time.
@@ -131,7 +148,7 @@ class Test
 end
 ```
 
-**IMPORTANT NOTE**: in the current version of Rlang the new method call used to allocate the object sape doesn't do any initialization. That's why the new method in this context (class body or top level) doesn't accept any parameter
+**IMPORTANT NOTE**: in the current version of Rlang the new method call used to allocate static objects doesn't do any initialization. That's why the new method in this context (class body or top level) doesn't accept any parameter.
 
 ### Dynamic objects
 At any point in the body of method you can dynamically instantiate a new object. Here is an exemple:
@@ -171,6 +188,11 @@ end
 ## Methods
 Methods in Rlang are defined as you would normally do in Ruby by using the `def` reserved keyword. They can be either class or instance methods.
 
+### Method definition
+A method in Rlang can either be defined in a class, a module or at the top level. In that case the method is implicitely defined within the context of the Object class as Ruby does.
+
+Class methods must be defined using the `def self.mymethod` syntax. The `class << self ... end` form is not supported.
+
 ### Method arguments
 Rlang method definition supports fixed name arguments in any number. The  *args and **args notation are not supported.
 
@@ -251,7 +273,7 @@ The types currently supported by Rlang are integers either long (`:I32`) or doub
 Only in rare cases will you use the `local` directive in methods as Rlang does its best to infer the type of a variable from its first assigned value. As an example, in the code below, the fact that `arg1` is known to be an `:I64` type of argument is enough to auto-magically create lvar as in `:I64` local variable too.
 
 ```ruby
-def self.m_local_var(arg1)
+def m_local_var(arg1)
   arg :arg1, :I64
   lvar = arg1 * 100
   # ....

data/lib/rlang/lib/array/array32.rb

@@ -0,0 +1,43 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# 4 bytes object array class
+require_relative '../memory'
+require_relative '../kernel'
+require_relative '../object'
+require_relative '../string'
+
+
+class Array32
+  attr_reader :count, :ptr
+
+  # count: number of elements in Array
+  # Array elements are native types or
+  # pointers to objects
+  # Arrays are fixed size for now
+  def initialize(count)
+    @ptr = Object.allocate(count * 4)
+    @count = count
+  end
+
+  def size; @count; end
+  def length; @count; end
+
+  def [](idx)
+    result :I32
+    raise "Index out of bound" if idx >= @count
+    # offset in memory for elt #idx is idx * 4
+    Memory.load32(@ptr + (idx << 2))
+  end
+
+  def []=(idx, value)
+    arg value: :I32
+    result :I32
+    raise "Index out of bound" if idx >= @count
+    # offset in memory for elt #idx is idx * 4
+    Memory.store32(@ptr + (idx << 2), value)
+    value
+  end
+
+end

data/lib/rlang/lib/array/array64.rb

@@ -0,0 +1,43 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# 4 bytes object array class
+require_relative '../memory'
+require_relative '../kernel'
+require_relative '../object'
+require_relative '../string'
+
+
+class Array64
+  attr_reader :count, :ptr
+
+  # count: number of elements in Array
+  # Array elements are native types or
+  # pointers to objects
+  # Arrays are fixed size for now
+  def initialize(count)
+    @ptr = Object.allocate(count * 8)
+    @count = count
+  end
+
+  def size; @count; end
+  def length; @count; end
+
+  def [](idx)
+    result :I64
+    raise "Index out of bound" if idx >= @count
+    # offset in memory for elt #idx is idx * 8
+    Memory.load64(@ptr + (idx << 3))
+  end
+
+  def []=(idx, value)
+    arg value: :I64
+    result :I64
+    raise "Index out of bound" if idx >= @count
+    # offset in memory for elt #idx is idx * 8
+    Memory.store64(@ptr + (idx << 3), value)
+    value
+  end
+
+end

data/lib/rlang/lib/array.rb

@@ -0,0 +1,6 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+require_relative './array/array32'
+require_relative './array/array64'

data/lib/rlang/lib/kernel.rb

@@ -0,0 +1,18 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Kernel methods
+
+$! = 0.cast_to(:String)
+
+module Kernel
+
+  def raise(msg)
+    arg msg: :String
+    result :none
+    $! = msg
+    inline wat: '(unreachable)', wtype: :none
+  end
+
+end

data/lib/rlang/lib/malloc.rb

@@ -30,9 +30,10 @@ $NALLOC = 1024
 
 # Allocate some unused memory space to make 
 # sure so that freep doesn't point to memory
-# address 0 because it has a sepcial meaning
-# Allocate 20 bytes (5 x I32 integers)
-DAta[:dummy_malloc_data] = [0, 0, 0, 0, 0]
+# address 0 because it has a special meaning
+# Allocate 20 bytes (4 x I32 integers)
+DAta.align(4)
+DAta[:dummy_malloc_data] = [0, 0, 0, 0]
 
 class Header
   attr_accessor :ptr, :size
@@ -47,6 +48,7 @@ class Malloc
   # declare ahead of time because is used in
   # the code before it is actually defined
   result :Malloc, :free, :nil
+  result :Malloc, :morecore, :Header
 
 # -------- Dynamic Memory Allocator Functions -----------
 

data/lib/rlang/lib/memory.rb

@@ -1,4 +1,9 @@
-require 'rlang/lib/type'
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Web Assembly memory access methods
+#
 
 class Memory
 
@@ -25,5 +30,100 @@ class Memory
       idx += 1
     end
   end
-  
+
+  def self.load32_8(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load8_u (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load32_16(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load16_u (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load32(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load64_8(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load8_u (local.get $addr))',
+           wtype: :I64
+  end
+
+  def self.load64_16(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load16_u (local.get $addr))',
+           wtype: :I64
+  end
+  def self.load64_32(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load32_u (local.get $addr))',
+           wtype: :I64
+  end
+  def self.load64(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load (local.get $addr))',
+           wtype: :I64
+  end
+
+  def self.store32_8(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store8 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store32_16(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store16 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store32(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_8(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store8 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_16(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store16 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_32(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store32 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
 end

data/lib/rlang/lib/object.rb

@@ -1,10 +1,17 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Base Object class
+
 require_relative './malloc'
+require_relative './kernel'
 
 class Object
-  # don't use allocate as a name to avoid
-  # colliding with Ruby native method in 
-  # Rlang simulator
-  def self.alloc(nbytes)
+
+  include Kernel
+  
+  def self.allocate(nbytes)
     result :I32
     Malloc.malloc(nbytes)
   end

data/lib/rlang/lib/string.rb

@@ -1,4 +1,5 @@
 require_relative './malloc'
+require_relative './memory'
 
 class String
   attr_reader :length, :ptr

data/lib/rlang/lib/unistd.rb

@@ -8,6 +8,7 @@
 # srbk(0) returns the current value of the break
 # Note: in WASM we can only grow linear memory by pages (64 KB block)
 
+require_relative './memory'
 
 # These 3 global variables below are used by the
 # dynamic memory allocator. You can redefine them
@@ -27,8 +28,6 @@ $HEAP_MAX_SIZE = 1073741824  # 1GB
 $HEAP_SIZE = 0
 
 class Unistd
-  result :Memory, :grow, :I32
-  result :Memory, :size, :I32
 
   def self.sbrk(n)
     # local variables used. All default type

data/lib/rlang/lib.rb

@@ -3,9 +3,11 @@
 # All rights reserved.
 
 # Rlang standard library
-require_relative './lib/object'
 require_relative './lib/type'
 require_relative './lib/memory'
 require_relative './lib/unistd'
 require_relative './lib/malloc'
-require_relative './lib/string'
+require_relative './lib/object'
+require_relative './lib/kernel'
+require_relative './lib/string'
+require_relative './lib/array'

data/lib/rlang/parser/attr.rb

@@ -11,14 +11,14 @@ require_relative './wtype'
 module Rlang::Parser
   class Attr
     include Log
-    attr_reader :name, :getter, :setter, :ivar
+    attr_reader :name, :getter, :setter, :ivar, :klass
 
     # The name argument can either be the attribute name
     # (e.g. :size) or an ivar name (e.g. :@size)
-    def initialize(class_wnode, name, wtype=WType::DEFAULT)
-      @class_wnode = class_wnode
+    def initialize(klass, name, wtype=WType::DEFAULT)
+      @klass = klass
       @name = name
-      @ivar = class_wnode.create_ivar(:"@#{name}", wtype)
+      @ivar = klass.wnode.create_ivar(:"@#{name}", wtype)
       @getter = nil
       @setter = nil
       @export = false
@@ -26,16 +26,16 @@ module Rlang::Parser
     end
 
     def attr_reader
-      @getter = @class_wnode.find_or_create_method(self.getter_name, nil, wtype, :instance)
+      @getter = @klass.wnode.find_or_create_method(nil, self.getter_name, :instance, wtype)
       @getter.export! if @export
-      logger.debug "Getter created: #{@getter.inspect}"
+      logger.debug "Getter created: #{@getter}"
       @getter
     end
 
     def attr_writer
-      @setter = @class_wnode.find_or_create_method(self.setter_name, nil, wtype, :instance)
+      @setter = @klass.wnode.find_or_create_method(nil, self.setter_name, :instance, wtype)
       @setter.export! if @export
-      logger.debug "Setter created: #{@setter.inspect}"
+      logger.debug "Setter created: #{@setter}"
       @setter
     end
 
@@ -47,10 +47,6 @@ module Rlang::Parser
       @export = true
     end
 
-    def class_name
-      @class_wnode.class_name
-    end
-
     def wtype
       @ivar.wtype
     end
@@ -64,7 +60,7 @@ module Rlang::Parser
       @getter.wtype = wtype if @getter
       @setter.wtype = wtype if @setter
       @ivar.wtype = wtype
-      logger.debug "Attr/Getter/Setter/ivar wtype updated : #{@getter.inspect}"
+      logger.debug "Attr/Getter/Setter/ivar wtype updated : #{@getter}"
     end
 
     def getter_name

data/lib/rlang/parser/const.rb

@@ -10,6 +10,110 @@ require_relative './cvar'
 # Constants and Class variables are managed
 # in exactly the same way
 module Rlang::Parser
-  class Const < CVar
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Class variables
+# Note: Const class inherits from this class
+
+require_relative '../../utils/log'
+require_relative './wtype'
+require_relative './data'
+
+module Rlang::Parser
+  class Const
+    include Log
+    attr_reader :scope_class, :name, :value
+    attr_accessor :wtype
+
+    def initialize(name, value, wtype=WType::DEFAULT)
+      @scope_class = nil
+      @name  = name
+      @wtype = wtype
+      @data  = nil
+      self.value = value if value
+    end
+
+    # class or module in which constant is defined
+    # not to be confused with wtype that hold the Rlang
+    # class of the constant
+    def scope_class=(scope_class_or_mod)
+      logger.debug "Placing Constant #{name} in scope class #{scope_class_or_mod&.name}"
+      raise "Error: constant scope class already initialized with #{scope_class.name} / #{@scope_class}. Got #{scope_class_or_mod.name} / #{scope_class_or_mod}." \
+        if @scope_class
+      @scope_class = scope_class_or_mod
+      @scope_class.consts << self if @scope_class
+    end
+
+    # The value attribute can either be set at
+    # initialize time or later (e.g. for classes and modules)
+    def value=(value)
+      # TODO: as opposed to Ruby we don't handle constant
+      # reassignment for now.
+      raise "Constant #{self.name} already initialized with value #{@value}. Now getting #{value}" \
+        if @value
+      return nil unless value
+      logger.debug "Initializing constant #{@name} @ #{@address} with value #{@value} / wtype #{@wtype}"
+      if value.kind_of? Module
+         # for now just store 0 in constants
+         # pointing to class or module
+         # TODO: probably point to a minimal data 
+         # with the class path string for instance (= class name)
+        self.data = 0
+      else
+        self.data = value
+      end
+      @value = value
+    end
+
+    def data=(value)
+      @data = DAta.new(self.wasm_name.to_sym, value, @wtype)
+    end
+
+    # the symbol form of this constant path
+    # e.g. a constant A::B will return :"A::B"
+    def path_name
+      #@scope_class ? "#{@scope_class.path_name}::#{@name}".to_sym : @name
+      self.path.map(&:name).join('::').to_sym
+    end
+
+    # Returns an array of successive Const objects that
+    # altogether makes the full path of this Const
+    # e.g. a constant A::B will return [Const(:A), Const(:B)]
+    def path
+      sk = nil; c = self; p = [c]
+      while (sk = c.scope_class) && sk.const != c
+        logger.debug "c: #{c.name}/#{c}, sk: #{sk.name}/#{sk}"
+        c = sk.const
+        p.unshift(c)
+      end
+      # Do not keep Object as the first element of the
+      # const path unless it is the only element
+      p.shift if p.first.name == :Object && p.size > 1
+      logger.debug "Const#path : #{p.map(&:name)}"
+      p
+    end
+
+    def class?
+      @wtype.name == :Class
+    end
+
+    def module?
+      @wtype.name == :Module
+    end
+
+    def address
+      @data.address
+    end
+
+    def wasm_name
+      "$#{self.path_name}"
+    end
+
+    def wasm_type
+      @wtype.wasm_type
+    end
   end
 end
+end