Starting files for testing

Author: jasonprogrammer

.gitignore

@@ -0,0 +1,2 @@
+bin/*
+!bin/nim*.py

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug Nim Project",
+            "type": "gdb",
+            "request": "launch",
+            "target": "main",
+            "cwd": "${workspaceRoot}",
+            "valuesFormatting": "parseText"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,16 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build Nim Project",
+            "type": "shell",
+            "command": "nim c -d:debug --debugger:native main.nim",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

bin/nim.py

@@ -0,0 +1,290 @@
+
+import gdb
+import re
+
+#################################################################################################
+#####  Type pretty printers
+#################################################################################################
+
+class NimTypePrinter(gdb.types.TypePrinter):
+  "Nim type printer, one printer for all Nim types"
+
+  type_hash_regex = re.compile("^(.+?)_([A-Za-z0-9]+)$")
+
+  type_map_static = {
+    'NI': 'int',  'NI8': 'int8', 'NI16': 'int16',  'NI32': 'int32',  'NI64': 'in64',
+    'NU': 'uint', 'NU8': 'uint8','NU16': 'uint16', 'NU32': 'uint32', 'NU64': 'uint64',
+    'NF': 'float', 'NF32': 'float32', 'NF32': 'float64',
+    'NIM_BOOL': 'bool', 'NIM_CHAR': 'char', 'NCSTRING': 'cstring',
+    'NimStringDesc': 'string'
+  }
+  
+  def __init__ (self):
+    super (NimTypePrinter, self).__init__ ("NimTypePrinter")
+
+  @staticmethod
+  def rti(type_name):
+    "Get static const TNimType variable, should be available for every non trivial Nim type"
+
+    m = NimTypePrinter.type_hash_regex.match(type_name)
+    if m is not None:
+      try:
+        return gdb.parse_and_eval("NTI_" + m.group(2) + "_")
+      except:
+       return None
+
+  def instantiate(self): 
+    return self._recognizer()
+
+  class _recognizer(object):
+
+    def recognize(self, type_obj):
+
+      tname = ""
+      if type_obj.tag is not None:
+        tname = type_obj.tag 
+      elif type_obj.name is not None:
+        tname = type_obj.name
+      else:
+        return None
+
+      result = NimTypePrinter.type_map_static.get(tname, None)
+      if result is not None:
+        return result
+
+      rti = NimTypePrinter.rti(tname)
+      if rti is not None: 
+        return str(rti['name'])
+
+      return None
+
+nimobjfile = gdb.current_objfile() or gdb.objfiles()[0]
+nimobjfile.type_printers = []
+nimobjfile.type_printers = [NimTypePrinter()]
+
+
+#################################################################################################
+#####  GDB Function, equivalent of Nim's $ operator
+#################################################################################################
+
+class DollarPrintFunction (gdb.Function):
+  "Nim's equivalent of $ operator as a gdb function, available in expressions `print $dollar(myvalue)"
+  
+  _gdb_dollar_functions = gdb.execute("info functions dollar__", True, True)
+  dollar_functions = re.findall('NimStringDesc \*(dollar__[A-z0-9_]+?)\(([^,)]*)\);', _gdb_dollar_functions)
+
+  def __init__ (self):
+    super (DollarPrintFunction, self).__init__("dollar")
+
+  @staticmethod
+  def invoke_static(arg):
+
+    for func, arg_typ in DollarPrintFunction.dollar_functions:
+      	
+      if arg.type.name == arg_typ:
+        func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
+        return func_value(arg)
+ 
+      if arg.type.name + " *" == arg_typ:
+        func_value = gdb.lookup_global_symbol(func, gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
+        return func_value(arg.address)
+
+    raise ValueError("No suitable Nim $ operator found for type: " + arg.type.name)
+
+  def invoke(self, arg):
+    return self.invoke_static(arg)
+
+DollarPrintFunction()
+
+
+#################################################################################################
+#####  GDB Command, equivalent of Nim's $ operator
+#################################################################################################
+
+class DollarPrintCmd (gdb.Command):
+  """Dollar print command for Nim, `$ expr` will invoke Nim's $ operator"""
+
+  def __init__ (self):
+    super (DollarPrintCmd, self).__init__ ("$", gdb.COMMAND_DATA, gdb.COMPLETE_EXPRESSION)
+
+  def invoke (self, arg, from_tty):
+    param = gdb.parse_and_eval(arg)
+    gdb.write(str(DollarPrintFunction.invoke_static(param)) + "\n", gdb.STDOUT)
+    
+DollarPrintCmd()
+
+
+#################################################################################################
+#####  Value pretty printers
+#################################################################################################
+
+class NimBoolPrinter:
+
+  pattern = re.compile(r'^NIM_BOOL$')
+
+  def __init__(self, val):
+    self.val = val
+
+  def display_hint(self):
+    return 'bool'
+
+  def to_string(self):
+    if self.val == 0:
+      return "false"
+    else:
+      return "true"
+
+################################################################
+
+class NimStringPrinter:
+
+  pattern = re.compile(r'^NimStringDesc \*$')
+
+  def __init__(self, val):
+    self.val = val
+
+  def display_hint(self):
+    return 'string'
+
+  def to_string(self):
+    if self.val:
+      l = int(self.val['Sup']['len'])
+      return self.val['data'][0].address.string("utf-8", "ignore", l)
+    else:
+      return "<nil>"
+
+
+################################################################
+
+class NimEnumPrinter:
+
+  pattern = re.compile(r'^tyEnum_(.+?)_([A-Za-z0-9]+)$')
+
+  reprEnum = gdb.lookup_global_symbol("reprEnum", gdb.SYMBOL_FUNCTIONS_DOMAIN).value()
+
+  def __init__(self, val):
+    self.val = val
+    if self.reprEnum is None:
+      raise ValueError("reprEnum function symbol is not found, can't display Nim enum. reprEnum was likely removed by dead code elimination")
+
+  def display_hint(self):
+    return 'enum'
+
+  def to_string(self):
+    try:
+      m = self.pattern.match(str(self.val.type))
+      nti =  gdb.parse_and_eval("NTI_" + m.group(2) + "_").address
+      return self.reprEnum(self.val, nti)
+    except Exception as e:
+      gdb.write("reprEnum exception: " + str(e) + "\n", gdb.STDERR)
+
+
+################################################################
+
+class NimSetPrinter:
+
+  pattern = re.compile(r'^tySet_(.+?)_([A-Za-z0-9]+)$')
+
+  def __init__(self, val):
+    self.val = val
+
+  def to_string(self):
+    try:
+      return DollarPrintFunction.invoke_static(self.val)
+    except:
+      gdb.write("RTI information not found for set, likely removed by dead code elimination: " + str(self.val.type) + "\n", gdb.STDERR)
+
+
+################################################################
+
+class NimSeqPrinter:
+
+  pattern = re.compile(r'^tySequence_.*$')
+
+  def __init__(self, val):
+    self.val = val
+
+  def display_hint(self):
+    return 'array'
+
+  def to_string(self):
+    return 'seq'
+
+  def children(self):
+    if not self.val:
+      yield ("seq", "<nil>")
+      raise StopIteration
+
+    len = int(self.val['Sup']['len'])
+    for i in range(len):
+      yield ('[{0}]'.format(i), self.val["data"][i])
+
+################################################################
+
+class NimObjectPrinter:
+
+  pattern = re.compile(r'^tyObject_.*$')
+
+  def __init__(self, val):
+    self.val = val
+
+  def display_hint(self):
+    return 'object'
+
+  def to_string(self):
+    return str(self.val.type)
+
+  def children(self):
+    if not self.val:
+      yield "object", "<nil>"
+      raise StopIteration
+
+    for (i, field) in enumerate(self.val.type.fields()):
+      if field.type.code == gdb.TYPE_CODE_UNION:              		
+        yield _union_field
+      else:
+        yield (field.name, self.val[field])
+
+  def _union_field(self, i, field):
+    rti = NimTypePrinter.rti(self.val.type.name)
+    if rti is None: 
+      return (field.name, "UNION field can't be displayed without RTI")
+
+    node_sons = rti['node'].dereference()['sons']
+    prev_field = self.val.type.fields()[i - 1]  
+
+    descriminant_node = None
+    for i in range(int(node['len'])):
+      son = node_sons[i].dereference()
+      if son['name'].string("utf-8", "ignore") == str(prev_field.name):
+        descriminant_node = son
+        break
+    if descriminant_node is None: 
+      raise ValueError("Can't find union descriminant field in object RTI")
+
+    if descriminant_node is None: raise ValueError("Can't find union field in object RTI")
+    union_node = descriminant_node['sons'][int(self.val[prev_field])].dereference()
+    union_val = self.val[field]
+
+    for f1 in union_val.type.fields():      
+      for f2 in union_val[f1].type.fields():
+        if str(f2.name) == union_node['name'].string("utf-8", "ignore"):
+           return (str(f2.name), union_val[f1][f2])
+ 
+    raise ValueError("RTI is absent or incomplete, can't find union definition in RTI")
+
+
+################################################################
+
+def makematcher(klass):
+  def matcher(val):
+    try:
+      if klass.pattern.match(str(val.type)):
+        return klass(val)
+    except Exception, e:
+        print("Nim matcher exception: ", str(e))
+  return matcher
+
+nimobjfile.pretty_printers = []
+nimobjfile.pretty_printers.extend([makematcher(var) for var in vars().values() if hasattr(var, 'pattern')])
+