Cpp Metaprogramming

wiki

Below we express in Lua a definition of a C++ class and a C++ module (compilation unit) containing that class.

require "cppmeta" :import()



-- Define class.

Rectangle =

  Class     "Rectangle"

  :include  "public <string>"

  :include  "<sstream>"

  :include  "<iostream>"

  :property "double width = 0.0"

  :property "double height = 0.0"

  :func[[

    /* Get the surface area of the rectangle. */

    double get_area() const {

      return get_width() * get_height();

    }

  ]]

  :func[[

    /* Resize rectangle by scale factor. */

    void scale(double amount = 0) {

      set_width(get_width() * amount);

      set_height(get_height() * amount);

    }

  ]]

  :func[[

    /* Convert rectangle to string. */

    std::string tostring() {

      ostringstream os;

      os << "Rectangle[" << get_width() << "," << get_height() << "]";

      return os.str();

    }

  ]]



-- Define module (compilation unit).

Rectanglem = 

  Module   "rectanglem"

  :include "<iostream>"

  :using_namespace"std"

  :class(Rectangle)

  :func[[

    /* entry point */

    int main() {

      Rectangle s;

      s.set_width(10);

      s.set_height(20);

      s.scale(2);

      cout << s.tostring() << " " << s.get_area() << " " << s.get_class_name() << endl;

      return 0;

    }

  ]]



-- Insert into any class a member function returning class name.

-- This is a helper function, achieving aspect oriented programming somewhat.

function name_class(class)

  local ccode = cppmeta.subst([[

    /* Return name of class as string. */

    std::string get_class_name() { return "%(name)"; }

  ]], {name = class.name})

  class:func(ccode):include("public <string>")

  return c

end

name_class(Rectangle) -- add other functions to class.



Rectanglem:write() -- generate source files for C++ compiler.



-- Just for fun, print out a list of method names and descriptions too.

for _,v in ipairs(Rectangle.funcs) do

  print(v.name, v.comment)

end

We seek to have that automatically generate these two files in standard C++:

rectanglem.h

#ifndef MODULE_rectanglem

#define MODULE_rectanglem

#include <string>



class Rectangle {

public:

  Rectangle::Rectangle();

  explicit Rectangle::Rectangle(const Rectangle & other);

  Rectangle & operator=(const Rectangle & other);

  double get_width() const { return width; }

  void set_width(double _) { width = _; }

  double get_height() const { return height; }

  void set_height(double _) { height = _; }

  double get_area() const;

  void scale(double amount = 0);

  std::string tostring();

  std::string get_class_name();



private:

  double width;

  double height;



};



#endif // first include

rectanglem.cpp

#include "rectanglem.h"

#include <sstream>

#include <iostream>



using namespace std;



Rectangle::Rectangle() : width(0.0), height(0.0)

{

}

Rectangle::Rectangle(const Rectangle & other) : width(other.width), height(other.height)

{

}

  Rectangle &

Rectangle::operator=(const Rectangle & other) {

  width = other.width;

  height = other.height;



}

  double

Rectangle::get_area() const {

  return get_width() * get_height();

}

  void

Rectangle::scale(double amount) {

  set_width(get_width() * amount);

  set_height(get_height() * amount);

}

  std::string

Rectangle::tostring() {

  ostringstream os;

  os << "Rectangle[" << get_width() << "," << get_height() << "]";

  return os.str();

}

  std::string

Rectangle::get_class_name() { return "Rectangle"; }







  int

main() {

  Rectangle s;

  s.set_width(10);

  s.set_height(20);

  s.scale(2);

  cout << s.tostring() << " " << s.get_area() << " " << s.get_class_name() << endl;

  return 0;

}

The "cppmeta.lua" module is implemented at the bottom of this page.

Warning: This code is a rough draft. The code currently does not handle the corner cases or even most cases. However, I believe the approach case reasonably be made robust. It mostly avoids the difficulties of fully parsing C++. The code is known to run on Lua 5.1.

See also LuaProxyDll for a related C metaprogramming example.

--DavidManura

-- cppmeta.lua

-- (c) David Manura, 2007-02.

-- Licensed under the same terms as Lua itself.



module("cppmeta", package.seeall)



function import()

  local env = getfenv(2)

  for k,v in pairs(cppmeta) do env[k] = v end

  return cppmeta

end



-- remove leading indents from string

local function unindent(s)

  local spacer = string.match(s, "( *)}%s*$")

  local t = {}

  string.gsub(s, "[^\n]+", function(s) t[#t+1] = s; return "" end)

  for i = 1,#t do

     t[i] = string.gsub(t[i], "^" .. spacer, "")

  end

  s = table.concat(t, "\n")

  return s

end



-- substitute variables in string

function subst(s, vars)

  for k,v in pairs(vars) do

    s = string.gsub(s, "%%%(" .. k .. "%)", v)

  end

  return s

end



-- remove whitespace at beginning and end of string

local function trim(s)

  s = string.gsub(s, "^%s+", "")

  s = string.gsub(s, "%s+$", "")

  return s

end



-- extracts leading C comment (if any) from string.

local function remove_comment(ccode)

  local comment

  ccode = string.gsub(ccode, "^%s*/%*(.-)%*/%s*",

                      function(s) comment = s; return "" end)

  return ccode, comment

end



-- format function definition

local function format_funcdef(func, parent)

  -- Remove default assignments from arguments

  local args = func.args

  args = string.gsub(args, "%s*=[^,)]+", "")



  local body = func.body

  if string.sub(body, 1, 1) == "{" then body = " " .. body end



  local mods = (func.mods == "") and "" or " " .. func.mods 



  local prefix = parent and (parent .. "::") or ""



  local cfunc = "  " .. func.type .. "\n"

              .. prefix .. func.name .. "(" .. args .. ")" .. mods

              .. body .. "\n"



  return cfunc  

end



-- parse function from C++ string.

local function parse_func(ccode)

  local comment

  ccode, comment = remove_comment(ccode)

  ccode = unindent(ccode)

  local type, name, args, mods, body

    = string.match(ccode, "^%s*([^(]+)%s+([%w_]+)%s*%((.*)%)%s*([^{]-)%s*({.*})")

  assert(type, ccode)

  --print("F", type,";",name, ";",args, ";",body)

  local func = {name = name, args = args, type = type, mods = mods,

                body = body, comment = comment}

  return func

end



-- parse property from C++ string

local function parse_property(ccode)

  ccode = trim(ccode)

  local type, name, default

    = string.match(ccode, "^%s*(.+)%s+([%w_]+)%s*=%s*(.-)%s*$")

  --print('P', type, ';', name, ';', default)

  assert(type, ccode)

  local prop = {name = name, type = type, default = default}

  return prop

end



-- parse "include" from C++ string

local function parse_include(ccode)

  ccode = trim(ccode)

  local ccode2 = string.gsub(ccode, "^%s*public%s+", "")

  local visibility = (ccode2 ~= ccode) and "public" or "private"

  local include = {ccode2, visibility = visibility}

  return include

end



Class = {}

Class.__index = Class

setmetatable(Class, {__call = function(self, ...) return Class.new(...) end})

-- Construct class.

function Class.new(name)

  return setmetatable({

    name = name,

    properties = {},

    funcs = {},

    includes = {}

  }, Class)

end

-- Use property in class.

function Class:property(ccode)

  local prop = parse_property(ccode)

  table.insert(self.properties, prop)

  return self

end

-- Use (member) function in class.

function Class:func(ccode)

  local func = parse_func(ccode)

  table.insert(self.funcs, func)

  return self

end

-- Use include in class.

function Class:include(ccode)

  local include = parse_include(ccode)

  table.insert(self.includes, include)

  return self

end

-- Return string of C++ code for class declaration.

function Class:declaration()

  local cfields = ""

  for _,prop in ipairs(self.properties) do

    local cfield = "  %type %name;\n"

    cfield = string.gsub(cfield, "%%type", prop.type)

    cfield = string.gsub(cfield, "%%name", prop.name)

    cfields = cfields .. cfield

  end



  local cpubs = ""

  for _,prop in ipairs(self.properties) do

    local cfield =

        "  %type get_%name() const { return %name; }\n" ..

        "  void set_%name(%type _) { %name = _; }\n"

    cfield = string.gsub(cfield, "%%type", prop.type)

    cfield = string.gsub(cfield, "%%name", prop.name)

    cpubs = cpubs .. cfield

  end



  for _,func in ipairs(self.funcs) do

    local mods = (func.mods == "") and "" or " " .. func.mods

    local cfunc = "  " .. func.type .. " " .. func.name .. "(" .. func.args .. ")" .. mods .. ";\n"

    cpubs  = cpubs .. cfunc

  end



  local c = subst([[

class %(name) {

public:

  %(name)::%(name)();

  explicit %(name)::%(name)(const %(name) & other);

  %(name) & operator=(const %(name) & other);

%(cpubs)

private:

%(cfields)

};

]], {name = self.name, cpubs = cpubs, cfields = cfields})

  return c

end

-- Return string of C++ code for class implementation.

function Class:implementation()

  local cinit = ""

  if #self.properties > 0 then

    for _,prop in ipairs(self.properties) do

      cinit = cinit .. ", " .. prop.name .. "(" .. prop.default .. ")"

    end

    cinit = ":" .. string.sub(cinit, 2)

  end



  local cinit3 = ""

  if #self.properties > 0 then

    for _,prop in ipairs(self.properties) do

      cinit3 = cinit3 .. ", " .. prop.name .. "(other." .. prop.name .. ")"

    end

    cinit3 = ":" .. string.sub(cinit3, 2)

  end



  local cassigninit = ""

  if #self.properties > 0 then

    for _,prop in ipairs(self.properties) do

      cassigninit = cassigninit .. "  " .. prop.name .. " = other." .. prop.name .. ";\n"

    end

  end



  local cfuncs = ""

  for _,func in ipairs(self.funcs) do

    local cfunc = format_funcdef(func, self.name)

    cfuncs  = cfuncs .. cfunc

  end



  local c = subst([[

%(name)::%(name)() %(cinit)

{

}

%(name)::%(name)(const %(name) & other) %(cinit3)

{

}

  %(name) &

%(name)::operator=(const %(name) & other) {

%(cassigninit)

}

%(cfuncs)

]], {cinit3 = cinit3, cassigninit = cassigninit, cinit = cinit,

     name = self.name, cfuncs = cfuncs})

  return c

end



Module = {}

Module.__index = Module

setmetatable(Module, {__call = function(self, ...) return Module.new(...) end})

-- Construct module.

function Module.new(name)

  return setmetatable({

    name = name,

    includes = {},

    using_namespaces = {},

    classes = {},

    funcs = {}

  }, Module)

end

-- Use include in module.

function Module:include(ccode)

  local include = parse_include(ccode)

  table.insert(self.includes, include)

  return self

end

-- Use namespace in module.

function Module:using_namespace(name)

  name = trim(name)

  table.insert(self.using_namespaces, name)

  return self

end

-- Define class in module.

function Module:class(o)

  table.insert(self.classes, o)

  return self

end

-- Define function in module.

function Module:func(ccode)

  local func = parse_func(ccode)

  table.insert(self.funcs, func)

  return self

end

-- Return srting of C++ code for module header.

function Module:header()

  local cincludes = ""

  local includes = {}

  for _,v in ipairs(includes) do includes[#includes+1] = v end

  for _,class in ipairs(self.classes) do

    for _,v in ipairs(class.includes) do includes[#includes+1] = v end

  end

  local found = {}

  for _,v in ipairs(includes) do

    if v.visibility == "public" and not found[v[1]] then

      cincludes = cincludes .. "#include " .. v[1] .. "\n"

      found[v[1]] = true

    end

  end



  local cclassdecs = ""

  for _,class in ipairs(self.classes) do

    cclassdecs = cclassdecs .. class:declaration()

  end



  local c = subst([[

#ifndef MODULE_%(name)

#define MODULE_%(name)

%(cincludes)

%(cclassdecs)

#endif // first include

]], {name = self.name, cincludes = cincludes, cclassdecs = cclassdecs})

  return c

end

-- Return string of C++ code for module implementation.

function Module:implementation()

  local cincludes = ""

  local found = {}

  for _,class in ipairs(self.classes) do

    local includes = class.includes

    for _,v in ipairs(includes) do

      if v.visibility == "private" and not found[v[1]] then

        cincludes = cincludes .. "#include " .. v[1] .. "\n"

        found[v[1]] = true

      end

    end

  end



  local cusings = ""

  for _,ns in ipairs(self.using_namespaces) do

    cusings = cusings .. "using namespace " .. ns .. ";\n";

  end



  local cdefs = ""

  for _,class in ipairs(self.classes) do

    cdefs = cdefs .. class:implementation() .. "\n"

  end



  local cfuncs = ""

  for _,func in ipairs(self.funcs) do

    local cfunc = format_funcdef(func)

    cfuncs  = cfuncs .. cfunc

  end



  local c = subst([[

#include "%(name).h"

%(cincludes)

%(cusings)

%(cdefs)

%(cfuncdefs)

]], {name = self.name, cdefs = cdefs, cincludes = cincludes,

     cfuncdefs = cfuncs, cusings = cusings})



  return c

end

-- Write module sources to files.

function Module:write()

  local fh = assert(io.open(self.name .. ".h", "w"))

  fh:write(self:header())

  fh:close()

  local fh = assert(io.open(self.name .. ".cpp", "w"))

  fh:write(self:implementation())

  fh:close()

end