Changeset 11888 in project


Ignore:
Timestamp:
09/04/08 04:06:16 (13 years ago)
Author:
Ivan Raikov
Message:

Improvements in the nemo command-line interface, sxml example began.

Location:
release/3/nemo/trunk
Files:
1 added
1 edited

Legend:

Unmodified
Added
Removed
  • release/3/nemo/trunk/nemo.scm

    r11870 r11888  
    2222(require-extension  syntax-case)
    2323(require-extension  matchable)
    24 
     24(require-extension  args)
    2525(require-extension  nemo-macros)
    2626(require-extension  nemo-nmodl)
     
    6868                       (s+ "specify input format (xml, sxml)")
    6969                       (string->symbol arg))
    70     ,(args:make-option (o)       (required: "FORMAT")   
    71                        (s+ "specify output format (nmodl, sxml)")
    72                        (string->symbol arg))
    73     ,(args:make-option (sxml-file)       (required: "FILE")   
     70    ,(args:make-option (sxml)       (optional: "FILE")   
    7471                       (s+ "write SXML output to file (default: <model-name>.sxml)"))
    75     ,(args:make-option (nmodl-file)       (required: "FILE")   
    76                        (s+ "write NMODL output to file"))
    77     ,(args:make-option (nmodl-file)       (required: "FILE")   
    78                        (s+ "write NMODL output to file"))
     72    ,(args:make-option (nmodl)      (optional: "FILE")   
     73                       (s+ "write NMODL output to file (default: <model-name>.mod)"))
    7974    ,(args:make-option (nmodl-method)       (required: "METHOD")
    8075                       (s+ "specify NMODL integration method (cnexp, derivimplicit)")
     
    9691  (print "The following options are recognized: ")
    9792  (newline)
    98   (print (parameterize ((args:indent 5)) (args:usage opts)))
     93  (print (parameterize ((args:indent 5) (args:width 30)) (args:usage opts)))
    9994  (exit 1))
    10095
     
    127122        (sxml:match 'ncml:input
    128123                    (lambda (node bindings root env)
    129                       (let ((id   (sxml:attrv 'id node))
     124                      (let ((id   (sxml:attr 'id node))
    130125                            (from (sxml:kidn 'from node))
    131126                            (as   (sxml:kidn 'as node)))
     
    140135        (sxml:match 'ncml:output
    141136                    (lambda (node bindings root env)
    142                       (let ((id   (sxml:attrv 'id node)))
     137                      (let ((id   (sxml:attr 'id node)))
    143138                        (if (not id) (error 'output-template "output declaration requires id attribute"))
    144139                        `(output ,(string->symbol id))))))
     
    147142        (sxml:match 'ncml:const
    148143                    (lambda (node bindings root env)
    149                       (let ((id   (sxml:attrv 'id node))
     144                      (let ((id   (sxml:attr 'id node))
    150145                            (expr ((lambda (x)
    151146                                     (if (not x) 
     
    159154        (sxml:match 'ncml:transition
    160155                    (lambda (node bindings root env)
    161                       (let ((src  (sxml:attrv 'src node))
    162                             (dest (sxml:attrv 'dest node))
     156                      (let ((src  (sxml:attr 'src node))
     157                            (dest (sxml:attr 'dest node))
    163158                            (expr ((lambda (x)
    164159                                     (if (not x) 
     
    176171        (sxml:match 'ncml:asgn
    177172                    (lambda (node bindings root env)
    178                       (let ((id   (sxml:attrv 'id node))
     173                      (let ((id   (sxml:attr 'id node))
    179174                            (expr ((lambda (x)
    180175                                     (if (not x) 
     
    189184        (sxml:match 'ncml:state_complex
    190185                    (lambda (node bindings root env)
    191                       (let ((id   (sxml:attrv 'id node))
     186                      (let ((id   (sxml:attr 'id node))
    192187                            (initial ((lambda (x)
    193188                                        (if (not x) 
     
    223218        (sxml:match 'ncml:defun
    224219                    (lambda (node bindings root env)
    225                       (let ((id    (sxml:attrv 'id node))
     220                      (let ((id    (sxml:attr 'id node))
    226221                            (args  ((lambda (x)
    227222                                      (if (null? x) 
     
    229224                                                 "function definition requires at least one arg element")
    230225                                          (map string->symbol x)))
    231                                     (sxml:kidsn 'arg node)))
     226                                    (sxml:kidsn 'ncml:arg node)))
    232227                            (body ((lambda (x)
    233228                                     (if (not x) 
     
    235230                                                "function definition requires body element")
    236231                                         (ncml-expr->expr x)))
    237                                    (sxml:kidn 'body node))))
     232                                   (sxml:kidn 'ncml:body node))))
    238233                        (if (not id) (error 'defun-template "function definition requires id attribute"))
    239234                        `(defun (,id ,args ,body))))))
     235
     236       (component-template
     237        (sxml:match 'ncml:component
     238                    (lambda (node bindings root env)
     239                      (let ((name (sxml:attr 'name node))
     240                            (type (sxml:attr 'type node)))
     241                        (if (not type) (error 'component-template "component definition requires type attribute"))
     242                        (if name
     243                            `(component (type ,type) (name ,name) ,(ncml->decls node))
     244                            `(component (type ,type) ,(ncml->decls node)))))))
    240245
    241246       
     
    247252                                                       asgn-template
    248253                                                       state-complex-template
    249                                                        defun-template)
     254                                                       defun-template
     255                                                       component-template)
    250256                         ncml:model (list))))
    251257
    252258(define (ncml->nmodl options doc)
    253259  (let* ((ncml:model   (ncml:sxpath '(ncml:model) doc))
    254          (model-name  (sxml:attrv 'name ncml:model))
    255          (model-decls (ncml->decls ncml:model)))
     260         (model-name   (sxml:attr 'name ncml:model))
     261         (model-decls  (ncml->decls ncml:model)))
    256262    (match  (nemo-constructor model-name model-decls)
    257263            ((model nemo)
     
    273279      (for-each
    274280       (lambda (operand)
    275          (let ((doc        (call-with-input-file operand (lambda (port) (ssax:xml->sxml port '((ncml . "ncml")))) ))
    276                (mod-fname  (s+ (lookup-def 'nmodl-file options (pathname-strip-extension operand)) ".mod"))
    277                (sxml-fname ((lambda (x) (and x (if (string? (cdr x)) (s+ (pathname-strip-extension (cdr x)) ".sxml")
     281         (let ((read-xml  (lambda (name) (call-with-input-file name
     282                                           (lambda (port) (ssax:xml->sxml port '((ncml . "ncml")))) )))
     283               (read-sxml  (lambda (name) (call-with-input-file name read)))
     284               (doc        (cond ((lookup-def 'i options) => (lambda (x)
     285                                                               (case (string->symbol x)
     286                                                                 ((sxml)  (read-sxml operand))
     287                                                                 ((xml)   (read-xml operand))
     288                                                                 (else    (error 'nemo "unknown input format" x)))))
     289                                 (else  (case ((lambda (x) (or (not x) (string->symbol x)))
     290                                               (pathname-extension operand))
     291                                          ((xml)   (read-xml operand))
     292                                          ((sxml)  (read-sxml operand))
     293                                          (else    (read-xml operand))))))
     294               (sxml-fname  ((lambda (x) (and x (if (string? (cdr x)) (s+ (pathname-strip-extension (cdr x)) ".sxml")
    278295                                                   (s+  (pathname-strip-extension operand) ".sxml"))))
    279                             (assoc 'sxml-file options)))
     296                            (assoc 'sxml options)))
     297               (mod-fname  ((lambda (x) (and x (if (string? (cdr x)) (s+ (pathname-strip-extension (cdr x)) ".mod")
     298                                                   (s+  (pathname-strip-extension operand) ".mod"))))
     299                            (assoc 'nmodl options)))
    280300               (nmodl-method
    281301                (let ((method  ((lambda (x) (and x (string->symbol x))) (lookup-def 'nmodl-method options) )))
Note: See TracChangeset for help on using the changeset viewer.