Changeset 13235 in project


Ignore:
Timestamp:
02/10/09 07:13:04 (11 years ago)
Author:
Ivan Raikov
Message:

XML parser and generator brought up to date.

Location:
release/3/nemo/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • release/3/nemo/trunk/expr-parser.scm

    r13040 r13235  
    190190
    191191(define (nemo:parse-sym-expr lst #!optional loc)
     192  (print "parse-expr: lst = " lst)
    192193  (let ((ret (cond ((number? lst)  lst)
    193194                   ((symbol? lst)  lst)
  • release/3/nemo/trunk/nemo-core.scm

    r13052 r13235  
    946946                            (fold
    947947                             (lambda (x ax)
     948                               (match-let (((qs scope-subst) ax))
    948949                               (match x
    949950                                      ((? symbol?)
     
    963964                                         (((nemo-core 'add-external!) sys) x `(input ,id1 ,qid ,n1))
    964965                                         (list (cons qid qs) (update-subst x1 qid scope-subst))))
    965                                       ))
     966                                      )))
    966967                                  (list qs scope-subst) lst))
    967968                           (else (nemo:error 'eval-nemo-system-decls
     
    986987                            (((or 'reaction 'REACTION) ((and id (? symbol?)) . alst) )
    987988                             (let* ((loc          `(reaction ,id))
     989                                    (alst         (filter identity alst))
    988990                                    (initial      (lookup-def 'initial alst))
    989991                                    (conserve-eq  (alist-ref 'conserve alst))
     
    10441046                             (let* ((qid     (compute-qid id scope scope-subst))
    10451047                                    (qexpr   (subst-expr (parse-expr expr `(rate ,id)) scope-subst))
     1048                                    (rest    (filter identity rest))
    10461049                                    (initial (lookup-def 'initial rest)))
    10471050                               (env-extend! qid '(rate) (and initial (eval-const initial)) `(rhs ,qexpr))
  • release/3/nemo/trunk/nemo-utils.scm

    r13012 r13235  
    4343
    4444(define (lookup-def k lst . rest)
     45
    4546  (let-optionals rest ((default #f))
    4647      (let ((kv (assoc k lst)))
  • release/3/nemo/trunk/nemo.scm

    r13180 r13235  
    8282                             (s+ "write NMODL output to file (default: <model-name>.mod)"))
    8383           (args:make-option (nmodl-kinetic)       (optional: "STATES")
    84                              (s+ "use NMODL kinetic equations for the given state complexes "
    85                                  "(or for all state complexes)"))
     84                             (s+ "use NMODL kinetic equations for the given reactions "
     85                                 "(or for all reactions)"))
    8686           (args:make-option (nmodl-method)       (required: "METHOD")
    8787                             (s+ "specify NMODL integration method")
     
    143143         ((? number?)    node)
    144144         ((? string?)    (sxml:number node))
    145          (('ncml:id id)  (string->symbol (->string id)))
     145         (('ncml:id id)  ($ id))
    146146         (('ncml:apply ('@ ('id id)) . args)  (cons ($ id) (map ncml-expr->expr args)))
    147147         (('ncml:let ('ncml:bnds . bnds) ('ncml:expr body))
     
    223223            (ncml:transition (@ (src ,dst) (dst ,src))  (ncml:rate ,(expr->ncml-expr rate2)))))
    224224         (else (error 'transition->ncml-transition "invalid transition " x))))
     225
     226(define (lineq->ncml-lineq parse-expr)
     227  (lambda (x)
     228    (match x
     229           (((and i (? integer?)) '= rhs)
     230            `(ncml:lineq (@ (val ,(->string i)))
     231                         (ncml:expr ,(expr->ncml-expr (parse-expr rhs)))))
     232           (else (error 'lineq->ncml-lineq "invalid linear equation " x)))))
    225233
    226234(define builtin-fns
     
    263271    (else  (string->symbol (string-append "ncml:" (->string op))))))
    264272
    265 
    266 (define (make-component->ncml dis model)
     273(define (declaration->ncml parse-expr)
     274  (lambda (x)
     275    (match x
     276         (((or 'input 'INPUT) . lst)
     277          (map (lambda (x)
     278                 (match x
     279                        ((? symbol?)
     280                         `(ncml:input (@ id ,(->string x))))
     281                        ((id1 (or 'as 'AS) x1)
     282                         `(ncml:input (@ (id ,(->string id1)) (as ,(->string x1)))))
     283                        ((id1 (or 'from 'FROM) n1)
     284                         `(ncml:input (@ (id ,(->string id1)) (from ,(->string n1)))))
     285                        ((id1 (or 'as 'AS) x1 (or 'from 'FROM) n1)
     286                         `(ncml:input (@ (id ,(->string id1))
     287                                         (as ,(->string x1)) (from ,(->string n1)))))))
     288               lst))
     289
     290
     291         (((or 'output 'OUTPUT) . (and lst (? (lambda (x) (every symbol? x)))))
     292          (map  (lambda (x) `(ncml:output (@ (id ,(->string x))))) lst))
     293
     294
     295         (((or 'const 'CONST) (and id (? symbol?)) '= expr)
     296          `(ncml:const (@ (id ,(->string id))) (ncml:expr ,(expr->ncml-expr (parse-expr expr)))))
     297
     298
     299         (((or 'reaction 'REACTION) ((and id (? symbol?)) . alst) )
     300          (let ((trs     (lookup-def 'transitions alst))
     301                (initial (lookup-def 'initial alst))
     302                (open    (lookup-def 'open alst))
     303                (cons    (lookup-def 'conserve alst))
     304                (p       (lookup-def 'power alst)))
     305            (let ((sxml-trs (append-map transition->ncml-transition trs)))
     306              `(ncml:reaction (@ (id ,(->string id)))
     307                              (ncml:open ,open)
     308                              ,(and initial `(ncml:initial ,(expr->ncml-expr (parse-expr initial))) )
     309                              ,(and cons `(ncml:conserve ,((lineq->ncml-lineq parse-expr) cons)) )
     310                              (ncml:transitions ,@sxml-trs)
     311                              (ncml:power ,(expr->ncml-expr (parse-expr p)))))))
     312
     313
     314         (((or 'd 'D) ((and id (? symbol?))) '= expr . rest)
     315          (let ((initial (lookup-def 'initial rest)))
     316            `(ncml:rate (@ (id ,(->string id)) )
     317                        ,(and initial `(ncml:initial ,(expr->ncml-expr (parse-expr initial))))
     318                        (ncml:expr ,(expr->ncml-expr (parse-expr expr))))))
     319 
     320                           
     321         (((and id (? symbol?)) '= expr)
     322          `(ncml:asgn (@ (id ,id)) (ncml:expr ,(expr->ncml-expr (parse-expr expr)))))
     323                       
     324         (((or 'defun 'DEFUN) (and id (? symbol?))
     325           (and idlist (? (lambda (x) (every symbol? x)))) expr)
     326          `(ncml:defun (@ (id ,x))
     327                       ,@(map (lambda (v) `(ncml:arg ,(->string v))) idlist)
     328                       (ncml:body ,(expr->ncml-expr (parse-expr expr)))))
     329         
     330         (((or 'component 'COMPONENT) ((or 'type 'TYPE) typ) ((or 'name 'NAME) name) . lst)
     331          `(ncml:component (@ (name ,(->string name)) (type ,(->string typ)))
     332                           ,@(map (declaration->ncml parse-expr) lst)))
     333         
     334         (((or 'component 'COMPONENT) ((or 'type 'TYPE) typ)  . lst) 
     335          `(ncml:component (@ (type ,(->string typ)))
     336                           ,@(map (declaration->ncml parse-expr) lst)))
     337         
     338         (((or 'component 'COMPONENT)  ((or 'name 'NAME) name) '=
     339           (and functor-name (? symbol?)) (and args (? list?)))
     340          `(ncml:component (@ (name ,(->string name))
     341                              (functor-name ,(->string functor-name)))
     342                           ,@(map (declaration->ncml parse-expr) lst)))
     343         )))
     344
     345(define (make-component->ncml dis model parse-expr)
    267346  (lambda (x)
    268347    (let ((en (environment-ref model x)))
    269       (cond ((procedure? en)
    270              (let ((fd (procedure-data en)))
    271                `(ncml:defun (@ (id ,x))
    272                             ,@(map (lambda (v) `(ncml:arg ,v)) (lookup-def 'vars fd))
    273                             (ncml:body ,(expr->ncml-expr (lookup-def 'body fd))))))
    274             (else
    275              (match en
    276                    
    277                     (($ nemo:quantity 'EXTERNAL   local-name name namespace)
    278                      (if namespace
    279                          `(ncml:input (@ (id ,name)) (as ,local-name) (from ,namespace))
    280                          `(ncml:input (@ (id ,name)) (as ,local-name))))
    281                     (($ nemo:quantity 'CONST  name value)
    282                      `(ncml:const (@ (id ,name)) (ncml:expr ,value)))
    283                    
    284                     (($ nemo:quantity 'ASGN name value rhs)
    285                      (let ((expr (expr->ncml-expr rhs)))
    286                        `(ncml:asgn (@ (id ,name)) (ncml:expr ,expr))))
    287                    
    288                     (($ nemo:quantity 'REACTION name initial open trs p)
    289                      (let ((sxml-trs (append-map transition->ncml-transition trs)))
    290                        `(ncml:state_complex (@ (id ,name))
    291                                             (ncml:open ,open) (ncml:initial ,(expr->ncml-expr initial))
    292                                             (ncml:transitions ,@sxml-trs)
    293                                             (ncml:power ,(expr->ncml-expr p)))))
    294                    
    295                     (($ nemo:quantity 'COMPONENT name type lst)
    296                      (let ((component->ncml (make-component->ncml dis model))
    297                            (component-exports ((dis 'component-exports) model x)))
    298                        (case type
    299                          ((toplevel) `(,@(map component->ncml lst)
    300                                        ,@(map (lambda (x) `(ncml:output (@ (id ,x)))) component-exports)))
    301                          (else `(ncml:component (@ (name ,name) (type ,type))
    302                                                 ,@(filter-map component->ncml lst)
    303                                                 ,@(map (lambda (x) `(ncml:output (@ (id ,x)))) component-exports)
    304                                                 )))))
    305                      
    306                      (else #f)))))))
     348        (cond ((procedure? en)
     349               (let ((fd (procedure-data en)))
     350                 `(ncml:defun (@ (id ,x))
     351                              ,@(map (lambda (v) `(ncml:arg ,v)) (lookup-def 'vars fd))
     352                              (ncml:body ,(expr->ncml-expr (lookup-def 'body fd))))))
     353              (else
     354               (match en
     355                     
     356                      (($ nemo:quantity 'EXTERNAL   local-name name namespace)
     357                       (if namespace
     358                           `(ncml:input (@ (id ,name)) (as ,local-name) (from ,namespace))
     359                           `(ncml:input (@ (id ,name)) (as ,local-name))))
     360
     361                      (($ nemo:quantity 'CONST  name value)
     362                       `(ncml:const (@ (id ,name)) (ncml:expr ,value)))
     363                     
     364                      (($ nemo:quantity 'ASGN name value rhs)
     365                       (let ((expr (expr->ncml-expr rhs)))
     366                         `(ncml:asgn (@ (id ,name)) (ncml:expr ,expr))))
     367                     
     368                      (($ nemo:quantity 'RATE name initial rhs)
     369                       (let ((expr (expr->ncml-expr rhs))
     370                             (initial (and initial (expr->ncml-expr initial))))
     371                         `(ncml:rate (@ (id ,name))
     372                                     ,(and initial `(ncml:initial ,initial))
     373                                     (ncml:expr ,expr))))
     374                     
     375                      (($ nemo:quantity 'REACTION name initial open trs cons p)
     376                       (let ((sxml-trs (append-map transition->ncml-transition trs)))
     377                         `(ncml:reaction (@ (id ,name))
     378                                         (ncml:open ,open)
     379                                         ,(and initial `(ncml:initial ,(expr->ncml-expr initial)))
     380                                         ,(and cons `(ncml:conserve ,(map (lineq->ncml-lineq identity) cons)) )
     381                                         (ncml:transitions ,@sxml-trs)
     382                                         (ncml:power ,(expr->ncml-expr p)))))
     383                     
     384                      (($ nemo:quantity 'COMPONENT name type lst)
     385                       (let ((component->ncml (make-component->ncml dis model parse-expr))
     386                             (component-exports ((dis 'component-exports) model x)))
     387                         (case type
     388                           ((toplevel) `(,@(map component->ncml lst)
     389                                         ,@(map (lambda (x) `(ncml:output (@ (id ,x)))) component-exports)))
     390                           (else `(ncml:component (@ (name ,name) (type ,type))
     391                                                  ,@(filter-map component->ncml lst)
     392                                                  ,@(map (lambda (x) `(ncml:output (@ (id ,x)))) component-exports)
     393                                                  )))))
     394                     
     395                      (($ nemo:quantity 'FUNCTOR name args type lst)
     396                       (let ((component->ncml (make-component->ncml dis model parse-expr)))
     397                         `(ncml:functor (@ (name ,name) (type ,type)
     398                                           (parameters ,(string-intersperse (map ->string args) ",")))
     399                                        ,@(filter-map (declaration->ncml parse-expr) lst)
     400                                        )))
     401                     
     402                      (else #f)))))))
    307403   
    308404
    309 (define (model->ncml options model)
     405(define (model->ncml options model parse-expr)
    310406  (match-let ((($ nemo:quantity 'DISPATCH  dis)     (environment-ref model (nemo-intern 'dispatch))))
    311407     (let ((sysname     ((dis 'sysname) model))
    312            (component->ncml (make-component->ncml dis model)))
     408           (component->ncml (make-component->ncml dis model parse-expr)))
    313409       `(ncml:model (@ (name ,sysname)) ,@(component->ncml (nemo-intern 'toplevel))))))
    314410           
     
    343439
    344440(define (ensure-xmlns doc)
    345   (sxml:add-attr doc '(xmlns ncml)))
     441  (let ((doc1 (sxml:add-attr doc '(xmlns:ncml "ncml"))))
     442    (sxml:add-attr doc1 '(xmlns ncml))))
    346443
    347444
     
    364461
    365462
    366 (define (ncml->decls ncml:model)
     463(define (ncml->declarations ncml:model)
    367464  (letrec
    368465      ((input-template
     
    397494                        `(const ,($ id) = ,expr)))))
    398495       
    399        (state-complex-transition-template
     496       (reaction-transition-template
    400497        (sxml:match 'ncml:transition
    401498                    (lambda (node bindings root env)
     
    404501                            (rate  ((lambda (x)
    405502                                      (if (not x) 
    406                                           (error 'state-complex-transition-template
    407                                                  "state complex transition requires rate element")
     503                                          (error 'reaction-transition-template
     504                                                 "reaction transition requires rate element")
    408505                                          (ncml-expr->expr (second x))))
    409506                                    (sxml:kidn* 'ncml:rate node))))
    410                         (if (not src) (error 'state-complex-transition-template
    411                                              "state complex transition requires src attribute"))
    412                         (if (not dst) (error 'state-complex-transition-template
    413                                              "state complex transition requires dst attribute"))
     507                        (if (not src) (error 'reaction-transition-template
     508                                             "reaction transition requires src attribute"))
     509                        (if (not dst) (error 'reaction-transition-template
     510                                             "reaction transition requires dst attribute"))
    414511                       
    415512                        `(-> ,($ src) ,($ dst) ,rate)))))
     
    427524                        `(,($ id) = ,expr)))))
    428525       
     526       (rate-template
     527        (sxml:match 'ncml:rate
     528                    (lambda (node bindings root env)
     529                      (let ((id   (sxml:attr node 'id))
     530                            (rhs ((lambda (x)
     531                                     (if (not x) 
     532                                          (error 'rate-template "rate equation requires expr element")
     533                                          (ncml-expr->expr (second x))))
     534                                   (sxml:kidn* 'ncml:expr node)))
     535                            (initial ((lambda (x) (and x (ncml-expr->expr (second x))))
     536                                      (sxml:kidn* 'ncml:initial node))))
     537                        (if (not id) (error 'rate-template "rate equation requires id attribute"))
     538                        `(d (,($ id)) = ,rhs ,(and initial `(initial ,initial) ))))))
     539       (lineq-template
     540        (sxml:match 'ncml:lineq
     541                    (lambda (node bindings root env)
     542                      (let ((val   (string->number (->string (sxml:attr node 'val))))
     543                            (rhs   ((lambda (x)
     544                                        (if (not x) 
     545                                            (error 'lineq-template
     546                                                   "lineq definition requires expr element")
     547                                            (ncml-expr->expr (second x))))
     548                                      (sxml:kidn* 'ncml:expr node))))
     549                        `(,val = ,rhs)))))
    429550       
    430        (state-complex-template
    431         (sxml:match 'ncml:state_complex
     551       (reaction-template
     552        (sxml:match 'ncml:reaction
    432553                    (lambda (node bindings root env)
    433                       (let ((id   (string->symbol (->string (sxml:attr node 'id))))
    434                             (initial ((lambda (x)
     554                      (let* ((id      ($ (sxml:attr node 'id)))
     555                            (initial ((lambda (x) (and x (ncml-expr->expr (second x))))
     556                                      (sxml:kidn* 'ncml:initial node)))
     557
     558                            (open    ((lambda (x)
    435559                                        (if (not x) 
    436                                             (error 'state-complex-template
    437                                                    "state complex declaration requires initial element")
    438                                             (ncml-expr->expr (second x))))
    439                                       (sxml:kidn* 'ncml:initial node)))
    440                             (open ((lambda (x)
    441                                      (if (not x)
    442                                          (error 'state-complex-template
    443                                                 "state complex declaration requires open element")
    444                                          ($ (second x))))
    445                                    (sxml:kidn* 'ncml:open node)))
     560                                            (error 'reaction-template
     561                                                   "reaction declaration requires open element")
     562                                            ($ (second x))))
     563                                      (sxml:kidn* 'ncml:open node)))
     564
     565                            (conserve ((lambda (x)
     566                                         (and x (let ((tmpl (sxml:make-null-ss lineq-template)))
     567                                                  (stx:apply-templates (second x) tmpl root env))))
     568                                       (sxml:kidn* 'ncml:conserve node)))
     569
    446570                            (power ((lambda (x)
    447571                                      (if (not x) 
    448                                           (error 'state-complex-template
    449                                                  "state complex declaration requires open element")
     572                                          (error 'reaction-template
     573                                                 "reaction declaration requires open element")
    450574                                          (sxml:number (second x))))
    451575                                    (sxml:kidn* 'ncml:power node)))
     576
    452577                            (transitions ((lambda (x)
    453578                                            (if (not x) 
    454                                                 (error 'state-complex-template
    455                                                        "state complex declaration requires transitions element")
    456                                                 (let ((tmpl (sxml:make-null-ss state-complex-transition-template)))
     579                                                (error 'reaction-template
     580                                                       "reaction declaration requires transitions element")
     581                                                (let ((tmpl (sxml:make-null-ss reaction-transition-template)))
    457582                                                  (stx:apply-templates (cdr x) tmpl root env))))
    458                                           (sxml:kidn* 'ncml:transitions node))))
     583                                          (sxml:kidn* 'ncml:transitions node)))
     584
     585                            )
    459586                                         
    460                         (if (not id) (error 'state-complex-template "state complex transition requires id attribute"))
    461                         `(state-complex (,id (initial ,initial) (open ,open) (power ,power)
    462                                              (transitions ,@transitions)))))))
     587                        (if (not id) (error 'reaction-template "reaction transition requires id attribute"))
     588                        `(reaction (,id (initial ,initial) (open ,open) (power ,power)
     589                                        ,(and conserve `(conserve ,conserve) )
     590                                        (transitions ,@transitions)))))))
    463591
    464592
     
    486614                    (lambda (node bindings root env)
    487615                      (let ((name (sxml:attr node 'name))
     616                            (functor-name (sxml:attr node 'functor-name))
    488617                            (type (sxml:attr node 'type)))
    489618                        (if (not type) (error 'component-template "component definition requires type attribute"))
    490619                        (if name
    491                             `(component (type ,($ type)) (name ,($ name)) ,@(ncml->decls (sxml:kids node)))
    492                             `(component (type ,($ type)) ,@(ncml->decls (sxml:kids node))))))))
     620                            `(component (type ,($ type)) (name ,($ name)) ,@(ncml->declarations (sxml:kids node)))
     621                            (if functor-name
     622                                `(component (name ,($ name)) = ,functor-name ,(ncml->declarations (sxml:kids node)))
     623                                `(component (type ,($ type)) ,@(ncml->declarations (sxml:kids node)))))))))
     624
     625       (functor-template
     626        (sxml:match 'ncml:functor
     627                    (lambda (node bindings root env)
     628                      (let ((parameters (sxml:attr node 'parameters))
     629                            (name (sxml:attr node 'name))
     630                            (type (sxml:attr node 'type)))
     631                        (if (not type) (error 'functor-template "functor definition requires type attribute"))
     632                        (if (not name) (error 'functor-template "functor definition requires name attribute"))
     633                        (if (not parameters)
     634                            (error 'functor-template "functor definition requires parameters attribute"))
     635                        `(functor (type ,($ type)) (name ,($ name))
     636                                  (args ,(map string->symbol (string-split parameters ",")))
     637                                  ,@(ncml->declarations (sxml:kids node)))))))
    493638
    494639       (hh-template
     
    553698        )
    554699
    555     (stx:apply-templates ncml:model (sxml:make-null-ss input-template
    556                                                        output-template
    557                                                        const-template
    558                                                        asgn-template
    559                                                        state-complex-template
    560                                                        defun-template
    561                                                        component-template
    562                                                        hh-template
    563                                                        decaying-pool-template)
    564                          ncml:model (list))))
     700     (stx:apply-templates ncml:model
     701                          (sxml:make-null-ss input-template
     702                                             output-template
     703                                             const-template
     704                                             asgn-template
     705                                             rate-template
     706                                             reaction-template
     707                                             defun-template
     708                                             component-template
     709                                             functor-template
     710                                             hh-template
     711                                             decaying-pool-template)
     712                          ncml:model (list))))
    565713
    566714
     
    569717  (let* ((ncml:model   ((lambda (x)
    570718                          (if (null? x) (error 'ncml->model "ncml:model element not found in input document") (car x)))
    571                         (ncml:sxpath '(ncml:model) `(*TOP* . ,doc))))
     719                        (ncml:sxpath '(// ncml:model) `(*TOP* . ,doc))))
    572720         (model-name   (sxml:attr ncml:model 'name))
    573          (model-decls  (ncml->decls (sxml:kids ncml:model))))
    574     (let* ((model+nemo  (nemo-constructor model-name model-decls identity))
    575            (model (first model+nemo))
    576            (nemo  (second model+nemo)))
     721         (model-decls  (ncml->declarations (sxml:kids ncml:model))))
     722    (let* ((model+nemo  (nemo-constructor model-name model-decls (lambda (x . rest) (identity x))))
     723           (model       (first model+nemo))
     724           (nemo        (second model+nemo)))
    577725      (let ((model-1 (nemo:hh-transformer model)))
    578726        (if (assoc 'depgraph options) (print "dependency graph: " ((nemo 'depgraph*) model-1)))
     
    615763                              (else    (error 'nemo "unknown input format" in-format))))
    616764
     765                (parse-expr  (case in-format
     766                               ((sxml xml)          identity)
     767                               ((s-exp sexp)        identity)
     768                               ((nemo)              nemo:parse-sym-expr)
     769                               (else    (error 'nemo "unknown input format" in-format)))) 
     770
    617771                (model       (case in-format
    618772                               ((sxml xml)          (ncml->model options doc))
    619                                ((s-exp sexp)        (sexp->model options doc identity))
    620                                ((nemo)              (sexp->model options doc nemo:parse-sym-expr))
     773                               ((s-exp sexp)        (sexp->model options doc parse-expr))
     774                               ((nemo)              (sexp->model options doc parse-expr))
    621775                               (else    (error 'nemo "unknown input format" in-format))))
     776
    622777                (sxml-fname  ((lambda (x) (and x (if (and (cdr x) (string? (cdr x)))
    623778                                                     (s+ (pathname-strip-extension (cdr x)) ".sxml")
     
    653808                     (else (error "unknown matlab-method " method)))))
    654809                )
    655            (if sxml-fname (with-output-to-file sxml-fname (lambda () (pretty-print (model->ncml options model)))))
    656            (if xml-fname  (let* ((doc  (model->ncml options model))
     810           (if sxml-fname (with-output-to-file sxml-fname
     811                            (lambda () (pretty-print (model->ncml options model)))))
     812           (if xml-fname  (let* ((doc  (model->ncml options model parse-expr))
    657813                                 (doc1 (ensure-xmlns
    658814                                       (cond ((eq? (car doc) '*TOP*) (assoc 'ncml:model (cdr doc)))
    659815                                             (else doc)))))
    660                             (with-output-to-file xml-fname (lambda () (print-fragments (generate-XML `(begin ,doc1)))))))
     816                            (with-output-to-file xml-fname
     817                              (lambda () (print-fragments (generate-XML `(begin ,doc1)))))))
    661818           (if mod-fname
    662819               (with-output-to-file
  • release/3/nemo/trunk/nemo.setup

    r13180 r13235  
    88(run (csi -s expr.grm))
    99
    10 (compile -O -d2 -s -o ,(dynld-name "nemo-core")
     10(compile -d2 -s -o ,(dynld-name "nemo-core")
    1111         ,@(if has-exports? '(-check-imports -emit-exports nemo-core.exports) '())
    1212         nemo-core.scm)
     
    2727    ,@(if has-exports? `((exports "nemo-core.exports")) (list)) ))
    2828
    29 (compile -O -d2 -s -o ,(dynld-name "nemo-utils")
     29(compile -d2 -s -o ,(dynld-name "nemo-utils")
    3030         ,@(if has-exports? '(-check-imports -emit-exports nemo-utils.exports) '())
    3131         nemo-utils.scm)
     
    4848
    4949
    50 (compile -O -d2 -s -o ,(dynld-name "nemo-ionch")
     50(compile -d2 -s -o ,(dynld-name "nemo-ionch")
    5151         ,@(if has-exports? '(-check-imports -emit-exports nemo-ionch.exports) '())
    5252         nemo-ionch.scm)
     
    7676
    7777
    78 (compile -O -d2 -s -extension -o ,(dynld-name "nemo-nmodl")
     78(compile -d2 -s -extension -o ,(dynld-name "nemo-nmodl")
    7979         ,@(if has-exports? '(-check-imports -emit-exports nemo-nmodl.exports) '())
    8080         nemo-nmodl.scm)
     
    9494
    9595(if (file-exists? "nemo-matlab.scm")
    96     (compile -O -d2 -s -extension -o ,(dynld-name "nemo-matlab")
     96    (compile -d2 -s -extension -o ,(dynld-name "nemo-matlab")
    9797             ,@(if has-exports? '(-check-imports -emit-exports nemo-matlab.exports) '())
    9898             nemo-matlab.scm))
     
    113113
    114114
    115 (compile -O -d2 -s -o ,(dynld-name "nemo-hh")
     115(compile -d2 -s -o ,(dynld-name "nemo-hh")
    116116         ,@(if has-exports? '(-check-imports -emit-exports nemo-hh.exports) '())
    117117         extensions/nemo-hh.scm)
     
    134134(run (csi -qbs nemo-eggdoc.scm > nemo.html))
    135135
    136 (compile -O -d2 nemo.scm -lchicken)
     136(compile -d2 nemo.scm -lchicken)
    137137
    138138(install-program
Note: See TracChangeset for help on using the changeset viewer.