lisp/ob-C.el

   1 ;;; ob-C.el --- org-babel functions for C and similar languages
   2
   3 ;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
   4
   5 ;; Author: Eric Schulte
   6 ;;      Thierry Banel
   7 ;; Keywords: literate programming, reproducible research
   8 ;; Homepage: http://orgmode.org
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;; Org-Babel support for evaluating C, C++, D code.
  28 ;;
  29 ;; very limited implementation:
  30 ;; - currently only support :results output
  31 ;; - not much in the way of error feedback
  32
  33 ;;; Code:
  34 (require 'ob)
  35 (require 'cc-mode)
  36
  37 (declare-function org-entry-get "org"
  38                   (pom property &optional inherit literal-nil))
  39 (declare-function org-remove-indentation "org" (code &optional n))
  40
  41 (defvar org-babel-tangle-lang-exts)
  42 (add-to-list 'org-babel-tangle-lang-exts '("C++" . "cpp"))
  43 (add-to-list 'org-babel-tangle-lang-exts '("D" . "d"))
  44
  45 (defvar org-babel-default-header-args:C '())
  46
  47 (defcustom org-babel-C-compiler "gcc"
  48   "Command used to compile a C source code file into an executable.
  49 May be either a command in the path, like gcc
  50 or an absolute path name, like /usr/local/bin/gcc
  51 parameter may be used, like gcc -v"
  52   :group 'org-babel
  53   :version "24.3"
  54   :type 'string)
  55
  56 (defcustom org-babel-C++-compiler "g++"
  57   "Command used to compile a C++ source code file into an executable.
  58 May be either a command in the path, like g++
  59 or an absolute path name, like /usr/local/bin/g++
  60 parameter may be used, like g++ -v"
  61   :group 'org-babel
  62   :version "24.3"
  63   :type 'string)
  64
  65 (defcustom org-babel-D-compiler "rdmd"
  66   "Command used to compile and execute a D source code file.
  67 May be either a command in the path, like rdmd
  68 or an absolute path name, like /usr/local/bin/rdmd
  69 parameter may be used, like rdmd --chatty"
  70   :group 'org-babel
  71   :version "24.3"
  72   :type 'string)
  73
  74 (defvar org-babel-c-variant nil
  75   "Internal variable used to hold which type of C (e.g. C or C++ or D)
  76 is currently being evaluated.")
  77
  78 (defun org-babel-execute:cpp (body params)
  79   "Execute BODY according to PARAMS.
  80 This function calls `org-babel-execute:C++'."
  81   (org-babel-execute:C++ body params))
  82
  83 (defun org-babel-expand-body:cpp (body params)
  84   "Expand a block of C++ code with org-babel according to it's
  85 header arguments."
  86   (org-babel-expand-body:C++ body params))
  87
  88 (defun org-babel-execute:C++ (body params)
  89   "Execute a block of C++ code with org-babel.
  90 This function is called by `org-babel-execute-src-block'."
  91   (let ((org-babel-c-variant 'cpp)) (org-babel-C-execute body params)))
  92
  93 (defun org-babel-expand-body:C++ (body params)
  94   "Expand a block of C++ code with org-babel according to it's
  95 header arguments."
  96   (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand-C++ body params)))
  97
  98 (defun org-babel-execute:D (body params)
  99   "Execute a block of D code with org-babel.
 100 This function is called by `org-babel-execute-src-block'."
 101   (let ((org-babel-c-variant 'd)) (org-babel-C-execute body params)))
 102
 103 (defun org-babel-expand-body:D (body params)
 104   "Expand a block of D code with org-babel according to it's
 105 header arguments."
 106   (let ((org-babel-c-variant 'd)) (org-babel-C-expand-D body params)))
 107
 108 (defun org-babel-execute:C (body params)
 109   "Execute a block of C code with org-babel.
 110 This function is called by `org-babel-execute-src-block'."
 111   (let ((org-babel-c-variant 'c)) (org-babel-C-execute body params)))
 112
 113 (defun org-babel-expand-body:C (body params)
 114   "Expand a block of C code with org-babel according to it's
 115 header arguments."
 116   (let ((org-babel-c-variant 'c)) (org-babel-C-expand-C body params)))
 117
 118 (defun org-babel-C-execute (body params)
 119   "This function should only be called by `org-babel-execute:C'
 120 or `org-babel-execute:C++' or `org-babel-execute:D'."
 121   (let* ((tmp-src-file (org-babel-temp-file
 122                         "C-src-"
 123                         (case org-babel-c-variant
 124                          (c   ".c"  )
 125                          (cpp ".cpp")
 126                          (d   ".d"  ))))
 127          (tmp-bin-file (org-babel-temp-file "C-bin-" org-babel-exeext)) ;; not used for D
 128          (cmdline (cdr (assoc :cmdline params)))
 129          (cmdline (if cmdline (concat " " cmdline) ""))
 130          (flags (cdr (assoc :flags params)))
 131          (flags (mapconcat 'identity
 132                            (if (listp flags) flags (list flags)) " "))
 133          (full-body
 134           (case org-babel-c-variant
 135             (c   (org-babel-C-expand-C   body params))
 136             (cpp (org-babel-C-expand-C++ body params))
 137             (d   (org-babel-C-expand-D   body params)))))
 138     (with-temp-file tmp-src-file (insert full-body))
 139     (case org-babel-c-variant
 140       ((c cpp)
 141        (org-babel-eval
 142         (format "%s -o %s %s %s"
 143                 (case org-babel-c-variant
 144                  (c   org-babel-C-compiler)
 145                  (cpp org-babel-C++-compiler))
 146                 (org-babel-process-file-name tmp-bin-file)
 147                 flags
 148                 (org-babel-process-file-name tmp-src-file)) ""))
 149       (d nil)) ;; no separate compilation for D
 150     (let ((results
 151            (org-babel-eval
 152             (case org-babel-c-variant
 153               ((c cpp)
 154                (concat tmp-bin-file cmdline))
 155               (d
 156                (format "%s %s %s %s"
 157                        org-babel-D-compiler
 158                        flags
 159                        (org-babel-process-file-name tmp-src-file)
 160                        cmdline)))
 161             "")))
 162       (when results
 163         (setq results (org-babel-trim (org-remove-indentation results)))
 164         (org-babel-reassemble-table
 165          (org-babel-result-cond (cdr (assoc :result-params params))
 166            (org-babel-read results t)
 167            (let ((tmp-file (org-babel-temp-file "c-")))
 168              (with-temp-file tmp-file (insert results))
 169              (org-babel-import-elisp-from-file tmp-file)))
 170          (org-babel-pick-name
 171           (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
 172          (org-babel-pick-name
 173           (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
 174       )))
 175
 176 (defun org-babel-C-expand-C++ (body params)
 177   "Expand a block of C or C++ code with org-babel according to
 178 it's header arguments."
 179   (org-babel-C-expand-C body params))
 180
 181 (defun org-babel-C-expand-C (body params)
 182   "Expand a block of C or C++ code with org-babel according to
 183 it's header arguments."
 184   (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
 185         (colnames (cdar (org-babel-get-header params :colname-names)))
 186         (main-p (not (string= (cdr (assoc :main params)) "no")))
 187         (includes (org-babel-read
 188                    (or (cdr (assoc :includes params))
 189                        (org-entry-get nil "includes" t))
 190                    nil))
 191         (defines (org-babel-read
 192                   (or (cdr (assoc :defines params))
 193                       (org-entry-get nil "defines" t))
 194                   nil)))
 195     (when (stringp includes)
 196       (setq includes (split-string includes)))
 197     (setq includes (append includes '("<string.h>" "<stdio.h>" "<stdlib.h>")))
 198     (when (stringp defines)
 199       (let ((y nil)
 200             (result (list t)))
 201         (dolist (x (split-string defines))
 202           (if (null y)
 203               (setq y x)
 204             (nconc result (list (concat y " " x)))
 205             (setq y nil)))
 206         (setq defines (cdr result))))
 207     (mapconcat 'identity
 208                (list
 209                 ;; includes
 210                 (mapconcat
 211                  (lambda (inc) (format "#include %s" inc))
 212                  includes "\n")
 213                 ;; defines
 214                 (mapconcat
 215                  (lambda (inc) (format "#define %s" inc))
 216                  (if (listp defines) defines (list defines)) "\n")
 217                 ;; variables
 218                 (mapconcat 'org-babel-C-var-to-C vars "\n")
 219                 ;; table sizes
 220                 (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
 221                 ;; tables headers utility
 222                 (when colnames
 223                   (org-babel-C-utility-header-to-C))
 224                 ;; tables headers
 225                 (mapconcat 'org-babel-C-header-to-C colnames "\n")
 226                 ;; body
 227                 (if main-p
 228                     (org-babel-C-ensure-main-wrap body)
 229                   body) "\n") "\n")))
 230
 231 (defun org-babel-C-expand-D (body params)
 232   "Expand a block of D code with org-babel according to
 233 it's header arguments."
 234   (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
 235         (colnames (cdar (org-babel-get-header params :colname-names)))
 236         (main-p (not (string= (cdr (assoc :main params)) "no")))
 237         (imports (or (cdr (assoc :imports params))
 238                      (org-babel-read (org-entry-get nil "imports" t)))))
 239     (when (stringp imports)
 240       (setq imports (split-string imports)))
 241     (setq imports (append imports '("std.stdio" "std.conv")))
 242     (mapconcat 'identity
 243                (list
 244                 "module mmm;"
 245                 ;; imports
 246                 (mapconcat
 247                  (lambda (inc) (format "import %s;" inc))
 248                  imports "\n")
 249                 ;; variables
 250                 (mapconcat 'org-babel-C-var-to-C vars "\n")
 251                 ;; table sizes
 252                 (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
 253                 ;; tables headers utility
 254                 (when colnames
 255                   (org-babel-C-utility-header-to-C))
 256                 ;; tables headers
 257                 (mapconcat 'org-babel-C-header-to-C colnames "\n")
 258                 ;; body
 259                 (if main-p
 260                     (org-babel-C-ensure-main-wrap body)
 261                   body) "\n") "\n")))
 262
 263 (defun org-babel-C-ensure-main-wrap (body)
 264   "Wrap BODY in a \"main\" function call if none exists."
 265   (if (string-match "^[ \t]*[intvod]+[ \t\n\r]*main[ \t]*(.*)" body)
 266       body
 267     (format "int main() {\n%s\nreturn 0;\n}\n" body)))
 268
 269 (defun org-babel-prep-session:C (session params)
 270   "This function does nothing as C is a compiled language with no
 271 support for sessions"
 272   (error "C is a compiled languages -- no support for sessions"))
 273
 274 (defun org-babel-load-session:C (session body params)
 275   "This function does nothing as C is a compiled language with no
 276 support for sessions"
 277   (error "C is a compiled languages -- no support for sessions"))
 278
 279 ;; helper functions
 280
 281 (defun org-babel-C-format-val (type val)
 282   "Handle the FORMAT part of TYPE with the data from VAL."
 283   (let ((format-data (cadr type)))
 284     (if (stringp format-data)
 285         (cons "" (format format-data val))
 286       (funcall format-data val))))
 287
 288 (defun org-babel-C-val-to-C-type (val)
 289   "Determine the type of VAL.
 290 Return a list (TYPE-NAME FORMAT).  TYPE-NAME should be the name of the type.
 291 FORMAT can be either a format string or a function which is called with VAL."
 292   (let* ((basetype (org-babel-C-val-to-base-type val))
 293          (type
 294           (case basetype
 295             (integerp '("int" "%d"))
 296             (floatp '("double" "%f"))
 297             (stringp
 298              (list
 299               (if (equal org-babel-c-variant 'd) "string" "const char*")
 300               "\"%s\""))
 301             (t (error "unknown type %S" basetype)))))
 302     (cond
 303      ((integerp val) type) ;; an integer declared in the #+begin_src line
 304      ((floatp val) type) ;; a numeric declared in the #+begin_src line
 305      ((and (listp val) (listp (car val))) ;; a table
 306       `(,(car type)
 307         (lambda (val)
 308           (cons
 309            (format "[%d][%d]" (length val) (length (car val)))
 310            (concat
 311             (if (equal org-babel-c-variant 'd) "[\n" "{\n")
 312             (mapconcat
 313              (lambda (v)
 314                (concat
 315                 (if (equal org-babel-c-variant 'd) " [" " {")
 316                 (mapconcat (lambda (w) (format ,(cadr type) w)) v ",")
 317                 (if (equal org-babel-c-variant 'd) "]" "}")))
 318              val
 319              ",\n")
 320             (if (equal org-babel-c-variant 'd) "\n]" "\n}"))))))
 321      ((or (listp val) (vectorp val)) ;; a list declared in the #+begin_src line
 322       `(,(car type)
 323         (lambda (val)
 324           (cons
 325            (format "[%d]" (length val))
 326            (concat
 327             (if (equal org-babel-c-variant 'd) "[" "{")
 328             (mapconcat (lambda (v) (format ,(cadr type) v)) val ",")
 329             (if (equal org-babel-c-variant 'd) "]" "}"))))))
 330      (t ;; treat unknown types as string
 331       type))))
 332
 333 (defun org-babel-C-val-to-base-type (val)
 334   "Determine the base type of VAL which may be
 335 'integerp if all base values are integers
 336 'floatp if all base values are either floating points or integers
 337 'stringp otherwise."
 338   (cond
 339    ((integerp val) 'integerp)
 340    ((floatp val) 'floatp)
 341    ((or (listp val) (vectorp val))
 342     (let ((type nil))
 343       (mapc (lambda (v)
 344               (case (org-babel-C-val-to-base-type v)
 345                 (stringp (setq type 'stringp))
 346                 (floatp
 347                  (if (or (not type) (eq type 'integerp))
 348                      (setq type 'floatp)))
 349                 (integerp
 350                  (unless type (setq type 'integerp)))))
 351             val)
 352       type))
 353    (t 'stringp)))
 354
 355 (defun org-babel-C-var-to-C (pair)
 356   "Convert an elisp val into a string of C code specifying a var
 357 of the same value."
 358   ;; TODO list support
 359   (let ((var (car pair))
 360         (val (cdr pair)))
 361     (when (symbolp val)
 362       (setq val (symbol-name val))
 363       (when (= (length val) 1)
 364         (setq val (string-to-char val))))
 365     (let* ((type-data (org-babel-C-val-to-C-type val))
 366            (type (car type-data))
 367            (formated (org-babel-C-format-val type-data val))
 368            (suffix (car formated))
 369            (data (cdr formated)))
 370       (format "%s %s%s = %s;"
 371               type
 372               var
 373               suffix
 374               data))))
 375
 376 (defun org-babel-C-table-sizes-to-C (pair)
 377   "Create constants of table dimensions, if PAIR is a table."
 378   (when (listp (cdr pair))
 379     (cond
 380      ((listp (cadr pair)) ;; a table
 381       (concat
 382        (format "const int %s_rows = %d;" (car pair) (length (cdr pair)))
 383        "\n"
 384        (format "const int %s_cols = %d;" (car pair) (length (cadr pair)))))
 385      (t ;; a list declared in the #+begin_src line
 386       (format "const int %s_cols = %d;" (car pair) (length (cdr pair)))))))
 387
 388 (defun org-babel-C-utility-header-to-C ()
 389   "Generate a utility function to convert a column name
 390 into a column number."
 391   (case org-babel-c-variant
 392     ((c cpp)
 393      "int get_column_num (int nbcols, const char** header, const char* column)
 394 {
 395   int c;
 396   for (c=0; c<nbcols; c++)
 397     if (strcmp(header[c],column)==0)
 398       return c;
 399   return -1;
 400 }
 401 "
 402      )
 403     (d
 404      "int get_column_num (string[] header, string column)
 405 {
 406   foreach (c, h; header)
 407     if (h==column)
 408       return to!int(c);
 409   return -1;
 410 }
 411 "
 412      )))
 413
 414 (defun org-babel-C-header-to-C (head)
 415   "Convert an elisp list of header table into a C or D vector
 416 specifying a variable with the name of the table."
 417   (let ((table (car head))
 418         (headers (cdr head)))
 419     (concat
 420      (format
 421       (case org-babel-c-variant
 422         ((c cpp) "const char* %s_header[%d] = {%s};")
 423         (d       "string %s_header[%d] = [%s];"))
 424       table
 425       (length headers)
 426       (mapconcat (lambda (h) (format "%S" h)) headers ","))
 427      "\n"
 428      (case org-babel-c-variant
 429        ((c cpp)
 430         (format
 431          "const char* %s_h (int row, const char* col) { return %s[row][get_column_num(%d,%s_header,col)]; }"
 432          table table (length headers) table))
 433        (d
 434         (format
 435          "string %s_h (ulong row, string col) { return %s[row][get_column_num(%s_header,col)]; }"
 436          table table table))))))
 437
 438 (provide 'ob-C)
 439
 440 ;;; ob-C.el ends here