Changeset 16049 in project


Ignore:
Timestamp:
09/23/09 13:17:56 (10 years ago)
Author:
Ivan Raikov
Message:

converted nemo to using getopt-long

Location:
release/4/nemo/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • release/4/nemo/trunk/nemo-eggdoc.scm

    r15395 r16049  
    2020
    2121
    22 (use eggdoc srfi-1)
     22(require-library eggdoc srfi-1)
     23(import eggdoc srfi-1)
    2324
    2425(define doc
  • release/4/nemo/trunk/nemo.meta

    r15866 r16049  
    2525
    2626 (needs eggdoc
    27         matchable args sxml-transforms ssax sxpath
     27        matchable sxml-transforms ssax sxpath
    2828        datatype vector-lib environments digraph graph-bfs graph-cycles
    29         mathh strictly-pretty varsubst lalr )
     29        mathh strictly-pretty varsubst lalr
     30        getopt-long)
    3031
    3132 (eggdoc "nemo-eggdoc.scm")
  • release/4/nemo/trunk/nemo.scm

    r15632 r16049  
    2121(import scheme chicken srfi-1)
    2222
    23 (require-extension matchable args ssax sxml-transforms sxpath sxpath-lolevel environments)
     23(require-extension matchable ssax sxml-transforms sxpath sxpath-lolevel
     24                   environments getopt-long)
    2425(require-extension nemo-core nemo-macros nemo-hh)
    2526
     
    2728(define nemo-matlab?  (extension-information 'nemo-matlab))
    2829
    29 (if nemo-nmodl? (use nemo-nmodl))
    30 (if nemo-matlab? (use nemo-matlab))
     30(if nemo-nmodl?   (use nemo-nmodl))
     31(if nemo-matlab?  (use nemo-matlab))
    3132
    3233(define (lookup-def k lst . rest)
     
    5859(define ssax:warn warn)
    5960
    60 (define opts
     61(define opt-defaults
    6162  `(
    62     ,(args:make-option (i)       (required: "FORMAT")   
    63                        (s+ "specify input format (nemo, xml, sxml, s-exp)")
    64                        (string->symbol arg))
    65     ,(args:make-option (xml)       (optional: "FILE")   
    66                        (s+ "write XML output to file (default: <model-name>.xml)"))
    67     ,(args:make-option (sxml)       (optional: "FILE")   
    68                        (s+ "write SXML output to file (default: <model-name>.sxml)"))
     63    (nmodl-kinetic . all)
     64    ))
     65
     66(define (defopt x)
     67  (lookup-def x opt-defaults))
     68
     69(define opt-grammar
     70  `(
     71    (input-format
     72     "specify input format (nemo, xml, sxml, s-exp)"
     73     (single-char #\i)
     74     (value (required FORMAT)
     75            (transformer ,string->symbol)))
     76
     77    (xml
     78     "write XML output to file (default: <model-name>.xml)"
     79     (value (optional FILENAME)
     80            ))
     81
     82    (sxml
     83     "write SXML output to file (default: <model-name>.sxml)"
     84     (value (optional FILENAME)
     85            ))
     86
    6987    ,@(if nemo-matlab?
    70           (list (args:make-option (matlab)      (optional: "FILE")   
    71                                   (s+ "write MATLAB output to file (default: <model-name>.m)"))
    72                 (args:make-option (matlab-method)       (required: "METHOD")
    73                                   (s+ "specify MATLAB/Octave integration method")
    74                                   (string->symbol arg))
    75                 )
     88          `((matlab
     89             "write MATLAB/Octave output to file (default: <model-name>.m)"
     90             (value (optional FILENAME)))
     91                     
     92            (matlab-method
     93             "specify MATLAB/Octave integration method"
     94             (value (required METHOD)
     95                    (transformer ,string->symbol)))
     96            )
    7697          `())
    7798    ,@(if nemo-nmodl?
    78           (list
    79            (args:make-option (nmodl)      (optional: "FILE")   
    80                              (s+ "write NMODL output to file (default: <model-name>.mod)"))
    81            (args:make-option (nmodl-kinetic)       (optional: "STATES")
    82                              (s+ "use NMODL kinetic equations for the given reactions "
    83                                  "(or for all reactions)"))
    84            (args:make-option (nmodl-method)       (required: "METHOD")
    85                              (s+ "specify NMODL integration method")
    86                              (string->symbol arg))
    87            (args:make-option (nmodl-depend)       (required: "VARS")
    88                              (s+ "specify DEPEND variables for NMODL interpolation tables")
    89                              (map string->symbol (string-split arg ",")))
    90            )
    91           `())
    92     ,(args:make-option (t)       #:none
    93                        (s+ "use interpolation tables in generated code, if possible")
    94                        #t)
    95     ,(args:make-option (h help)  #:none               "Print help"
    96                        (usage))
     99          `(
     100             (nmodl      "write NMODL output to file (default: <model-name>.mod)"
     101                         (value (optional FILENAME)))
     102
     103             (nmodl-kinetic  ,(s+ "use NMODL kinetic equations for the given reactions "
     104                                  "(or for all reactions)")
     105                             (value (optional STATES)
     106                                    (transformer
     107                                     ,(lambda (x)
     108                                        (or (and (symbol? x) x)
     109                                            (map string->symbol (string-split x ",")))))))
     110             
     111             (nmodl-method   "specify NMODL integration method"
     112                             (value (required METHOD)
     113                                    (transformer ,string->symbol)))
     114
     115             (nmodl-depend    "specify DEPEND variables for NMODL interpolation tables"
     116                              (value (required VARS)
     117                                     (transformer
     118                                      ,(lambda (x)
     119                                         (map string->symbol (string-split x ","))))))
     120             )
     121            `())
     122
     123    (t "use interpolation tables in generated code, if possible")
     124
     125    (help         (single-char #\h))
     126
    97127
    98128    ))
     
    101131;; Use args:usage to generate a formatted list of options (from OPTS),
    102132;; suitable for embedding into help text.
    103 (define (usage)
     133(define (nemo:usage)
    104134  (print "Usage: " (car (argv)) " [options...] <list of files to be processed> ")
    105135  (newline)
    106136  (print "The following options are recognized: ")
    107137  (newline)
    108   (print (parameterize ((args:indent 5) (args:width 30)) (args:usage opts)))
     138  (print (parameterize ((indent 5) (width 30)) (usage opt-grammar)))
    109139  (exit 1))
    110140
    111141
    112142;; Process arguments and collate options and arguments into OPTIONS
    113 ;; alist, and operands (filenames) into OPERANDS. 
    114 (define args    (command-line-arguments))
    115 (set!-values (options operands)  (args:parse args opts))
     143;; alist, and operands (filenames) into OPERANDS.  You can handle
     144;; options as they are processed, or afterwards.
     145
     146(define opts    (getopt-long (command-line-arguments) opt-grammar))
     147(define opt     (make-option-dispatch opts opt-grammar))
    116148
    117149
     
    180212            (let ((model-1 (nemo:hh-transformer model parse-expr)))
    181213              (if (assoc 'depgraph options) (print "dependency graph: " ((nemo 'depgraph*) model-1)))
    182               (if (assoc 'exports options) (print "exports: " ((nemo 'exports) model-1)))       
    183               (if (assoc 'imports options) (print "imports: " ((nemo 'imports) model-1)))
     214              (if (assoc 'exports options)  (print "exports: " ((nemo 'exports) model-1)))     
     215              (if (assoc 'imports options)  (print "imports: " ((nemo 'imports) model-1)))
    184216              (if (assoc 'components options)
    185217                  (for-each (lambda (x)
     
    401433   
    402434
    403 (define (model->ncml options model parse-expr)
     435(define (model->ncml model parse-expr)
    404436  (match-let ((($ nemo:quantity 'DISPATCH  dis)     
    405437               (environment-ref model (nemo-intern 'dispatch))))
     
    728760
    729761 
    730 (define (main options operands)
     762(define (main opt operands)
    731763  (if (null? operands)
    732       (usage)
     764      (nemo:usage)
    733765      (for-each
    734766       (lambda (operand)
     
    736768                                            (lambda (port) (ssax:xml->sxml port '((ncml . "ncml")))) )))
    737769                (read-sexp  (lambda (name) (call-with-input-file name read)))
    738                 (in-format  (cond ((lookup-def 'i options) =>
     770
     771                (in-format  (cond ((opt 'input-format) =>
    739772                                   (lambda (x)
    740                                      (case ($ x)
     773                                     (case x
    741774                                       ((nemo)        'nemo)
    742775                                       ((s-exp sexp)  'sexp)
    743                                        ((sxml)  'sxml)
    744                                        ((xml)   'xml)
    745                                        (else    (error 'nemo "unknown input format" x)))))
     776                                       ((sxml)        'sxml)
     777                                       ((xml)         'xml)
     778                                       (else          (error 'nemo "unknown input format" x)))))
    746779                                  (else  (case ((lambda (x) (or (not x) ($ x)))
    747780                                                (pathname-extension operand))
     
    750783                                           ((xml)   'xml)
    751784                                           (else    'nemo)))))
     785
    752786                (doc        (case in-format
    753787                              ((nemo sxml s-exp sexp)  (read-sexp operand))
     
    762796
    763797                (model       (case in-format
    764                                ((sxml xml)          (ncml->model options doc))
    765                                ((s-exp sexp)        (sexp->model options doc parse-expr))
    766                                ((nemo)              (sexp->model options doc parse-expr))
     798                               ((sxml xml)          (ncml->model '() doc))
     799                               ((s-exp sexp)        (sexp->model '() doc parse-expr))
     800                               ((nemo)              (sexp->model '() doc parse-expr))
    767801                               (else    (error 'nemo "unknown input format" in-format))))
    768802
    769                 (sxml-fname  ((lambda (x) (and x (if (and (cdr x) (string? (cdr x)))
    770                                                      (s+ (pathname-strip-extension (cdr x)) ".sxml")
    771                                                      (s+  (pathname-strip-extension operand) ".sxml"))))
    772                               (assoc 'sxml options)))
    773                 (xml-fname  ((lambda (x)  (and x (if (and (cdr x) (string? (cdr x)))
    774                                                      (s+ (pathname-strip-extension (cdr x)) ".xml")
    775                                                      (s+  (pathname-strip-extension operand) ".xml"))))
    776                               (assoc 'xml options)))
    777                 (mod-fname  ((lambda (x) (and x (if (and (cdr x) (string? (cdr x)))
    778                                                     (s+ (pathname-strip-extension (cdr x)) ".mod")
    779                                                     (s+  (pathname-strip-extension operand) ".mod"))))
    780                              (assoc 'nmodl options)))
    781                 (mat-fname  ((lambda (x) (and x (if (and (cdr x) (string? (cdr x)))
    782                                                     (s+ (pathname-strip-extension (cdr x)) ".m")
    783                                                     (s+  (pathname-strip-extension operand) ".m"))))
    784                              (assoc 'matlab options)))
    785                 (nmodl-depend  (lookup-def 'nmodl-depend options))
     803                (make-fname  (lambda (operand x suffix)
     804                               (and x (let ((fname (pathname-strip-extension operand)))
     805                                        (if (string? x) x (s+ fname suffix))))))
     806
     807                (sxml-fname  (make-fname operand (opt 'sxml) ".sxml"))
     808                (xml-fname   (make-fname operand (opt 'xml) ".xml"))
     809                (mod-fname   (make-fname operand (opt 'nmodl) ".mod"))
     810                (mat-fname   (make-fname operand (opt 'matlab) ".m"))
     811
     812                (nmodl-depend  (opt 'nmodl-depend))
    786813                                 
    787814                (nmodl-method
    788                  (let ((method  ($ (lookup-def 'nmodl-method options) )))
     815                 (let ((method  ($ (opt 'nmodl-method) )))
    789816                   (case method
    790817
     
    795822
    796823                (matlab-method
    797                  (let ((method  ($ (lookup-def 'matlab-method options) )))
     824                 (let ((method  ($ (opt 'matlab-method) )))
    798825                   (case method
    799826                     ((lsode odepkg #f) method)
     
    801828                )
    802829           (if sxml-fname (with-output-to-file sxml-fname
    803                             (lambda () (pretty-print (model->ncml options model parse-expr)))))
    804            (if xml-fname  (let* ((doc  (model->ncml options model parse-expr))
     830                            (lambda () (pretty-print (model->ncml model parse-expr)))))
     831           (if xml-fname  (let* ((doc  (model->ncml model parse-expr))
    805832                                 (doc1 (ensure-xmlns
    806833                                       (cond ((eq? (car doc) '*TOP*) (assoc 'ncml:model (cdr doc)))
     
    813840                                (model->nmodl `((depend  . ,nmodl-depend)
    814841                                                (method  . ,nmodl-method)
    815                                                 (table   . ,(assoc 't options))
    816                                                 (kinetic
    817                                                  ,(let ((opt (assoc 'nmodl-kinetic options)))
    818                                                     (and opt
    819                                                          (if (string? (cdr opt))
    820                                                              (map string->symbol (string-split (cdr opt) ","))
    821                                                              'all)))))
     842                                                (table   . ,(opt 't))
     843                                                (kinetic . ,(opt 'nmodl-kinetic)))
    822844                                              model))))
    823845           (if mat-fname
     
    825847                   mat-fname  (lambda ()
    826848                                (model->matlab `((method  . ,matlab-method)
    827                                                  (table   . ,(assoc 't options))
     849                                                 (table   . ,(opt 't))
    828850                                                 )
    829851                                               model))))
     
    831853       operands)))
    832854
    833 (main options operands)
    834 
     855(main opt (opt '@))
     856
  • release/4/nemo/trunk/nemo.setup

    r15632 r16049  
    3232(make (
    3333       ((dynld-name "nemo-utils") ("nemo-utils.scm")
    34         (run (csc -O -d2 -s nemo-utils.scm -j nemo-utils)) )
     34        (compile -O -d2 -s nemo-utils.scm -j nemo-utils))
    3535
    3636       ((dynld-name "nemo-utils.import") ("nemo-utils.import.scm")
    37         (run (csc -O2 -s nemo-utils.import.scm)) )
     37        (compile -O2 -s nemo-utils.import.scm))
    3838       )
    3939  (list (dynld-name "nemo-utils")
     
    5656(make (
    5757       ((dynld-name "nemo-ionch") ("nemo-ionch.scm")
    58         (run (csc -O -d2 -s nemo-ionch.scm -j nemo-ionch)) )
     58        (compile -O -d2 -s nemo-ionch.scm -j nemo-ionch))
    5959
    6060       ((dynld-name "nemo-ionch.import") ("nemo-ionch.import.scm")
    61         (run (csc -O2 -s nemo-ionch.import.scm)) )
     61        (compile -O2 -s nemo-ionch.import.scm))
    6262       )
    6363  (list (dynld-name "nemo-ionch")
     
    8181(make (
    8282       ((dynld-name "nemo-macros") ("nemo-macros.scm")
    83         (run (csc -O -d2 -s nemo-macros.scm -j nemo-macros)) )
     83        (compile -O -d2 -s nemo-macros.scm -j nemo-macros))
    8484
    8585       ((dynld-name "nemo-macros.import") ("nemo-macros.import.scm")
    86         (run (csc -O2 -s nemo-macros.import.scm)) )
     86        (compile -O2 -s nemo-macros.import.scm))
    8787       )
    8888  (list (dynld-name "nemo-macros")
     
    104104(make (
    105105       ((dynld-name "nemo-nmodl") ("nemo-nmodl.scm")
    106         (run (csc -O -d2 -s nemo-nmodl.scm -j nemo-nmodl)) )
     106        (compile -O -d2 -s nemo-nmodl.scm -j nemo-nmodl))
    107107
    108108       ((dynld-name "nemo-nmodl.import") ("nemo-nmodl.import.scm")
    109         (run (csc -O2 -s nemo-nmodl.import.scm)) )
     109        (compile -O2 -s nemo-nmodl.import.scm))
    110110       )
    111111  (list (dynld-name "nemo-nmodl")
     
    128128      (make (
    129129             ((dynld-name "nemo-matlab") ("nemo-matlab.scm")
    130               (run (csc -O -d2 -s nemo-matlab.scm -j nemo-matlab)) )
     130              (compile -O -d2 -s nemo-matlab.scm -j nemo-matlab))
    131131             
    132132             ((dynld-name "nemo-matlab.import") ("nemo-matlab.import.scm")
    133               (run (csc -O2 -s nemo-matlab.import.scm)) )
     133              (compile -O2 -s nemo-matlab.import.scm))
    134134             )
    135135        (list (dynld-name "nemo-matlab")
     
    153153(make (
    154154       ((dynld-name "nemo-hh") ("extensions/nemo-hh.scm")
    155         (run (csc -O -d2 -s extensions/nemo-hh.scm -j nemo-hh
    156                   -o ,(dynld-name "nemo-hh")) ))
     155        (compile -O -d2 -s extensions/nemo-hh.scm -j nemo-hh
     156                 -o ,(dynld-name "nemo-hh")) )
    157157
    158158       ((dynld-name "nemo-hh.import") ("nemo-hh.import.scm")
    159         (run (csc -O2 -s nemo-hh.import.scm)) )
     159        (compile -O2 -s nemo-hh.import.scm))
    160160       )
    161161  (list (dynld-name "nemo-hh")
     
    177177
    178178(make (
    179        ((dynld-name "nemo") ("nemo.scm")
    180         (run (csc -d2 nemo.scm)) )
     179       ("nemo" ("nemo.scm")
     180        (compile -d2 nemo.scm))
    181181       )
    182182  "nemo")
Note: See TracChangeset for help on using the changeset viewer.