c-mera/roswell/cm.ros at master · kiselgra/c-mera · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#!/bin/sh
#|-*- mode:lisp -*-|#
#|C-Mera generator
exec ros -Q -L sbcl-bin -m c-mera -- $0 "$@"
|#
(progn ;;init forms
  (ros:ensure-asdf)
  #+quicklisp(ql:quickload '(:c-mera
                             :cm-c
                             :cmu-c
                             :cm-c++
                             :cmu-c++
                             :cms-c++
                             :cms-cuda
                             :cms-glsl
                             :cms-opencl)
                           :silent t))

(defpackage :ros.script.cm.3700387292
  (:use :cl))
(in-package :ros.script.cm.3700387292)

(defvar *supported* '("c" "c++" "cxx" "glsl" "ocl" "opencl" "cuda"))
(defvar *abbrev* '(("cxx" . "c++") ("ocl" . "opencl")))
(defvar *processor* '(("c++" . "cxx")))

(defun main (&rest argv)
  (let ((gen "c")
        version help (cmd (pathname-name *load-pathname*)))
    (when (and (> (length cmd) 3)
               (string-equal "cm-" cmd :end2 3))
      (push (subseq cmd 3) argv))
    (cond ((zerop (length argv))
           (format
            t "~{~A~%~}"
            `("C-Mera generator selection frontend."
              ,(format nil "Please specify generator type as~{ ~A~^,~} or use --help." *supported*)
              "Generator abbreviations are ok and checked in the order given above."))
           (ros:quit 1))
          ((find (first argv) *supported* :test 'equal)
           (setf gen (or (cdr (assoc (first argv) *abbrev* :test 'equal))
                         (first argv))))
          ((find (first argv) '("--version" "-V") :test 'equal)
           (setf version t))
          (t (setf help t)))
    (let ((*package* (find-package (read-from-string (format nil ":cmu-~A" gen))))
          (processor-name (or (cdr (assoc gen *processor* :test #'equal))
                              gen)))
      (setf (readtable-case *readtable*) :invert)
      (funcall (read-from-string (format nil "cm-~A::~A-processor" gen processor-name))
               (cond
                 (version '("--version"))
                 (help '("--help"))
                 (t (rest argv)))))))
;;; vim: set ft=lisp lisp: