{"id":1579,"date":"2018-06-11T13:51:16","date_gmt":"2018-06-11T13:51:16","guid":{"rendered":"http:\/\/dlang.org\/blog\/?p=1579"},"modified":"2021-10-08T11:03:55","modified_gmt":"2021-10-08T11:03:55","slug":"dasbetterc-converting-make-c-to-d","status":"publish","type":"post","link":"https:\/\/dlang.org\/blog\/2018\/06\/11\/dasbetterc-converting-make-c-to-d\/","title":{"rendered":"DasBetterC: Converting make.c to D"},"content":{"rendered":"

Walter Bright<\/a> is the BDFL of the D Programming Language and founder of Digital Mars<\/a>. He has decades of experience implementing compilers and interpreters for multiple languages, including Zortech C++, the first native C++ compiler. He also created Empire, the Wargame of the Century<\/a>. This post is the third in a series<\/a>\u00a0about\u00a0D\u2019s BetterC mode<\/a><\/em><\/p>\n

\n

\"\"D as BetterC (a.k.a. DasBetterC) is a way to upgrade existing C projects to D in an incremental manner. This article shows a step-by-step process of converting a non-trivial C project to D and deals with common issues that crop up.<\/p>\n

While the dmd D compiler front end<\/a> has already been converted to D, it\u2019s such a large project that it can be hard to see just what was involved. I needed to find a smaller, more modest project that can be easily understood in its entirety, yet is not a contrived example.<\/p>\n

The old make program I wrote for the Datalight C compiler<\/a> in the early 1980\u2019s came to mind. It\u2019s a real implementation of the classic make program that\u2019s been in constant use since the early 80\u2019s. It\u2019s written in pre-Standard C, has been ported from system to system, and is a remarkably compact 1961 lines of code, including comments. It is still in regular use today.<\/p>\n

Here\u2019s the make manual<\/a>, and the source code<\/a>. The executable size for make.exe is 49,692 bytes and the last modification date was Aug 19, 2012.<\/p>\n

The Evil Plan is:<\/p>\n

    \n
  1. Minimize diffs between the C and D versions. This is so that if the programs behave differently, it is far easier to figure out the source of the difference.<\/li>\n
  2. No attempt will be made to fix or improve the C code during translation. This is also in the service of (1).<\/li>\n
  3. No attempt will be made to refactor the code. Again, see (1).<\/li>\n
  4. Duplicate the behavior of the C program as exactly and as much as possible,
    \nbugs and all.<\/li>\n
  5. Do whatever is necessary as needed in the service of (4).<\/li>\n<\/ol>\n

    Once that is completed, only then is it time to fix, refactor, clean up, etc.<\/p>\n

    Spoiler Alert!<\/h2>\n

    The completed conversion<\/a>. The resulting executable is 52,252 bytes (quite comparable to the original 49,692). I haven\u2019t analyzed the increment in size, but it is likely due to instantiations of the NEWOBJ<\/code> template (a macro in the C version), and changes in the DMC runtime library since 2012.<\/p>\n

    Step By Step<\/h2>\n

    Here are the differences between the C and D versions<\/a>. It\u2019s 664 out of 1961 lines, about a third, which looks like a lot, but I hope to convince you that nearly all of it is trivial.<\/p>\n

    The #include files are replaced<\/code> by corresponding D imports, such as replacing #include <stdio.h><\/code> with import core.stdc.stdio;<\/code><\/a>. Unfortunately, some of the #include<\/code> files are specific to Digital Mars C, and D versions do not exist (I need to fix that). To not let that stop the project, I simply included the relevant declarations in lines 29 to 64<\/a>. (See the documentation for the import<\/code> declaration<\/a>.)<\/p>\n

    #if _WIN32<\/code> is replaced<\/a> with version (Windows)<\/code><\/a>. (See the documentation for the version condition<\/a> and predefined versions<\/a>.)<\/p>\n

    extern (C):<\/code><\/a> marks the remainder of the declarations in the file as compatible with C. (See the documentation for the linkage attribute<\/a>.)<\/p>\n

    A global search\/replace changes uses of the debug1, debug2 and debug3<\/a> macros to debug printf<\/a>. In general, #ifdef DEBUG<\/code> preprocessor directives<\/a> are replaced with debug<\/code> conditional compilation<\/a>. (See the documentation for the debug<\/code> statement<\/a>.)<\/p>\n

    \/* Delete these old C macro definitions...\r\n#ifdef DEBUG\r\n-#define debug1(a)       printf(a)\r\n-#define debug2(a,b)     printf(a,b)\r\n-#define debug3(a,b,c)   printf(a,b,c)\r\n-#else\r\n-#define debug1(a)\r\n-#define debug2(a,b)\r\n-#define debug3(a,b,c)\r\n-#endif\r\n*\/\r\n\r\n\/\/ And replace their usage with the debug statement\r\n\/\/ debug2(\"Returning x%lx\\n\",datetime);\r\ndebug printf(\"Returning x%lx\\n\",datetime);<\/pre>\n
    The TRUE<\/code>, FALSE<\/code><\/a> and NULL<\/code> macros are search\/replaced with true<\/code>, false<\/code>, and null<\/code>.<\/p>\n
    The ESC macro is replaced<\/code><\/a> by a manifest constant<\/a>. (See the documentation for manifest constants<\/a>.)<\/p>\n
    \/\/ #define ESC     '!'\r\nenum ESC =      '!';<\/pre>\n
    The NEWOBJ macro is replaced<\/code><\/a> with a template function<\/a>.<\/p>\n
    \/\/ #define NEWOBJ(type)    ((type *) mem_calloc(sizeof(type)))\r\ntype* NEWOBJ(type)() { return cast(type*) mem_calloc(type.sizeof); }<\/pre>\n
    The filenamecmp<\/code> macro is replaced<\/a> with a function<\/a>.<\/p>\n
    Support for obsolete platforms is removed<\/a>.<\/p>\n
    Global variables in D are placed by default into thread-local storage (TLS). But since make<\/code> is a single-threaded program, they can be inserted into global storage with the __gshared<\/code> storage class<\/a>. (See the documentation for the __gshared<\/code> attribute<\/a>.)<\/p>\n
    \/\/ int CMDLINELEN;\r\n__gshared int CMDLINELEN<\/pre>\n
    D doesn\u2019t have a separate struct tag name space, so the typedefs are not necessary. An
    \n    alias<\/code><\/a> can be used instead.\u00a0(See the documentation for alias<\/code> declarations<\/a>.) Also,\u00a0struct<\/code><\/a> is omitted from variable declarations.<\/p>\n
    \/*\r\ntypedef struct FILENODE\r\n        {       char            *name,genext[EXTMAX+1];\r\n                char            dblcln;\r\n                char            expanding;\r\n                time_t          time;\r\n                filelist        *dep;\r\n                struct RULE     *frule;\r\n                struct FILENODE *next;\r\n        } filenode;\r\n*\/\r\nstruct FILENODE\r\n{\r\n        char            *name;\r\n        char[EXTMAX1]  genext;\r\n        char            dblcln;\r\n        char            expanding;\r\n        time_t          time;\r\n        filelist        *dep;\r\n        RULE            *frule;\r\n        FILENODE        *next;\r\n}\r\n\r\nalias filenode = FILENODE;<\/pre>\n
    macro<\/code> is a keyword in D<\/a>, so we\u2019ll just use MACRO<\/code> instead.<\/p>\n
    Grouping together multiple pointer declarations<\/a> is not allowed in D, use this instead<\/a>:<\/p>\n
    \/\/ char *name,*text;\r\n\/\/ In D, the * is part of the type and \r\n\/\/ applies to each symbol in the declaration.\r\nchar* name, text;<\/pre>\n
    C array declarations<\/a> are transformed to D array declarations<\/a>. (See the documentation for D\u2019s declaration syntax<\/a>.)<\/p>\n
    \/\/ char            *name,genext[EXTMAX+1];\r\nchar            *name;\r\nchar[EXTMAX+1]  genext;<\/pre>\n
    static<\/code><\/a> has no meaning at module scope in D. static<\/code> globals in C are equivalent to private<\/code> module-scope variables in D, but that doesn\u2019t really matter when the module is never imported anywhere. They still need to be __gshared<\/code> and that can be applied to an entire block of declarations<\/a>. (See the documentation for the static<\/code> attribute<\/a>)<\/p>\n
    \/*\r\nstatic ignore_errors = FALSE;\r\nstatic execute = TRUE;\r\nstatic gag = FALSE;\r\nstatic touchem = FALSE;\r\nstatic debug = FALSE;\r\nstatic list_lines = FALSE;\r\nstatic usebuiltin = TRUE;\r\nstatic print = FALSE;\r\n...\r\n*\/\r\n\r\n__gshared\r\n{\r\n    bool ignore_errors = false;\r\n    bool execute = true;\r\n    bool gag = false;\r\n    bool touchem = false;\r\n    bool xdebug = false;\r\n    bool list_lines = false;\r\n    bool usebuiltin = true;\r\n    bool print = false;\r\n    ...\r\n}<\/pre>\n
    Forward reference declarations<\/a> for functions are not necessary in D. Functions defined in a module can be called at any point in the same module, before or after their definition.<\/p>\n
    Wildcard expansion<\/a> doesn\u2019t have much meaning to a make<\/code> program.<\/p>\n
    Function parameters declared with array syntax<\/a> are pointers in reality, and are declared as pointers in D.<\/p>\n
    \/\/ int cdecl main(int argc,char *argv[])\r\nint main(int argc,char** argv)<\/pre>\n
    mem_init()<\/code> expands to nothing<\/a> and we previously removed the macro.<\/p>\n
    C code can play fast and loose with arguments to functions<\/a>, D demands that function prototypes be respected.<\/p>\n
    void cmderr(const char* format, const char* arg) {...}\r\n\r\n\/\/ cmderr(\"can't expand response file\\n\");\r\ncmderr(\"can't expand response file\\n\", null);<\/pre>\n
    Global search\/replace\u00a0C’s arrow operator<\/a> (-><\/code>) with the dot operator (.<\/code>), as member access in D is uniform.<\/p>\n
    Replace conditional compilation directives<\/a> with D\u2019s version<\/code>.<\/p>\n
    \/*\r\n #if TERMCODE\r\n    ...\r\n #endif\r\n*\/\r\n    version (TERMCODE)\r\n    {\r\n        ...\r\n    }<\/pre>\n
    The lack of function prototypes<\/a> shows the age of this code. D requires proper prototypes.<\/p>\n
    \/\/ doswitch(p)\r\n\/\/ char *p;\r\nvoid doswitch(char* p)<\/pre>\n
    debug<\/code> is a D keyword<\/a>. Rename it to xdebug<\/code>.<\/p>\n
    The \\n\\<\/code> line endings<\/a> for C multiline string literals are not necessary in D.<\/p>\n
    Comment out unused code<\/a> using D\u2019s \/+ +\/<\/code>\u00a0nesting block comments. (See the documentation for line, block and nesting block comments<\/a>.)<\/p>\n
    static if<\/code> can replace<\/a>\u00a0many uses of #if<\/code>. (See the documentation for the static if<\/code> condition<\/a>.)<\/p>\n
    Decay of arrays to pointers<\/a> is not automatic in D, use .ptr<\/code>.<\/p>\n
    \/\/ utime(name,timep);\r\nutime(name,timep.ptr);<\/pre>\n
    Use const<\/code> for C-style strings<\/a> derived from string literals in D, because D won\u2019t allow taking mutable pointers to string literals. (See the documentation for const<\/code> and immutable<\/code><\/a>.)<\/p>\n
    \/\/ linelist **readmakefile(char *makefile,linelist **rl)\r\nlinelist **readmakefile(const char *makefile,linelist **rl)<\/pre>\n
    void*<\/code> cannot be implicitly cast to char*<\/code><\/a>. Make it explicit.<\/p>\n
    \/\/ buf = mem_realloc(buf,bufmax);\r\nbuf = cast(char*)mem_realloc(buf,bufmax);<\/pre>\n
    Replace unsigned<\/code> with uint<\/code><\/a>.<\/p>\n
    inout<\/code> can be used to transfer<\/a> the \u201cconst-ness\u201d of a function from its argument to its return value. If the parameter is const<\/code>, so will be the return value. If the parameter is not const<\/code>, neither will be the return value. (See the documentation for inout<\/code> functions<\/a>.)<\/p>\n
    \/\/ char *skipspace(p) {...}\r\ninout(char) *skipspace(inout(char)* p) {...}<\/pre>\n
    arraysize<\/code> can be replaced<\/a> with the .length<\/code> property of arrays. (See the documentation for array properties<\/a>.)<\/p>\n
    \/\/ useCOMMAND  |= inarray(p,builtin,arraysize(builtin));\r\nuseCOMMAND  |= inarray(p,builtin.ptr,builtin.length)<\/pre>\n
    String literals are immutable, so it is necessary to replace mutable ones with a stack allocated array<\/a>. (See the documentation for string literals<\/a>.)<\/p>\n
    \/\/ static char envname[] = \"@_CMDLINE\";\r\nchar[10] envname = \"@_CMDLINE\";<\/pre>\n
    .sizeof<\/code> replaces C\u2019s sizeof()<\/code><\/a>. (See the documentation for the .sizeof<\/code> property<\/a>).<\/p>\n
    \/\/ q = (char *) mem_calloc(sizeof(envname) + len);\r\nq = cast(char *) mem_calloc(envname.sizeof + len);<\/pre>\n
    Don\u2019t care about old versions of Windows<\/a>.<\/p>\n
    Replace ancient C usage of char *<\/code> with void*<\/code>.<\/a><\/p>\n
    And that wraps up the changes! See, not so bad. I didn\u2019t set a timer, but I doubt this took more than an hour, including debugging a couple errors I made in the process.<\/p>\n
    This leaves the file man.c<\/a>, which is used to open the browser on the make manual page<\/a> when the -man<\/code> switch is given. Fortunately, this was already ported to D, so we can just copy that code<\/a>.<\/p>\n
    Building make<\/code> is so easy it doesn\u2019t even need a makefile:<\/p>\n
    \\dmd2.079\\windows\\bin\\dmd make.d dman.d -O -release -betterC -I. -I\\dmd2.079\\src\\druntime\\import\\ shell32.lib<\/pre>\n
    Summary<\/h2>\n
    We\u2019ve stuck to the Evil Plan of translating a non-trivial old school C program to D, and thereby were able to do it quickly and get it working correctly. An equivalent executable was generated.<\/p>\n
    The issues encountered are typical and easily dealt with:<\/p>\n