Changeset 30637 in project


Ignore:
Timestamp:
04/03/14 09:52:10 (7 years ago)
Author:
Ivan Raikov
Message:

npccl renamed to picnic

Location:
release/4
Files:
6 deleted
5 edited
6 copied
1 moved

Legend:

Unmodified
Added
Removed
  • release/4/digraph/trunk/digraph.scm

    r27208 r30637  
    22;;
    33;; Directed graph in adjacency list format.
    4 ;; Based on code from MLRISC
     4;; Based on code from MLRISC.
    55;;
    66;; Copyright 2007-2011 Ivan Raikov and the Okinawa Institute of Science and Technology.
  • release/4/ersatz/trunk/runtime.scm

    r29740 r30637  
    390390    (let ((args-len      (length args))
    391391          (arg-names-len (length arg-names)))
     392
     393      (if (< args-len arg-names-len)
     394          (error 'eval-macro "macro called with wrong number of arguments"
     395                 (list macro-name arg-names)
     396                 args))
    392397
    393398      (let* ((ctx  (push-frame ctx))
  • release/4/kd-tree/trunk/tests/run.scm

    r28200 r30637  
    33
    44(use typeclass kd-tree test srfi-1 random-mtzig)
    5 
    6 
    75
    86(define=> (make-consistency-tests <Point> <KdTree>)
     
    8987(define consistency-tests/3d (make-consistency-tests Point3d KdTree3d))
    9088(define consistency-tests/2d (make-consistency-tests Point2d KdTree2d))
     89(define elt< (lambda (i ai j bj) (< ai bj)))
    9190
    9291
     
    101100
    102101      (print "random coordinates generated...")
    103 
     102     
    104103      (let* (
    105104             (pts1 (let precur ((i (- n 1)) (ax '()))
  • release/4/nemo/trunk/nemo-nmodl.scm

    r30366 r30637  
    394394                                      (else
    395395                                       (nemo:error 'nemo:nmodl-reaction-keqs: "invalid transition equation "
    396                                                    (car tlst) " in state complex " n))
    397                                       (else (loop lst (cdr tlst)))))))
     396                                                   (car tlst) " in state complex " n)))
     397                               )))
    398398         (state-subs     (fold (lambda (s ax) (subst-extend s (nmodl-state-name n s) ax)) subst-empty state-list)))
    399399    ;; generate kinetic equations for each edge in the transitions system
  • release/4/picnic/trunk/expr-parser.scm

    r30536 r30637  
    6666      (cond  [(not arg) (error loc-str msg)]
    6767             [(lexical-token? arg)
    68               (npccl:error (conc "line " (source-location-line (lexical-token-source arg)) ": " msg) loc-str
     68              (picnic:error (conc "line " (source-location-line (lexical-token-source arg)) ": " msg) loc-str
    6969                     (conc (lexical-token-category arg)
    7070                           (if (lexical-token-value arg) (conc " " (lexical-token-value arg)) "")))]
    71              [else (npccl:error loc-str (conc msg arg))]
     71             [else (picnic:error loc-str (conc msg arg))]
    7272             ))))
    7373
     
    175175    column))
    176176
    177 (define (npccl:parse-string-expr s #!optional loc)
     177(define (picnic:parse-string-expr s #!optional loc)
    178178  (or (and (string? s) (string-null? s) '())
    179179      (let ((port
    180180             (cond ((string? s)  (open-input-string s))
    181181                   ((port? s)    s)
    182                    (else (error 'npccl:parse-string-expr "bad argument type: not a string or a port: " s)))))
     182                   (else (error 'picnic:parse-string-expr "bad argument type: not a string or a port: " s)))))
    183183        (expr-parser  (let ((ll (make-char-lexer port (make-parse-error loc) (make-source-location loc (port-line port) (port-column port) -1 -1))))
    184184                        (lambda ()
     
    219219 
    220220
    221 (define (npccl:parse-sym-expr lst #!optional loc)
     221(define (picnic:parse-sym-expr lst #!optional loc)
    222222  (let ((ret (cond ((number? lst)  lst)
    223223                   ((symbol? lst)  lst)
  • release/4/picnic/trunk/picnic-core.scm

    r30636 r30637  
    1818;;
    1919
    20 (module npccl-core
    21 
    22         (make-npccl-core npccl-verbose
    23          npccl:error npccl:warning npccl:version-string
    24          npccl:env-copy npccl:quantity?
    25          npccl:rhs? npccl:expr? npccl:subst-term npccl:binding? npccl:bind
    26          npccl:math-constants
    27          npccl-intern npccl-scoped eval-npccl-system-decls
     20(module picnic-core
     21
     22        (make-picnic-core picnic-verbose
     23         picnic:error picnic:warning picnic:version-string
     24         picnic:env-copy picnic:quantity?
     25         picnic:rhs? picnic:expr? picnic:subst-term picnic:binding? picnic:bind
     26         picnic:math-constants
     27         picnic-intern picnic-scoped eval-picnic-system-decls
    2828         CONST ASGN INITIAL PS SEGPS SET EXTERNAL PRIM LABEL
    2929
     
    3737                           datatype matchable vector-lib mpi
    3838                           varsubst digraph graph-bfs graph-cycles
    39                            mathh npccl-utils)
     39                           mathh picnic-utils)
    4040
    4141
     
    6666
    6767
    68         (define (npccl:warning x . rest)
     68        (define (picnic:warning x . rest)
    6969          (let loop ((port (open-output-string)) (objs (cons x rest)))
    7070            (if (null? objs)
     
    7272                  (newline port)
    7373                  (print-error-message (get-output-string port)
    74                                        (current-error-port) "npccl warning"))
     74                                       (current-error-port) "picnic warning"))
    7575                (begin (display (car objs) port)
    7676                       (display " " port)
     
    7878
    7979
    80         (define (npccl:error x . rest)
     80        (define (picnic:error x . rest)
    8181          (let ((port (open-output-string)))
    8282            (if (port? x)
     
    8989                  (begin
    9090                    (newline port)
    91                     (error 'npccl (get-output-string port)))
     91                    (error 'picnic (get-output-string port)))
    9292                  (let ((obj (car objs)))
    9393                    (if (procedure? obj)
     
    9999
    100100
    101         (include "npccl-version.scm")
    102 
    103 
    104         (define (npccl:version-string)
    105           (sprintf "NPCCL (http://wiki.call-cc.org/npccl) version ~A~%" npccl-version))
     101        (include "picnic-version.scm")
     102
     103
     104        (define (picnic:version-string)
     105          (sprintf "PICNIC (http://wiki.call-cc.org/picnic) version ~A~%" picnic-version))
    106106
    107107
     
    168168
    169169
    170         (define npccl:expr?   expr?)
    171         (define npccl:rhs?    rhs?)
    172 
    173 
    174         (define-datatype npccl:quantity npccl:quantity?
     170        (define picnic:expr?   expr?)
     171        (define picnic:rhs?    rhs?)
     172
     173
     174        (define-datatype picnic:quantity picnic:quantity?
    175175          (SYSNAME    (name symbol?) )
    176176          (LABEL      (v symbol?) )
     
    201201
    202202
    203         (define (npccl-intern sym)
     203        (define (picnic-intern sym)
    204204          (string->symbol (string-append "#" (symbol->string sym))))
    205205
    206206
    207         (define (npccl-scoped scope sym)
     207        (define (picnic-scoped scope sym)
    208208          (let ((ss (map ->string scope)))
    209209            (if (null? ss)
     
    232232
    233233
    234         (define (npccl:subst-term t subst k)
     234        (define (picnic:subst-term t subst k)
    235235          (assert (every symbol? (map car subst)))
    236236          (if (null? subst) t
     
    252252       
    253253
    254         (define (npccl:binding? t)
     254        (define (picnic:binding? t)
    255255          (and (list? t) (eq? 'let (car t)) (cdr t)))
    256256
    257         (define (npccl:bind ks vs e) `(let ,(zip ks vs) ,e))
    258 
    259         (define npccl:env-copy hash-table-copy)
    260 
    261         (define npccl:math-constants
     257        (define (picnic:bind ks vs e) `(let ,(zip ks vs) ,e))
     258
     259        (define picnic:env-copy hash-table-copy)
     260
     261        (define picnic:math-constants
    262262          (zip
    263263           `(E 1/E E^2 E^PI/4 LOG2E LOG10E LN2 LN3 LNPI LN10 1/LN2 1/LN10 PI PI/2
     
    272272
    273273
    274         (define (make-npccl-core . alst)
     274        (define (make-picnic-core . alst)
    275275
    276276          ;; floating point precision (single or double; default is double)
     
    447447          (define (add-constants! env)
    448448            (for-each (lambda (kv) (hash-table-set! env (car kv) (cadr kv)))
    449                       npccl:math-constants))
     449                      picnic:math-constants))
    450450
    451451
     
    512512              env))
    513513         
    514           (define (make-const-env npccl-env)
    515             (let ((env (npccl:env-copy base-env)))
    516               (hash-table-for-each npccl-env
     514          (define (make-const-env picnic-env)
     515            (let ((env (picnic:env-copy base-env)))
     516              (hash-table-for-each picnic-env
    517517                                   (lambda (sym en)
    518                                      (cond  ((npccl:quantity? en) 
    519                                              (cases npccl:quantity en
     518                                     (cond  ((picnic:quantity? en) 
     519                                             (cases picnic:quantity en
    520520                                                    (CONST (name value) 
    521521                                                           (hash-table-set! env name value))
     
    526526              env))
    527527
    528           (define (make-const-ftenv npccl-env)
     528          (define (make-const-ftenv picnic-env)
    529529            (let ((env (make-hash-table)))
    530530              (hash-table-for-each
    531                npccl-env
     531               picnic-env
    532532               (lambda (sym en)
    533                  (cond  ((npccl:quantity? en) 
    534                          (cases npccl:quantity en
     533                 (cond  ((picnic:quantity? en) 
     534                         (cases picnic:quantity en
    535535                                (CONST (name value) 
    536536                                       (hash-table-set! env name fptype))
     
    544544
    545545          (define (const-env-entry->value en)
    546             (cond  ((npccl:quantity? en) 
    547                     (cases npccl:quantity en
     546            (cond  ((picnic:quantity? en) 
     547                    (cases picnic:quantity en
    548548                           (CONST (name value)  value)
    549549                           (PRIM (name value)  value)
     
    555555
    556556          (define (system name)
    557             (let ((env  (npccl:env-copy base-env))
     557            (let ((env  (picnic:env-copy base-env))
    558558                  (name (if (symbol? name) name (string->symbol name))))
    559               (hash-table-set! env (npccl-intern 'dispatch)  (DISPATCH npccl-dispatch))
    560               (hash-table-set! env (npccl-intern 'name)      (SYSNAME name))
    561               (hash-table-set! env (npccl-intern 'exports)   (EXPORTS (list)))
    562               (hash-table-set! env (npccl-intern 'toplevel)  (COMPONENT 'toplevel 'toplevel (list) (list)))
     559              (hash-table-set! env (picnic-intern 'dispatch)  (DISPATCH picnic-dispatch))
     560              (hash-table-set! env (picnic-intern 'name)      (SYSNAME name))
     561              (hash-table-set! env (picnic-intern 'exports)   (EXPORTS (list)))
     562              (hash-table-set! env (picnic-intern 'toplevel)  (COMPONENT 'toplevel 'toplevel (list) (list)))
    563563              env))
    564564
    565565
    566           (define (add-external! npccl-env)
     566          (define (add-external! picnic-env)
    567567            (lambda (sym typ)
    568568              (match typ
    569569                     ('output
    570570                      (begin
    571                         (if (not (hash-table-exists? npccl-env sym))
    572                             (npccl:error 'add-external! ": exported quantity " sym " is not defined"))
    573                         (let* ((exports-sym   (npccl-intern 'exports))
    574                                (exports       (hash-table-ref npccl-env exports-sym)))
    575                           (cases npccl:quantity exports
    576                                  (EXPORTS (lst) (hash-table-set! npccl-env exports-sym (EXPORTS (append lst (list sym)))))
    577                                  (else  (npccl:error 'add-external! ": invalid exports entry " exports))))))
     571                        (if (not (hash-table-exists? picnic-env sym))
     572                            (picnic:error 'add-external! ": exported quantity " sym " is not defined"))
     573                        (let* ((exports-sym   (picnic-intern 'exports))
     574                               (exports       (hash-table-ref picnic-env exports-sym)))
     575                          (cases picnic:quantity exports
     576                                 (EXPORTS (lst) (hash-table-set! picnic-env exports-sym (EXPORTS (append lst (list sym)))))
     577                                 (else  (picnic:error 'add-external! ": invalid exports entry " exports))))))
    578578                     
    579579                     (('input sym lsym ns . rest)
     
    581581                            (lsym (or lsym sym))
    582582                            )
    583                         (if (hash-table-exists? npccl-env lsym)
    584                             (npccl:error 'add-import! ": import symbol " lsym " is already defined"))
     583                        (if (hash-table-exists? picnic-env lsym)
     584                            (picnic:error 'add-import! ": import symbol " lsym " is already defined"))
    585585                       
    586                         ((env-extend! npccl-env) lsym '(external) 'none
     586                        ((env-extend! picnic-env) lsym '(external) 'none
    587587                         `(name ,sym) `(namespace ,ns))))
    588588                     
     
    590590
    591591
    592           (define (make-symbol-check npccl-env)
     592          (define (make-symbol-check picnic-env)
    593593            (lambda (s loc . rest)
    594594              (let-optionals rest ((lbs '()))
    595595
    596                              (if (and (not (hash-table-exists? npccl-env s))
     596                             (if (and (not (hash-table-exists? picnic-env s))
    597597                                      (not (member s lbs)))
    598598                                 (begin
    599                                    (pp (hash-table->alist npccl-env))
    600                                    (npccl:error 'symbol-check: s " in the definition of " loc " is not defined")
     599                                   (pp (hash-table->alist picnic-env))
     600                                   (picnic:error 'symbol-check: s " in the definition of " loc " is not defined")
    601601                                   )
    602602                                 ))
     
    604604
    605605
    606           (define (make-arity-check npccl-env)
     606          (define (make-arity-check picnic-env)
    607607            (lambda (s args loc)
    608               (if (hash-table-exists? npccl-env s)
    609                   (let ((op (hash-table-ref npccl-env s)))
     608              (if (hash-table-exists? picnic-env s)
     609                  (let ((op (hash-table-ref picnic-env s)))
    610610                    (if (extended-procedure? op)
    611611                        (let* ((fd   (procedure-data op))
     
    613613                         
    614614                          (if (not (= (length fms) (length args)))
    615                               (npccl:error 'arity-check: "procedure " s
     615                              (picnic:error 'arity-check: "procedure " s
    616616                                          " called with incorrect number of arguments: "
    617617                                          args)))))
    618                   (npccl:error 'arity-check: "symbol " s "(" loc ")" " is not defined")
     618                  (picnic:error 'arity-check: "symbol " s "(" loc ")" " is not defined")
    619619                  )))
    620620
    621621
    622           (define (env-extend! npccl-env)
     622          (define (env-extend! picnic-env)
    623623            (lambda (name type initial . alst)
    624624              (let* ((sym (if (symbol? name) name (string->symbol name)))
    625                      (arity-check (make-arity-check npccl-env))
    626                      (symbol-check (make-symbol-check npccl-env))
     625                     (arity-check (make-arity-check picnic-env))
     626                     (symbol-check (make-symbol-check picnic-env))
    627627                     (normalize-expr (make-normalize-expr arity-check symbol-check)))
    628628
    629                 (if (hash-table-exists? npccl-env sym)
    630                     (npccl:error 'env-extend! ": quantity " sym " already defined")
     629                (if (hash-table-exists? picnic-env sym)
     630                    (picnic:error 'env-extend! ": quantity " sym " already defined")
    631631                    (match type
    632632
     
    634634                            (begin
    635635                              (if (not (symbol? initial))
    636                                   (npccl:error 'env-extend! ": label definitions require symbolic value"))
    637                               (hash-table-set! npccl-env sym (LABEL initial))))
     636                                  (picnic:error 'env-extend! ": label definitions require symbolic value"))
     637                              (hash-table-set! picnic-env sym (LABEL initial))))
    638638
    639639                           (('external) 
     
    644644                                     (x              (EXTERNAL name external-name ns))
    645645                                     )
    646                                 (hash-table-set! npccl-env sym x)
     646                                (hash-table-set! picnic-env sym x)
    647647                                )))
    648648                           
     
    652652                                            (extend-procedure initial rhs)
    653653                                            initial)))
    654                               (hash-table-set! npccl-env sym (PRIM name val))))
     654                              (hash-table-set! picnic-env sym (PRIM name val))))
    655655
    656656                           (('const)   
    657657                            (if (not (number? initial))
    658                                 (npccl:error 'env-extend! ": constant definitions require numeric value" name initial)
    659                                 (hash-table-set! npccl-env sym (CONST name initial))
     658                                (picnic:error 'env-extend! ": constant definitions require numeric value" name initial)
     659                                (hash-table-set! picnic-env sym (CONST name initial))
    660660                                ))
    661661
     
    666666                             
    667667                              (if (not (eq? initial 'none))
    668                                   (npccl:error 'env-extend!
     668                                  (picnic:error 'env-extend!
    669669                                              ": state function definitions must have initial value of '(none)"))
    670670                              (if (not rhs)
    671                                   (npccl:error 'env-extend! ": state function definitions require an equation"))
     671                                  (picnic:error 'env-extend! ": state function definitions require an equation"))
    672672                              (let ((expr1 (normalize-expr rhs (sprintf "assignment ~A" sym))))
    673                                 (hash-table-set! npccl-env sym (ASGN name 0.0 expr1)))
     673                                (hash-table-set! picnic-env sym (ASGN name 0.0 expr1)))
    674674                              ))
    675675
     
    680680                             
    681681                              (if (not (eq? initial 'none))
    682                                   (npccl:error 'env-extend!
     682                                  (picnic:error 'env-extend!
    683683                                              ": initial state function definitions must have initial value of '(none)"))
    684684                              (if (not rhs)
    685                                   (npccl:error 'env-extend! ": initial state function definitions require an equation"))
     685                                  (picnic:error 'env-extend! ": initial state function definitions require an equation"))
    686686                              (let ((expr1 (normalize-expr rhs (sprintf "initial ~A" sym))))
    687                                 (hash-table-set! npccl-env sym (INITIAL name expr1)))
     687                                (hash-table-set! picnic-env sym (INITIAL name expr1)))
    688688                              ))
    689689
     
    694694                                   (npts  (lookup-def 'npts alst))
    695695                                   (initial (lookup-def 'initial alst))
    696                                    (local-env (let ((local-env (hash-table-copy npccl-env)))
     696                                   (local-env (let ((local-env (hash-table-copy picnic-env)))
    697697                                                (hash-table-set! local-env name #t)
    698698                                                local-env))
     
    703703                              (if (not (and (symbol? gfun)
    704704                                            (procedure? (hash-table-ref local-env gfun))))
    705                                   (npccl:error 'env-extend! ": process definitions require a generating function"))
     705                                  (picnic:error 'env-extend! ": process definitions require a generating function"))
    706706
    707707                              (if (not npts)
    708                                   (npccl:error 'env-extend! ": process definitions require number of points"))
     708                                  (picnic:error 'env-extend! ": process definitions require number of points"))
    709709                             
    710710                              (let ((initial-expr
     
    713713                                                          (sprintf "initial value for process ~A" sym)))))
    714714
    715                                 (hash-table-set! npccl-env sym (PS name gfun initial-expr npts)))
     715                                (hash-table-set! picnic-env sym (PS name gfun initial-expr npts)))
    716716                             
    717717                              ))
     
    724724                                   (nsegpts (lookup-def 'nsegpts alst))
    725725                                   (initial (lookup-def 'initial alst))
    726                                    (local-env (let ((local-env (hash-table-copy npccl-env)))
     726                                   (local-env (let ((local-env (hash-table-copy picnic-env)))
    727727                                                (hash-table-set! local-env name #t)
    728728                                                local-env))
     
    733733                              (if (not (and (symbol? gfun)
    734734                                            (procedure? (hash-table-ref local-env gfun))))
    735                                   (npccl:error 'env-extend! ": segmented process definitions require a generating function"))
     735                                  (picnic:error 'env-extend! ": segmented process definitions require a generating function"))
    736736                             
    737737                              (if (not (and nsegs nsegpts))
    738                                   (npccl:error 'env-extend! ": segmented process definitions require number of points and number of segments"))
     738                                  (picnic:error 'env-extend! ": segmented process definitions require number of points and number of segments"))
    739739                             
    740740                              (let ((initial-expr
     
    743743                                                          (sprintf "initial value for process ~A" sym)))))
    744744
    745                                 (hash-table-set! npccl-env sym (SEGPS name gfun initial-expr nsegs nsegpts)))
     745                                (hash-table-set! picnic-env sym (SEGPS name gfun initial-expr nsegs nsegpts)))
    746746                             
    747747                              ))
     
    750750                            (let* (
    751751                                   (rhs  initial)
    752                                    (local-env (let ((local-env (hash-table-copy npccl-env)))
     752                                   (local-env (let ((local-env (hash-table-copy picnic-env)))
    753753                                                (hash-table-set! local-env name #t)
    754754                                                local-env))
    755755                                   (symbol-check (make-symbol-check local-env))
    756756                                   )
    757                               (hash-table-set! npccl-env sym (SET name rhs))
     757                              (hash-table-set! picnic-env sym (SET name rhs))
    758758                             
    759759                              ))
     
    762762                           (else
    763763                            (begin
    764                               (hash-table-set! npccl-env sym `(,type (name ,sym) . ,initial))))
     764                              (hash-table-set! picnic-env sym `(,type (name ,sym) . ,initial))))
    765765
    766766                           ))
     
    769769
    770770
    771           (define (infer npccl-env ftenv body)
     771          (define (infer picnic-env ftenv body)
    772772            (let recur ((expr body) (lb (list)))
    773773              (match expr
     
    779779                             (begin
    780780                               (if (not (equal? ct 'bool))
    781                                    (npccl:error 'infer "if condition type must be boolean"))
     781                                   (picnic:error 'infer "if condition type must be boolean"))
    782782                               (if (equal? tt et) tt
    783                                    (npccl:error 'infer "type mismatch in if statement: then = " tt
     783                                   (picnic:error 'infer "type mismatch in if statement: then = " tt
    784784                                               " else = " et))))))
    785785                     (('let bs e)
     
    790790                     
    791791                     ((s . es)   
    792                       (let* ((f    (hash-table-ref npccl-env s))
     792                      (let* ((f    (hash-table-ref picnic-env s))
    793793                             (lst  (procedure-data f)))
    794794                        (and lst
     
    813813         
    814814
    815           (define (defun! npccl-env)
     815          (define (defun! picnic-env)
    816816
    817817            (lambda (name formals body)
    818818
    819               (let* ((const-env (make-const-env npccl-env))
    820                      (local-env (let ((local-env (hash-table-copy npccl-env)))
     819              (let* ((const-env (make-const-env picnic-env))
     820                     (local-env (let ((local-env (hash-table-copy picnic-env)))
    821821                                  (for-each (lambda (s) (hash-table-set! local-env s #t))  formals)
    822822                                  local-env))
     
    841841
    842842                                                         ((and (symbol? s) (not (member s builtin-ops)) (not (member s lb)))
    843                                                           (npccl:error 'defun ": quantity " s " not defined"))
     843                                                          (picnic:error 'defun ": quantity " s " not defined"))
    844844
    845845                                                         (else (fold (enumconsts lb) ax es))
     
    853853
    854854                                                    ((and (symbol? s) (not (member s lb)))
    855                                                      (npccl:error 'defun ": quantity " s " not defined"))
     855                                                     (picnic:error 'defun ": quantity " s " not defined"))
    856856
    857857                                                    (else ax)))
     
    862862
    863863
    864                   (if (hash-table-exists? npccl-env sym)
    865                       (npccl:error 'defun! ": quantity " sym " already defined")
     864                  (if (hash-table-exists? picnic-env sym)
     865                      (picnic:error 'defun! ": quantity " sym " already defined")
    866866                      (let* (
    867867                             (body    (normalize-expr body (sprintf "function ~A" sym)))
     
    879879                             )
    880880
    881                         (let* ((ftenv  (make-const-ftenv npccl-env))
    882                                (rt     (infer npccl-env ftenv body))
     881                        (let* ((ftenv  (make-const-ftenv picnic-env))
     882                               (rt     (infer picnic-env ftenv body))
    883883                               (ftypes (filter-map (lambda (x)
    884884                                                     (or (and (hash-table-exists? ftenv x)
     
    891891                               )
    892892
    893                           (hash-table-set! npccl-env sym ef))
     893                          (hash-table-set! picnic-env sym ef))
    894894                        ))
    895895                  ))
     
    899899            (and (list? lst) (every symbol? lst)))
    900900
    901           (define (sysname npccl-env)
    902             (let ((v (hash-table-ref npccl-env (npccl-intern 'name))))
    903               (and v (cases npccl:quantity v
     901          (define (sysname picnic-env)
     902            (let ((v (hash-table-ref picnic-env (picnic-intern 'name))))
     903              (and v (cases picnic:quantity v
    904904                            (SYSNAME (name)  name)))
    905905              ))
    906906         
    907907
    908           (define (extended npccl-env)
     908          (define (extended picnic-env)
    909909            (filter-map (lambda (sym)
    910                           (let ((x (hash-table-ref npccl-env sym)))
    911                             (and (not (npccl:quantity? x)) (not (procedure? x))
     910                          (let ((x (hash-table-ref picnic-env sym)))
     911                            (and (not (picnic:quantity? x)) (not (procedure? x))
    912912                                 (match x
    913913                                        (((? symbol-list?) ('name name) . rest)  `(,sym ,x))
    914914                                        (else #f)))))
    915                         (hash-table-keys npccl-env)))
     915                        (hash-table-keys picnic-env)))
    916916         
    917917
    918           (define (extended-with-tag npccl-env tag)
     918          (define (extended-with-tag picnic-env tag)
    919919            (filter-map (lambda (sym)
    920                           (let ((x (hash-table-ref npccl-env sym)))
    921                             (and (not (npccl:quantity? x)) (not (procedure? x))
     920                          (let ((x (hash-table-ref picnic-env sym)))
     921                            (and (not (picnic:quantity? x)) (not (procedure? x))
    922922                                 (match x
    923923                                        (((? (lambda (x) (equal? x tag))) ('name name) . rest) 
    924924                                         `(,sym ,x))
    925925                                        (else #f)))))
    926                         (hash-table-keys npccl-env)))
     926                        (hash-table-keys picnic-env)))
    927927         
    928928
    929           (define (components npccl-env)
     929          (define (components picnic-env)
    930930            (filter-map (lambda (sym)
    931                           (let ((x (hash-table-ref npccl-env sym)))
    932                             (and (npccl:quantity? x)
    933                                  (cases npccl:quantity x
     931                          (let ((x (hash-table-ref picnic-env sym)))
     932                            (and (picnic:quantity? x)
     933                                 (cases picnic:quantity x
    934934                                        (COMPONENT (name type lst _)  `(,name ,type ,sym))
    935935                                        (else #f)))))
    936                         (hash-table-keys npccl-env)))
    937 
    938 
    939           (define (component-name npccl-env sym)
    940             (let ((x (hash-table-ref npccl-env sym)))
    941               (and (npccl:quantity? x)
    942                    (cases npccl:quantity x
     936                        (hash-table-keys picnic-env)))
     937
     938
     939          (define (component-name picnic-env sym)
     940            (let ((x (hash-table-ref picnic-env sym)))
     941              (and (picnic:quantity? x)
     942                   (cases picnic:quantity x
    943943                          (COMPONENT (name type lst _)  name)
    944944                          (else #f)))))
    945945
    946946
    947           (define (component-symbols npccl-env sym)
    948             (let ((x (hash-table-ref npccl-env sym)))
    949               (and (npccl:quantity? x)
    950                    (cases npccl:quantity x
     947          (define (component-symbols picnic-env sym)
     948            (let ((x (hash-table-ref picnic-env sym)))
     949              (and (picnic:quantity? x)
     950                   (cases picnic:quantity x
    951951                          (COMPONENT (name type lst _)  lst)
    952952                          (else #f)))))
    953953
    954954
    955           (define (component-scope-subst npccl-env sym)
    956             (let ((x (hash-table-ref npccl-env sym)))
    957               (and (npccl:quantity? x)
    958                    (cases npccl:quantity x
     955          (define (component-scope-subst picnic-env sym)
     956            (let ((x (hash-table-ref picnic-env sym)))
     957              (and (picnic:quantity? x)
     958                   (cases picnic:quantity x
    959959                          (COMPONENT (name type lst scope-subst)  scope-subst)
    960960                          (else #f)))))
    961961
    962962
    963           (define (component-exports npccl-env sym)
    964             (let ((all-exports (cases npccl:quantity (hash-table-ref npccl-env (npccl-intern 'exports))
     963          (define (component-exports picnic-env sym)
     964            (let ((all-exports (cases picnic:quantity (hash-table-ref picnic-env (picnic-intern 'exports))
    965965                                      (EXPORTS (lst)  lst))))
    966               (let ((x  (hash-table-ref npccl-env sym)))
    967                 (and (npccl:quantity? x)
    968                      (cases npccl:quantity x
     966              (let ((x  (hash-table-ref picnic-env sym)))
     967                (and (picnic:quantity? x)
     968                     (cases picnic:quantity x
    969969                            (COMPONENT (name type lst _) 
    970970                                       (begin
     
    972972                            (else #f))))))
    973973
    974           (define (component-imports npccl-env sym)
     974          (define (component-imports picnic-env sym)
    975975            (let ((all-imports
    976976                   (filter-map
    977977                    (lambda (sym)
    978                       (let ((x (hash-table-ref npccl-env sym)))
    979                         (and (npccl:quantity? x)
    980                              (cases npccl:quantity x
     978                      (let ((x (hash-table-ref picnic-env sym)))
     979                        (and (picnic:quantity? x)
     980                             (cases picnic:quantity x
    981981                                    (EXTERNAL (local-name name namespace)
    982982                                              (list local-name name namespace))
    983983                                    (else #f)))))
    984                     (hash-table-keys npccl-env))))
    985               (let ((x (hash-table-ref npccl-env sym)))
    986                 (and (npccl:quantity? x)
    987                      (cases npccl:quantity x
     984                    (hash-table-keys picnic-env))))
     985              (let ((x (hash-table-ref picnic-env sym)))
     986                (and (picnic:quantity? x)
     987                     (cases picnic:quantity x
    988988                            (COMPONENT (name type lst _) 
    989989                                       (begin
     
    992992
    993993
    994           (define (component-subcomps npccl-env sym)
     994          (define (component-subcomps picnic-env sym)
    995995
    996996            (define (component-type x)
    997               (cases npccl:quantity x
     997              (cases picnic:quantity x
    998998                     (COMPONENT (name type lst _) type)
    999999                     (else #f)))
    10001000
    10011001            (define (component-name x)
    1002               (cases npccl:quantity x
     1002              (cases picnic:quantity x
    10031003                     (COMPONENT (name type lst _) name)
    10041004                     (else #f)))
    10051005
    1006             (let ((en (hash-table-ref npccl-env sym)))
    1007               (and (npccl:quantity? en)
    1008                    (cases npccl:quantity en
     1006            (let ((en (hash-table-ref picnic-env sym)))
     1007              (and (picnic:quantity? en)
     1008                   (cases picnic:quantity en
    10091009                          (COMPONENT (name type lst _) 
    10101010                                     (filter-map
    10111011                                      (lambda (s)
    1012                                         (let ((x (hash-table-ref npccl-env s)))
     1012                                        (let ((x (hash-table-ref picnic-env s)))
    10131013                                          (and (iscomp? x) `(,(component-type x) ,(component-name x) ,s)))) lst))
    10141014                          (else #f)))))
    10151015
    1016           (define (component-extend! npccl-env)
     1016          (define (component-extend! picnic-env)
    10171017            (lambda (comp-name sym)
    1018               (let ((x (hash-table-ref npccl-env comp-name)))
    1019                 (if (npccl:quantity? x)
    1020                     (cases npccl:quantity x
     1018              (let ((x (hash-table-ref picnic-env comp-name)))
     1019                (if (picnic:quantity? x)
     1020                    (cases picnic:quantity x
    10211021                           (COMPONENT (name type lst scope-subst) 
    10221022                                      (let ((en1 (COMPONENT name type (delete-duplicates (append lst (list sym))) scope-subst)))
    1023                                         (hash-table-set! npccl-env comp-name en1)))
    1024                            (else (npccl:error 'component-extend! ": invalid component " comp-name)))
    1025                     (npccl:error 'component-extend! ": invalid component " comp-name)))))
    1026 
    1027 
    1028           (define (component-enumdeps npccl-env sym)
    1029 
    1030             (let ((x (hash-table-ref npccl-env sym)))
    1031               (and (npccl:quantity? x)
    1032                    (cases npccl:quantity x
     1023                                        (hash-table-set! picnic-env comp-name en1)))
     1024                           (else (picnic:error 'component-extend! ": invalid component " comp-name)))
     1025                    (picnic:error 'component-extend! ": invalid component " comp-name)))))
     1026
     1027
     1028          (define (component-enumdeps picnic-env sym)
     1029
     1030            (let ((x (hash-table-ref picnic-env sym)))
     1031              (and (picnic:quantity? x)
     1032                   (cases picnic:quantity x
    10331033
    10341034                          (COMPONENT
     
    10371037                            (append
    10381038                             (fold (lambda (qsym ax)
    1039                                      (let* ((q   (hash-table-ref npccl-env qsym))
     1039                                     (let* ((q   (hash-table-ref picnic-env qsym))
    10401040                                            (rhs (qrhs q)))
    10411041                                       (or (and rhs (append (enumdeps rhs) ax)) ax)))
    10421042                                   '()
    10431043                                   lst)
    1044                              (fold (lambda (x ax) (append (component-enumdeps npccl-env (third x)) ax))
     1044                             (fold (lambda (x ax) (append (component-enumdeps picnic-env (third x)) ax))
    10451045                                   '()
    1046                                    (component-subcomps npccl-env sym)))))
     1046                                   (component-subcomps picnic-env sym)))))
    10471047
    10481048                          (else #f)))))
    10491049
    10501050
    1051           (define (component-env npccl-env sym . syms)
     1051          (define (component-env picnic-env sym . syms)
    10521052            (fold
    10531053             (lambda (sym env)
    1054                (let ((comp (hash-table-ref npccl-env sym)))
    1055                  (and (npccl:quantity? comp)
    1056                       (cases npccl:quantity comp
     1054               (let ((comp (hash-table-ref picnic-env sym)))
     1055                 (and (picnic:quantity? comp)
     1056                      (cases picnic:quantity comp
    10571057                             (COMPONENT
    10581058                              (name type lst scope-subst) 
    1059                               (let* ((depnames (component-enumdeps npccl-env sym))
    1060                                      (subnames (map third (component-subcomps npccl-env sym)))
     1059                              (let* ((depnames (component-enumdeps picnic-env sym))
     1060                                     (subnames (map third (component-subcomps picnic-env sym)))
    10611061                                     (cnames   lst))
    10621062                                (let* ((syms (delete-duplicates (append depnames subnames cnames)))
    1063                                        (vals (map (lambda (x) (hash-table-ref npccl-env x)) syms)))
     1063                                       (vals (map (lambda (x) (hash-table-ref picnic-env x)) syms)))
    10641064                                  (for-each (lambda (s v) (hash-table-set! env s v))
    10651065                                            syms vals)
     
    10671067                                  )))
    10681068                             (else env)))))
    1069              (npccl:env-copy base-env)
     1069             (picnic:env-copy base-env)
    10701070             (cons sym syms)))
    10711071
    10721072
    1073           (define (exports npccl-env)
    1074             (cases npccl:quantity (hash-table-ref npccl-env (npccl-intern 'exports))
     1073          (define (exports picnic-env)
     1074            (cases picnic:quantity (hash-table-ref picnic-env (picnic-intern 'exports))
    10751075                   (EXPORTS (lst)  lst)))
    10761076
    10771077
    1078           (define (imports npccl-env)
     1078          (define (imports picnic-env)
    10791079            (filter-map (lambda (sym)
    1080                           (let ((x (hash-table-ref npccl-env sym)))
    1081                             (and (npccl:quantity? x)
    1082                                  (cases npccl:quantity x
     1080                          (let ((x (hash-table-ref picnic-env sym)))
     1081                            (and (picnic:quantity? x)
     1082                                 (cases picnic:quantity x
    10831083                                        (EXTERNAL (local-name name namespace)
    10841084                                                  (list local-name name namespace))
    10851085                                        (else #f)))))
    1086                         (hash-table-keys npccl-env)))
    1087 
    1088 
    1089 
    1090           (define (consts npccl-env)
     1086                        (hash-table-keys picnic-env)))
     1087
     1088
     1089
     1090          (define (consts picnic-env)
    10911091            (filter-map (lambda (sym)
    1092                           (let ((x (hash-table-ref npccl-env sym)))
    1093                             (and (npccl:quantity? x)
    1094                                  (cases npccl:quantity x
     1092                          (let ((x (hash-table-ref picnic-env sym)))
     1093                            (and (picnic:quantity? x)
     1094                                 (cases picnic:quantity x
    10951095                                        (CONST (name value)  (list name value) )
    10961096                                        (else #f)))))
    1097                         (hash-table-keys npccl-env)))
    1098 
    1099 
    1100 
    1101           (define (states npccl-env)
     1097                        (hash-table-keys picnic-env)))
     1098
     1099
     1100
     1101          (define (states picnic-env)
    11021102            (fold (lambda (sym ax)
    1103                     (let ((x (hash-table-ref npccl-env sym)))
    1104                       (if (npccl:quantity? x)
    1105                           (cases npccl:quantity x
     1103                    (let ((x (hash-table-ref picnic-env sym)))
     1104                      (if (picnic:quantity? x)
     1105                          (cases picnic:quantity x
    11061106                                 (PS (name gfun initial-expr npts)
    11071107                                     (cons name ax))
     
    11101110                                 (else ax))
    11111111                          ax)))
    1112                   (list) (hash-table-keys npccl-env)))
    1113 
    1114 
    1115           (define (processes npccl-env)
     1112                  (list) (hash-table-keys picnic-env)))
     1113
     1114
     1115          (define (processes picnic-env)
    11161116            (fold (lambda (sym ax)
    1117                     (let ((x (hash-table-ref npccl-env sym)))
    1118                       (if (npccl:quantity? x)
    1119                           (cases npccl:quantity x
     1117                    (let ((x (hash-table-ref picnic-env sym)))
     1118                      (if (picnic:quantity? x)
     1119                          (cases picnic:quantity x
    11201120                                 (PS (name gfun initial npts)
    11211121                                     (cons name ax))
    11221122                                 (else ax))
    11231123                          ax)))
    1124                   (list) (hash-table-keys npccl-env)))
    1125 
    1126           (define (segmented-processes npccl-env)
     1124                  (list) (hash-table-keys picnic-env)))
     1125
     1126          (define (segmented-processes picnic-env)
    11271127            (fold (lambda (sym ax)
    1128                     (let ((x (hash-table-ref npccl-env sym)))
    1129                       (if (npccl:quantity? x)
    1130                           (cases npccl:quantity x
     1128                    (let ((x (hash-table-ref picnic-env sym)))
     1129                      (if (picnic:quantity? x)
     1130                          (cases picnic:quantity x
    11311131                                 (SEGPS (name gfun initial-expr nsegs nsegpts)
    11321132                                        (cons name ax))
    11331133                                 (else ax))
    11341134                          ax)))
    1135                   (list) (hash-table-keys npccl-env)))
    1136 
    1137 
    1138           (define (initials npccl-env)
     1135                  (list) (hash-table-keys picnic-env)))
     1136
     1137
     1138          (define (initials picnic-env)
    11391139            (filter-map (lambda (sym)
    1140                           (let ((x (hash-table-ref npccl-env sym)))
    1141                             (and (npccl:quantity? x)
    1142                                  (cases npccl:quantity x
     1140                          (let ((x (hash-table-ref picnic-env sym)))
     1141                            (and (picnic:quantity? x)
     1142                                 (cases picnic:quantity x
    11431143                                        (INITIAL (name rhs) name)
    11441144                                        (else #f)))))
    1145                         (hash-table-keys npccl-env)))
    1146 
    1147           (define (asgns npccl-env)
     1145                        (hash-table-keys picnic-env)))
     1146
     1147          (define (asgns picnic-env)
    11481148            (filter-map (lambda (sym)
    1149                           (let ((x (hash-table-ref npccl-env sym)))
    1150                             (and (npccl:quantity? x)
    1151                                  (cases npccl:quantity x
     1149                          (let ((x (hash-table-ref picnic-env sym)))
     1150                            (and (picnic:quantity? x)
     1151                                 (cases picnic:quantity x
    11521152                                        (ASGN (name value rhs) name)
    11531153                                        (else #f)))))
    1154                         (hash-table-keys npccl-env)))
    1155 
    1156 
    1157           (define (defuns npccl-env)
     1154                        (hash-table-keys picnic-env)))
     1155
     1156
     1157          (define (defuns picnic-env)
    11581158            (filter-map (lambda (sym)
    1159                           (let ((x (hash-table-ref npccl-env sym)))
     1159                          (let ((x (hash-table-ref picnic-env sym)))
    11601160                            (and (procedure? x) (not (member sym builtin-ops)) (list sym x))))
    1161                         (hash-table-keys npccl-env)))
    1162 
    1163           (define (sets npccl-env)
     1161                        (hash-table-keys picnic-env)))
     1162
     1163          (define (sets picnic-env)
    11641164            (filter-map (lambda (sym)
    1165                           (let ((x (hash-table-ref npccl-env sym)))
    1166                             (and (npccl:quantity? x)
    1167                                  (cases npccl:quantity x
     1165                          (let ((x (hash-table-ref picnic-env sym)))
     1166                            (and (picnic:quantity? x)
     1167                                 (cases picnic:quantity x
    11681168                                        (SET (name rhs) name)
    11691169                                        (else #f)))))
    1170                         (hash-table-keys npccl-env)))
    1171 
    1172 
    1173           (define (toplevel npccl-env)
    1174             (cases npccl:quantity (hash-table-ref npccl-env (npccl-intern 'toplevel))
     1170                        (hash-table-keys picnic-env)))
     1171
     1172
     1173          (define (toplevel picnic-env)
     1174            (cases picnic:quantity (hash-table-ref picnic-env (picnic-intern 'toplevel))
    11751175                   (COMPONENT (name type lst _) `(,type ,lst))))
    11761176
     
    11921192                  ))
    11931193
    1194           (define (eval-const npccl-env expr qname)
    1195             (let* ((arity-check (make-arity-check npccl-env))
    1196                    (symbol-check (make-symbol-check npccl-env))
     1194          (define (eval-const picnic-env expr qname)
     1195            (let* ((arity-check (make-arity-check picnic-env))
     1196                   (symbol-check (make-symbol-check picnic-env))
    11971197                   (normalize-expr (make-normalize-expr arity-check symbol-check)))
    11981198              (let ((expr1 (normalize-expr expr (sprintf "constant ~A" qname)))
    1199                     (const-env (make-const-env npccl-env)))
     1199                    (const-env (make-const-env picnic-env)))
    12001200                (condition-case
    12011201                 (exact->inexact (eval-simple-expr const-env expr1))
     
    12051205
    12061206          (define (iscomp? x)
    1207             (cond ((npccl:quantity? x)
    1208                    (cases npccl:quantity x
     1207            (cond ((picnic:quantity? x)
     1208                   (cases picnic:quantity x
    12091209                          (COMPONENT  (name type lst _)  #t)
    12101210                          (else #f)))
     
    12121212
    12131213          (define (isdep? x)
    1214             (cond ((npccl:quantity? x)
    1215                    (cases npccl:quantity x
     1214            (cond ((picnic:quantity? x)
     1215                   (cases picnic:quantity x
    12161216                          (SET     (name rhs)  #t)
    12171217                          (ASGN    (name value rhs)  #t)
     
    12241224
    12251225          (define (isstate? x)
    1226             (and (npccl:quantity? x)
    1227                  (cases npccl:quantity x
     1226            (and (picnic:quantity? x)
     1227                 (cases picnic:quantity x
    12281228                        (PS        (name gfun initial npts)  #t)
    12291229                        (SEGPS     (name gfun initial-expr nsegs nsegpts) #t)
     
    12331233
    12341234          (define (qrhs x)
    1235             (and (npccl:quantity? x)
    1236                  (cases npccl:quantity x
     1235            (and (picnic:quantity? x)
     1236                 (cases picnic:quantity x
    12371237                        (SET (name rhs)   (match rhs
    12381238                                                 (('section v l) v)
     
    12461246
    12471247          ;; create equation dependency graph
    1248           (define (make-eqng npccl-env)
    1249             (let* ((sysname    (sysname npccl-env))
     1248          (define (make-eqng picnic-env)
     1249            (let* ((sysname    (sysname picnic-env))
    12501250                   (g          (make-digraph sysname (string-append (symbol->string sysname)
    12511251                                                                    " equation dependency graph")))
    12521252                   (add-node!  (g 'add-node!))
    12531253                   (add-edge!  (g 'add-edge!))
    1254                    (npccl-list  (filter (lambda (sym)
    1255                                          (let ((x (hash-table-ref npccl-env sym)))
     1254                   (picnic-list  (filter (lambda (sym)
     1255                                         (let ((x (hash-table-ref picnic-env sym)))
    12561256                                           (or (isstate? x) (isdep? x))))
    1257                                        (hash-table-keys npccl-env)))
    1258                    (npccl-ids      (list-tabulate (length npccl-list) identity))
    1259                    (name->id-map  (zip npccl-list npccl-ids)))
     1257                                       (hash-table-keys picnic-env)))
     1258                   (picnic-ids      (list-tabulate (length picnic-list) identity))
     1259                   (name->id-map  (zip picnic-list picnic-ids)))
    12601260
    12611261              (let-values (((state-list asgn-list) 
    1262                             (partition (lambda (sym) (isstate? (hash-table-ref npccl-env sym)))
    1263                                        npccl-list)))
     1262                            (partition (lambda (sym) (isstate? (hash-table-ref picnic-env sym)))
     1263                                       picnic-list)))
    12641264               
    12651265                ;; insert equations in the dependency graph
    1266                 (for-each (lambda (i n) (add-node! i n)) npccl-ids npccl-list)
     1266                (for-each (lambda (i n) (add-node! i n)) picnic-ids picnic-list)
    12671267                ;; create dependency edges in the graph
    12681268                (for-each (lambda (e)
     
    12711271                                                        (j (car (alist-ref nj name->id-map))))
    12721272                                                    (add-edge! (list i j (format "~A=>~A" ni nj))))))
    1273                                    (else (npccl:error 'make-eqng ": invalid edge " e))))
     1273                                   (else (picnic:error 'make-eqng ": invalid edge " e))))
    12741274                          (fold (lambda (qsym ax)
    1275                                   (let* ((q   (hash-table-ref npccl-env qsym))
     1275                                  (let* ((q   (hash-table-ref picnic-env qsym))
    12761276                                         (rhs (qrhs q)))
    12771277                                    (if rhs
    12781278                                        (let* ((deps (filter (if (isstate? q)
    12791279                                                                 (lambda (sym)
    1280                                                                    (if (not (hash-table-exists? npccl-env sym))
    1281                                                                        (npccl:error 'make-eqng ": undefined symbol " sym
     1280                                                                   (if (not (hash-table-exists? picnic-env sym))
     1281                                                                       (picnic:error 'make-eqng ": undefined symbol " sym
    12821282                                                                                   " in definition of quantity " qsym))
    1283                                                                    (and (let ((x (hash-table-ref npccl-env sym)))
     1283                                                                   (and (let ((x (hash-table-ref picnic-env sym)))
    12841284                                                                          (and (isdep? x) (not (eq? sym qsym))))))
    12851285                                                                 (lambda (sym)
    1286                                                                    (if (not (hash-table-exists? npccl-env sym))
    1287                                                                        (npccl:error 'make-eqng ": undefined symbol " sym
     1286                                                                   (if (not (hash-table-exists? picnic-env sym))
     1287                                                                       (picnic:error 'make-eqng ": undefined symbol " sym
    12881288                                                                                   " in definition of quantity " qsym))
    1289                                                                    (and (let ((x (hash-table-ref npccl-env sym)))
     1289                                                                   (and (let ((x (hash-table-ref picnic-env sym)))
    12901290                                                                          (isdep? x)))))
    12911291                                                             (enumdeps rhs)))
     
    12941294                                          (if edges (append edges ax) ax))
    12951295                                        ax)))
    1296                                 (list) npccl-list))
     1296                                (list) picnic-list))
    12971297                (let ((cycles (graph-cycles-fold g (lambda (cycle ax) (cons cycle ax)) (list))))
    12981298                  (if (null? cycles) (list state-list asgn-list g)
    1299                       (npccl:error 'make-eqng ": equation cycle detected: " (car cycles)))))))
     1299                      (picnic:error 'make-eqng ": equation cycle detected: " (car cycles)))))))
    13001300
    13011301
     
    13251325
    13261326
    1327           (define (make-eval-poset npccl-env eqposet)
     1327          (define (make-eval-poset picnic-env eqposet)
    13281328            (vector-map
    13291329             (lambda (i lst)
    13301330               (filter-map (lambda (id+sym)
    13311331                             (let* ((sym  (cdr id+sym))
    1332                                     (x    (hash-table-ref npccl-env sym)))
    1333                                (and (npccl:quantity? x)
    1334                                     (cases npccl:quantity x
     1332                                    (x    (hash-table-ref picnic-env sym)))
     1333                               (and (picnic:quantity? x)
     1334                                    (cases picnic:quantity x
    13351335                                           (PS  (name gfun initial npts)
    13361336                                                (list 'ps sym gfun))
     
    13431343                                           (SET  (name rhs)
    13441344                                                 (list 'set sym rhs))
    1345                                            (else npccl:error 'make-eval-poset
     1345                                           (else picnic:error 'make-eval-poset
    13461346                                                 ": invalid quantity in equation poset: " sym)))))
    13471347                           lst))
     
    13661366                                    (if (ee c) (ee t) (ee f))
    13671367                                    [var ()
    1368                                          (npccl:error 'eval-expr " exception in " expr ": \n"
     1368                                         (picnic:error 'eval-expr " exception in " expr ": \n"
    13691369                                                     (lambda () (print-error-message var)))])))
    13701370
     
    13771377                                               (vs  (lookup-def 'formals fd)))
    13781378                                          (if (not (= (length vs) (length args)))
    1379                                               (npccl:error 'eval-expr "procedure " s
     1379                                              (picnic:error 'eval-expr "procedure " s
    13801380                                                          " called with incorrect number of arguments"))))
    13811381                                    (apply op args))
    13821382                                  [var ()
    1383                                        (npccl:error 'eval-expr " exception in " expr ": \n"
     1383                                       (picnic:error 'eval-expr " exception in " expr ": \n"
    13841384                                                   (lambda () (print-error-message var)))]))
    13851385                               
     
    13871387                                 (cond ((symbol? s) (hash-table-ref env s))
    13881388                                       ((or (number? s) (string? s)) s)
    1389                                        (else (npccl:error 'eval-expr "unknown expression " s)))))))
     1389                                       (else (picnic:error 'eval-expr "unknown expression " s)))))))
    13901390                val)))
    13911391
    13921392
    1393           (define (eval-poset npccl-env eqposet)
    1394             (let ((my-env (hash-table-copy npccl-env)))
     1393          (define (eval-poset picnic-env eqposet)
     1394            (let ((my-env (hash-table-copy picnic-env)))
    13951395              (vector-for-each
    13961396               (lambda (i lst)
     
    13991399                    (let* ((sym  (cdr id+sym))
    14001400                           (x    (hash-table-ref my-env sym)))
    1401                       (and (npccl:quantity? x)
    1402                            (cases npccl:quantity x
     1401                      (and (picnic:quantity? x)
     1402                           (cases picnic:quantity x
    14031403                                  (SET  (name rhs)
    14041404                                         (let ((v ((eval-set-expr my-env) rhs)))
     
    14101410                                         (let ((v ((eval-expr my-env) rhs)))
    14111411                                           (hash-table-set! my-env sym v)))
    1412                                   (else npccl:error 'eval-poset
     1412                                  (else picnic:error 'eval-poset
    14131413                                        ": invalid quantity in equation poset: " sym)))))
    14141414                  lst))
     
    14181418
    14191419
    1420           (define (depgraph npccl-env)
    1421             (match-let (((state-list asgn-list g)  (make-eqng npccl-env))) g))
    1422 
    1423 
    1424           (define (depgraph* npccl-env)
    1425             (match-let (((state-list asgn-list g)  (make-eqng npccl-env)))
     1420          (define (depgraph picnic-env)
     1421            (match-let (((state-list asgn-list g)  (make-eqng picnic-env))) g))
     1422
     1423
     1424          (define (depgraph* picnic-env)
     1425            (match-let (((state-list asgn-list g)  (make-eqng picnic-env)))
    14261426                       (list state-list asgn-list g)))
    14271427
    14281428
    14291429          ;; Dispatcher
    1430           (define (npccl-dispatch selector)
     1430          (define (picnic-dispatch selector)
    14311431            (case selector
    14321432              ((add-external!)     add-external!)
     
    14401440              ((env-extend!)       env-extend!)
    14411441              ((subst-expr)        (subst-driver (lambda (x) (and (symbol? x) x))
    1442                                                  npccl:binding?
     1442                                                 picnic:binding?
    14431443                                                 identity
    1444                                                  npccl:bind
    1445                                                  npccl:subst-term))
     1444                                                 picnic:bind
     1445                                                 picnic:subst-term))
    14461446              ((make-const-env)      make-const-env)
    14471447              ((system)              system)
     
    14701470              ((extended-with-tag)   extended-with-tag)
    14711471              (else
    1472                (npccl:error 'selector ": unknown message " selector " sent to an npccl-core object"))))
    1473 
    1474           npccl-dispatch)
    1475 
    1476 
    1477         (define (eval-npccl-system-decls npccl-core name sys declarations #!key
     1472               (picnic:error 'selector ": unknown message " selector " sent to an picnic-core object"))))
     1473
     1474          picnic-dispatch)
     1475
     1476
     1477        (define (eval-picnic-system-decls picnic-core name sys declarations #!key
    14781478                                        (parse-expr (lambda (x . rest) x))
    14791479                                        (initial-scope #f))
    14801480
    1481           (define (eval-const x loc) (and x ((npccl-core 'eval-const) sys x loc)))
    1482           (define env-extend!  ((npccl-core 'env-extend!) sys))
    1483           (define (compute-qid id scope scope-subst) (or (and scope scope-subst (npccl-scoped scope id)) id))
     1481          (define (eval-const x loc) (and x ((picnic-core 'eval-const) sys x loc)))
     1482          (define env-extend!  ((picnic-core 'env-extend!) sys))
     1483          (define (compute-qid id scope scope-subst) (or (and scope scope-subst (picnic-scoped scope id)) id))
    14841484          (define (update-subst id qid subst) (if (equal? id qid) subst
    14851485                                                  (subst-extend id qid subst) ))
    14861486          (define subst-expr  (subst-driver (lambda (x) (and (symbol? x) x))
    1487                                             npccl:binding?
     1487                                            picnic:binding?
    14881488                                            identity
    1489                                             npccl:bind
    1490                                             npccl:subst-term))
     1489                                            picnic:bind
     1490                                            picnic:subst-term))
    14911491          (define (subst-set-expr x subst-env)
    14921492            (match x
     
    15041504                       (let ((qs (reverse qs)))
    15051505                         (if (not scope)
    1506                              (let* ((top-syms   ((npccl-core 'component-symbols ) sys (npccl-intern 'toplevel)))
     1506                             (let* ((top-syms   ((picnic-core 'component-symbols ) sys (picnic-intern 'toplevel)))
    15071507                                    (top-syms1  (append qs top-syms)))
    1508                                (hash-table-set! sys (npccl-intern 'toplevel) (COMPONENT 'toplevel 'toplevel top-syms1 '()))))
     1508                               (hash-table-set! sys (picnic-intern 'toplevel) (COMPONENT 'toplevel 'toplevel top-syms1 '()))))
    15091509                         (list qs scope-subst))
    15101510                       (let ((decl (car ds)))
     
    15301530                                                                    ((? symbol?)
    15311531                                                                     (let ((qid (compute-qid x scope scope-subst)))
    1532                                                                        (((npccl-core 'add-external!) sys) x `(input ,x ,qid #f))
     1532                                                                       (((picnic-core 'add-external!) sys) x `(input ,x ,qid #f))
    15331533                                                                       (list (cons qid qs) (update-subst x qid scope-subst))))
    15341534                                                                    ((id1 (or 'as 'AS) x1 . rest)
    15351535                                                                     (let ((qid (compute-qid x1 scope scope-subst)))
    1536                                                                        (((npccl-core 'add-external!) sys) x `(input ,id1 ,qid #f ,@rest))
     1536                                                                       (((picnic-core 'add-external!) sys) x `(input ,id1 ,qid #f ,@rest))
    15371537                                                                       (list (cons qid qs) (update-subst x1 qid scope-subst) )))
    15381538                                                                    ((id1 (or 'from 'FROM) n1 . rest)
    15391539                                                                     (let ((qid (compute-qid id1 scope scope-subst)))
    1540                                                                        (((npccl-core 'add-external!) sys) x `(input ,id1 ,qid ,n1 ,@rest))
     1540                                                                       (((picnic-core 'add-external!) sys) x `(input ,id1 ,qid ,n1 ,@rest))
    15411541                                                                       (list (cons qid qs) (update-subst id1 qid scope-subst) )))
    15421542                                                                    ((id1 (or 'as 'AS) x1 (or 'from 'FROM) n1 . rest)
    15431543                                                                     (let ((qid (compute-qid x1 scope scope-subst)))
    1544                                                                        (((npccl-core 'add-external!) sys) x `(input ,id1 ,qid ,n1 ,@rest))
     1544                                                                       (((picnic-core 'add-external!) sys) x `(input ,id1 ,qid ,n1 ,@rest))
    15451545                                                                       (list (cons qid qs) (update-subst x1 qid scope-subst) )))
    15461546                                                                    (((and id1 (? symbol?)) . rest)
    15471547                                                                     (let ((qid (compute-qid id1 scope scope-subst)))
    1548                                                                        (((npccl-core 'add-external!) sys) id1 `(input ,id1 ,qid #f ,@rest))
     1548                                                                       (((picnic-core 'add-external!) sys) id1 `(input ,id1 ,qid #f ,@rest))
    15491549                                                                       (list (cons qid qs) (update-subst id1 qid scope-subst))))
    15501550                                                                    )))
    15511551                                                (list qs scope-subst) lst))
    1552                                               (else (npccl:error 'eval-npccl-system-decls
     1552                                              (else (picnic:error 'eval-picnic-system-decls
    15531553                                                                "import statement must be of the form: "
    15541554                                                                "input id1 [as x1] ... "))))
     
    15571557                                       (((or 'output 'OUTPUT) . (and lst (? (lambda (x) (every symbol? x)))))
    15581558                                        (let ((lst1 (map (lambda (x) (compute-qid x scope scope-subst)) lst)))
    1559                                           (for-each (lambda (x) (((npccl-core 'add-external!) sys) x 'output)) lst1)
     1559                                          (for-each (lambda (x) (((picnic-core 'add-external!) sys) x 'output)) lst1)
    15601560                                          (list qs scope-subst)))
    15611561                                       
     
    16621662                                                                          scope-subst1))
    16631663                                               )
    1664                                           (((npccl-core 'defun!) sys) qid idlist qexpr)
     1664                                          (((picnic-core 'defun!) sys) qid idlist qexpr)
    16651665                                          (list (cons qid qs) (update-subst id qid scope-subst))))
    16661666                                       
     
    16681668                                       (((or 'prim 'PRIM) id value)
    16691669                                        (cond ((symbol? id)  (env-extend! id '(prim) value))
    1670                                               (else (npccl:error 'eval-npccl-system-decls
     1670                                              (else (picnic:error 'eval-picnic-system-decls
    16711671                                                                "prim declarations must be of the form: "
    16721672                                                                "prim id value"))))
     
    16741674                                       (((or 'sysname 'SYSNAME) name) 
    16751675                                        (if (symbol? name)
    1676                                             (hash-table-set! sys (npccl-intern 'name) (SYSNAME name))
    1677                                             (npccl:error 'eval-npccl-system-decls
     1676                                            (hash-table-set! sys (picnic-intern 'name) (SYSNAME name))
     1677                                            (picnic:error 'eval-picnic-system-decls
    16781678                                                        "system name must be a symbol")))
    16791679                                       
     
    16861686                                                                   (hash-table-ref
    16871687                                                                    sys (or (lookup-def name scope-subst) name)))))
    1688                                                        (or (and x (npccl:quantity? x)
    1689                                                                 (cases npccl:quantity x
     1688                                                       (or (and x (picnic:quantity? x)
     1689                                                                (cases picnic:quantity x
    16901690                                                                       (LABEL (v)  v)
    16911691                                                                       (else name)))
     
    17131713
    17141714                                        (if (and scope scope-subst)
    1715                                             (npccl:error 'eval-npccl-system-decls
     1715                                            (picnic:error 'eval-picnic-system-decls
    17161716                                                        "functor instantiation is not permitted in nested scope"))
    17171717
     
    17191719                                         (((functor-args functor-type functor-lst)
    17201720                                           (let ((x (hash-table-ref sys functor-name)))
    1721                                              (or (and (npccl:quantity? x)
    1722                                                       (cases npccl:quantity x
     1721                                             (or (and (picnic:quantity? x)
     1722                                                      (cases picnic:quantity x
    17231723                                                             (FUNCTOR (sym args typ lst)  (list args typ lst))
    17241724                                                             (else #f)))
    1725                                                  (npccl:error 'eval-npccl-system-decls! functor-name
     1725                                                 (picnic:error 'eval-picnic-system-decls! functor-name
    17261726                                                             " is not a functor" )))))
    17271727
    17281728                                         (if (not (<= (length functor-args)  (length args)))
    17291729                                             (let ((n (length args)))
    1730                                                (npccl:error 'eval-npccl-system-decls! "functor " functor-name
     1730                                               (picnic:error 'eval-picnic-system-decls! "functor " functor-name
    17311731                                                           " requires at least " (length functor-args) " arguments; "
    17321732                                                           args  " (total " n ") "
     
    17431743
    17441744                                            (if (not (every (lambda (x) (member x cqs1-names string=)) args-names))
    1745                                                 (npccl:error 'eval-npccl-system-decls! "functor " functor-name
     1745                                                (picnic:error 'eval-picnic-system-decls! "functor " functor-name
    17461746                                                            " instantiation did not include required arguments "
    17471747                                                            (filter (lambda (x) (not (member x cqs1-names string=))) args-names)))
     
    17621762
    17631763                                        (if (and scope scope-subst)
    1764                                             (npccl:error 'eval-npccl-system-decls
     1764                                            (picnic:error 'eval-picnic-system-decls
    17651765                                                        "functor declaration is not permitted in nested scope"))
    17661766                                        (let* ((sym      (string->symbol (->string name)))
    17671767                                               (functor  (FUNCTOR sym args typ lst)))
    17681768                                          (if (hash-table-exists? sys sym)
    1769                                               (npccl:error 'eval-npccl-system-decls! ": functor " sym " already defined"))
     1769                                              (picnic:error 'eval-picnic-system-decls! ": functor " sym " already defined"))
    17701770                                          (hash-table-set! sys sym functor)
    17711771                                          (list (cons sym qs) scope-subst)))
    17721772                                       
    17731773                                       (((or 'const 'CONST) . _)
    1774                                         (npccl:error 'eval-npccl-system-decls "declaration: " decl
     1774                                        (picnic:error 'eval-picnic-system-decls "declaration: " decl
    17751775                                                    ": constant declarations must be of the form: "
    17761776                                                    "const id = expr"))
    17771777                                       
    17781778                                       ((id '= . _)
    1779                                         (npccl:error 'eval-npccl-system-decls
     1779                                        (picnic:error 'eval-picnic-system-decls
    17801780                                                    "declaration " decl
    17811781                                                    ": algebraic equations must be of the form: "
     
    17831783                                       
    17841784                                       (((or 'reaction 'REACTION) . _)
    1785                                         (npccl:error 'eval-npccl-system-decls
     1785                                        (picnic:error 'eval-picnic-system-decls
    17861786                                                    "declaration " decl
    17871787                                                    ": reaction declarations must be of the form: "
     
    17891789                                       
    17901790                                       (((or 'fun 'FUN 'rel 'REL 'defun 'DEFUN) . _)
    1791                                         (npccl:error 'eval-npccl-system-decls "function declarations must be of the form: "
     1791                                        (picnic:error 'eval-picnic-system-decls "function declarations must be of the form: "
    17921792                                                    "fun id (arg1 arg2 ...) expr"))
    17931793                                       
    17941794                                       (((or 'prim 'PRIM) . _)
    1795                                         (npccl:error 'eval-npccl-system-decls "prim declarations must be of the form: "
     1795                                        (picnic:error 'eval-picnic-system-decls "prim declarations must be of the form: "
    17961796                                                    "prim id value"))
    17971797                                       
    17981798                                       (((or 'component 'COMPONENT) . _) 
    1799                                         (npccl:error 'eval-npccl-system-decls "invalid component: " decl))
     1799                                        (picnic:error 'eval-picnic-system-decls "invalid component: " decl))
    18001800                                       
    18011801                                       (((or 'sysname 'SYSNAME) . _) 
    1802                                         (npccl:error 'eval-npccl-system-decls "system name must be of the form (sysname name)"))
     1802                                        (picnic:error 'eval-picnic-system-decls "system name must be of the form (sysname name)"))
    18031803                                       
    18041804                                       ;; anything that doesn't match is possibly
    1805                                        ;; declarations recognized by the npccl extension
     1805                                       ;; declarations recognized by the picnic extension
    18061806                                       ;; modules
    18071807                                       (((and tag (? symbol?))  . lst)
     
    18251825
    18261826                                       (else
    1827                                         (npccl:error 'eval-npccl-system-decls
     1827                                        (picnic:error 'eval-picnic-system-decls
    18281828                                                    "declaration " decl ": "
    18291829                                                    "extended declarations must be of the form: "
  • release/4/picnic/trunk/picnic-utils.scm

    r30636 r30637  
    1818;;
    1919
    20 (module npccl-utils
     20(module picnic-utils
    2121
    2222        *
     
    5454                )
    5555
    56         (define npccl-verbose (make-parameter 0))
     56        (define picnic-verbose (make-parameter 0))
    5757
    5858
    5959        (define (d fstr . args)
    6060          (let ([port (current-error-port)])
    61             (if (positive? (npccl-verbose))
     61            (if (positive? (picnic-verbose))
    6262                (begin (apply fprintf port fstr args)
    6363                       (flush-output port) ) )))
  • release/4/picnic/trunk/picnic-version.scm

    r30636 r30637  
    11
    2 (define npccl-version "1.0")
     2(define picnic-version "1.0")
  • release/4/picnic/trunk/picnic.meta

    r30636 r30637  
    11; -*- Hen -*-
    22
    3 ((egg "npccl.egg") ; This should never change
     3((egg "picnic.egg") ; This should never change
    44
    55 ; List here all the files that should be bundled as part of your egg. 
    66
    7  (files "npccl.meta" "npccl.setup" "npccl-core.scm" "npccl.scm" "npccl-utils.scm"
     7 (files "picnic.meta" "picnic.setup" "picnic-core.scm" "picnic.scm" "picnic-utils.scm"
    88        "calc-parser.scm" "expr-parser.scm" "calc.grm"
    99        "tests"
     
    1919 (category parsing)
    2020
    21  ; A list of eggs npccl depends on.
     21 ; A list of eggs picnic depends on.
    2222
    2323 (needs make matchable (iexpr 1.8)
  • release/4/picnic/trunk/picnic.scm

    r30636 r30637  
    2323(import scheme chicken)
    2424
    25 (require-extension srfi-1 npccl-core)
     25(require-extension srfi-1 picnic-core)
    2626(require-library iexpr ersatz-lib)
    2727(require-extension datatype matchable lalr-driver getopt-long)
     
    3232(define rest cdr)
    3333
    34 (define-datatype npccl:model npccl:model?
     34(define-datatype picnic:model picnic:model?
    3535  (ModelSource (source-path string?) (in-format symbol?) (name symbol?)
    3636               (decls list?)
     
    6464(define (d fstr . args)
    6565  (let ([port (current-error-port)])
    66     (if (positive? (npccl-verbose))
     66    (if (positive? (picnic-verbose))
    6767        (begin (apply fprintf port fstr args)
    6868               (flush-output port) ) )))
     
    111111  `(
    112112    (input-format
    113      "specify input format (npccl, s-exp)"
     113     "specify input format (picnic, s-exp)"
    114114     (single-char #\i)
    115115     (value (required FORMAT)
     
    139139;; Use args:usage to generate a formatted list of options (from OPTS),
    140140;; suitable for embedding into help text.
    141 (define (npccl:usage)
     141(define (picnic:usage)
    142142  (print "Usage: " (car (argv)) "  <list of files to be processed> [options...] ")
    143143  (newline)
     
    156156
    157157
    158 (define (npccl-constructor name declarations parse-expr)
    159   (let* ((npccl   (make-npccl-core))
    160          (sys    ((npccl 'system) name))
    161          (qs     (eval-npccl-system-decls npccl name sys declarations parse-expr: parse-expr)))
    162     (list sys npccl qs)))
     158(define (picnic-constructor name declarations parse-expr)
     159  (let* ((picnic   (make-picnic-core))
     160         (sys    ((picnic 'system) name))
     161         (qs     (eval-picnic-system-decls picnic name sys declarations parse-expr: parse-expr)))
     162    (list sys picnic qs)))
    163163
    164164
    165165(define (sexp->model-decls doc)
    166166  (match doc
    167          ((or ('npccl-model model-name model-decls)
    168               ('npccl-model (model-name . model-decls)))
     167         ((or ('picnic-model model-name model-decls)
     168              ('picnic-model (model-name . model-decls)))
    169169          (list model-name model-decls))
    170          ((or ('npccl-model model-name model-decls user-templates)
    171               ('npccl-model (model-name . model-decls) user-templates))
     170         ((or ('picnic-model model-name model-decls user-templates)
     171              ('picnic-model (model-name . model-decls) user-templates))
    172172          (list model-name model-decls
    173173                (map (lambda (x) (list (->string (car x))
     
    182182
    183183(define (sexp-model-decls->model options model-name model-decls parse-expr)
    184   (let* ((model+npccl  (npccl-constructor model-name model-decls parse-expr))
    185          (model (first model+npccl))
    186          (npccl  (second model+npccl)))
    187       (if (assoc 'depgraph options) (print "dependency graph: " ((npccl 'depgraph*) model)))
    188       (if (assoc 'exports options)  (print "exports: " ((npccl 'exports) model)))       
    189       (if (assoc 'imports options)  (print "imports: " ((npccl 'imports) model)))
     184  (let* ((model+picnic  (picnic-constructor model-name model-decls parse-expr))
     185         (model (first model+picnic))
     186         (picnic  (second model+picnic)))
     187      (if (assoc 'depgraph options) (print "dependency graph: " ((picnic 'depgraph*) model)))
     188      (if (assoc 'exports options)  (print "exports: " ((picnic 'exports) model)))     
     189      (if (assoc 'imports options)  (print "imports: " ((picnic 'imports) model)))
    190190      (if (assoc 'components options)
    191191          (for-each (lambda (x)
    192                       (print "component " x ": " ((npccl 'component-exports) model (second x)))
    193                       (print "component " x " subcomponents: " ((npccl 'component-subcomps) model (second x))))
    194                     ((npccl 'components) model)))
     192                      (print "component " x ": " ((picnic 'component-exports) model (second x)))
     193                      (print "component " x " subcomponents: " ((picnic 'component-subcomps) model (second x))))
     194                    ((picnic 'components) model)))
    195195      model))
    196196         
     
    203203  (let ((tmpl (assoc (->string template-name) user-templates string=?)))
    204204    (if (not tmpl)
    205         (error 'npccl "template not found" template-name))
     205        (error 'picnic "template not found" template-name))
    206206    (let ((ctx (ersatz:init-context models: template-vars )))
    207207      (display
     
    240240  (case in-format
    241241   
    242     ((sexp npccl)
     242    ((sexp picnic)
    243243     (SingleModel source-path in-format model-name
    244244                  (sexp-model-decls->model
     
    246246                  model-decls user-templates iexpr parse-expr))
    247247   
    248     (else (error 'npccl "invalid input format"))
     248    (else (error 'picnic "invalid input format"))
    249249    ))
    250250       
    251251 
    252252(define (qrhs x)
    253   (and (npccl:quantity? x)
    254        (cases npccl:quantity x
     253  (and (picnic:quantity? x)
     254       (cases picnic:quantity x
    255255              (SET  (name rhs)  `(SetExpr . ,rhs))
    256256              (ASGN  (name value rhs)  rhs)
     
    259259
    260260(define (qinit x)
    261   (and (npccl:quantity? x)
    262        (cases npccl:quantity x
     261  (and (picnic:quantity? x)
     262       (cases picnic:quantity x
    263263              (PS (name gfun init npts)   init)
    264264              (SEGPS (name gfun init nsegs nsegpts)   init)
     
    266266
    267267(define (gfun x)
    268   (and (npccl:quantity? x)
    269        (cases npccl:quantity x
     268  (and (picnic:quantity? x)
     269       (cases picnic:quantity x
    270270              (PS (name gfun init npts)   gfun)
    271271              (SEGPS (name gfun init nsegs nsegpts)   gfun)
     
    277277  (define (cn x)   (first x))
    278278               
    279   (match-let ((($ npccl:quantity 'DISPATCH dis)
    280                (hash-table-ref sys (npccl-intern 'dispatch))))
     279  (match-let ((($ picnic:quantity 'DISPATCH dis)
     280               (hash-table-ref sys (picnic-intern 'dispatch))))
    281281                                   
    282282     (let* (
     
    455455(define prelude/scheme
    456456  `(#<<EOF
    457 (use srfi-1 mathh matchable kd-tree mpi npccl-utils)
     457(use srfi-1 mathh matchable kd-tree mpi picnic-utils)
    458458(include "mathh-constants")
    459 (define npccl-write-pointsets (make-parameter #f))
     459(define picnic-write-pointsets (make-parameter #f))
    460460(MPI:init)
    461461(if (member "-v" (command-line-arguments))
    462     (npccl-verbose 1))
     462    (picnic-verbose 1))
    463463(if (member "-w" (command-line-arguments))
    464     (npccl-write-pointsets #t))
     464    (picnic-write-pointsets #t))
    465465(define my-comm (MPI:get-comm-world))
    466466(define myrank  (MPI:comm-rank my-comm))
     
    531531(define (invoke-generator/scheme sys section-name section-processes layout-name)
    532532  (let* ((origin (gensym 'p))
    533          (make-section (cases npccl:quantity
     533         (make-section (cases picnic:quantity
    534534                              (hash-table-ref sys (first (car section-processes)))
    535535                              (PS (name gfun init npts)   
     
    540540                  (match-lambda
    541541                   ((process-name process-n)
    542                     (cases npccl:quantity (hash-table-ref sys process-name)
     542                    (cases picnic:quantity (hash-table-ref sys process-name)
    543543                           (PS (name gfun init npts)   
    544544                               (let ((init-var (and init (gensym 'v))))
     
    657657                         'pts)))
    658658                    )
    659                (if (npccl-write-pointsets)
     659               (if (picnic-write-pointsets)
    660660                   (write-pointset (quote ,(cn forest)) layout))
    661661               layout
     
    750750  (if (opt 'version)
    751751      (begin
    752         (print (npccl:version-string))
     752        (print (picnic:version-string))
    753753        (exit 0)))
    754754
    755755  (if (null? operands)
    756756
    757       (npccl:usage)
     757      (picnic:usage)
    758758
    759759      (let* (
     
    779779                               (lambda (x)
    780780                                 (case ($ x)
    781                                    ((npccl)        'npccl)
     781                                   ((picnic)        'picnic)
    782782                                   ((s-exp sexp)  'sexp)
    783                                    (else          (error 'npccl "unknown input format" x)))))
     783                                   (else          (error 'picnic "unknown input format" x)))))
    784784                              (else
    785785                               (case ((lambda (x) (or (not x) ($ x)))
    786786                                      (pathname-extension operand))
    787787                                 ((s-exp sexp)  'sexp)
    788                                  (else 'npccl)))))
     788                                 (else 'picnic)))))
    789789
    790790                       (doc.iexpr
    791791                        (case in-format
    792                           ((npccl
     792                          ((picnic
    793793                           (let ((content (read-sexp operand)))
    794                              (if (eq? content 'npccl-model)
     794                             (if (eq? content 'picnic-model)
    795795                                 (cons (read-iexpr operand) #t)
    796796                                 (cons content #f))))
    797797                          ((sexp) 
    798798                           (cons (read-sexp operand) #f))
    799                           (else    (error 'npccl "unknown input format" in-format))))
     799                          (else    (error 'picnic "unknown input format" in-format))))
    800800                       
    801801                       (dd          (if (opt 'debug)
    802802                                        (begin
    803803                                          ;;(pp (car doc.iexpr))
    804                                           (npccl-verbose 1))))
     804                                          (picnic-verbose 1))))
    805805                           
    806806                       (parse-expr
    807807                        (case in-format
    808808                          ((sexp)         identity)
    809                           ((npccl)              (if (cdr doc.iexpr)
     809                          ((picnic)              (if (cdr doc.iexpr)
    810810                                                   (lambda (x #!optional loc)
    811                                                      (if (string? x) (npccl:parse-string-expr x loc)
    812                                                          (npccl:parse-sym-expr x loc)))
    813                                                    npccl:parse-sym-expr))
    814                           (else    (error 'npccl "unknown input format" in-format))))
     811                                                     (if (string? x) (picnic:parse-string-expr x loc)
     812                                                         (picnic:parse-sym-expr x loc)))
     813                                                   picnic:parse-sym-expr))
     814                          (else    (error 'picnic "unknown input format" in-format))))
    815815
    816816                       
    817817                       (model-name.model-decls
    818818                        (case in-format
    819                           ((sexp npccl)         (sexp->model-decls (car doc.iexpr)))
    820                           (else    (error 'npccl "unknown input format" in-format))))
     819                          ((sexp picnic)         (sexp->model-decls (car doc.iexpr)))
     820                          (else    (error 'picnic "unknown input format" in-format))))
    821821                       
    822822                       )
     
    837837            (models
    838838             (map (lambda (x)
    839                     (cases npccl:model x
     839                    (cases picnic:model x
    840840                           
    841841                           (ModelSource (source-path in-format model-name model-decls user-templates iexpr parse-expr)
     
    855855           (lambda (model)
    856856             
    857              (cases npccl:model model
     857             (cases picnic:model model
    858858                   
    859859                    (SingleModel (source-path in-format model-name sys model-decls user-templates iexpr? parse-expr)
     
    874874
    875875                 
    876                   (else (error 'npccl "invalid model" model))))
     876                  (else (error 'picnic "invalid model" model))))
    877877
    878878           models))
  • release/4/picnic/trunk/picnic.setup

    r30636 r30637  
    44  (make-pathname #f fn ##sys#load-dynamic-extension))   
    55
    6 (include "npccl-version.scm")
     6(include "picnic-version.scm")
    77
    88(use make)
    99
    1010(make (
    11        ((dynld-name "npccl-utils") ("npccl-utils.scm")
    12         (compile -O -d2 -S -s npccl-utils.scm -j npccl-utils))
     11       ((dynld-name "picnic-utils") ("picnic-utils.scm")
     12        (compile -O -d2 -S -s picnic-utils.scm -j picnic-utils))
    1313
    14        ((dynld-name "npccl-utils.import") ("npccl-utils.import.scm")
    15         (compile -O2 -s npccl-utils.import.scm))
     14       ((dynld-name "picnic-utils.import") ("picnic-utils.import.scm")
     15        (compile -O2 -s picnic-utils.import.scm))
    1616       )
    17   (list (dynld-name "npccl-utils")
    18         (dynld-name "npccl-utils.import"))
     17  (list (dynld-name "picnic-utils")
     18        (dynld-name "picnic-utils.import"))
    1919  )
    2020
     
    2222
    2323  ; Name of your extension:
    24   'npccl-utils
     24  'picnic-utils
    2525
    2626  ; Files to install for your extension:
    27   `(,(dynld-name "npccl-utils") ,(dynld-name "npccl-utils.import"))
     27  `(,(dynld-name "picnic-utils") ,(dynld-name "picnic-utils.import"))
    2828
    2929  ; Assoc list with properties for your extension:
    30   `((version ,npccl-version)))
     30  `((version ,picnic-version)))
    3131
    3232(make (
    33        ((dynld-name "npccl-core") ("npccl-core.scm")
    34         (compile -O -d2 -S -s npccl-core.scm -j npccl-core))
     33       ((dynld-name "picnic-core") ("picnic-core.scm")
     34        (compile -O -d2 -S -s picnic-core.scm -j picnic-core))
    3535
    36        ((dynld-name "npccl-core.import") ("npccl-core.import.scm")
    37         (compile -O2 -s npccl-core.import.scm))
     36       ((dynld-name "picnic-core.import") ("picnic-core.import.scm")
     37        (compile -O2 -s picnic-core.import.scm))
    3838       )
    39   (list (dynld-name "npccl-core")
    40         (dynld-name "npccl-core.import"))
     39  (list (dynld-name "picnic-core")
     40        (dynld-name "picnic-core.import"))
    4141  )
    4242
     
    4444
    4545  ; Name of your extension:
    46   'npccl-core
     46  'picnic-core
    4747
    4848  ; Files to install for your extension:
    49   `(,(dynld-name "npccl-core") ,(dynld-name "npccl-core.import"))
     49  `(,(dynld-name "picnic-core") ,(dynld-name "picnic-core.import"))
    5050
    5151  ; Assoc list with properties for your extension:
    52   `((version ,npccl-version)))
     52  `((version ,picnic-version)))
    5353
    5454
     
    5757    (begin
    5858      (run (csi -s expr.grm))
    59       (compile -deploy -uses files -O -d2 npccl.scm
     59      (compile -deploy -uses files -O -d2 picnic.scm
    6060               -o ,(installation-prefix))
    6161      )
     
    6666              (run (csi -s expr.grm)))
    6767
    68              ("npccl" ("npccl.scm" "expr.grm.scm")
    69               (compile -O -d2 npccl.scm))
     68             ("picnic" ("picnic.scm" "expr.grm.scm")
     69              (compile -O -d2 picnic.scm))
    7070             )
    71         "npccl")
     71        "picnic")
    7272     
    7373      (install-program
    74        'npccl
     74       'picnic
    7575       
    76        `("npccl" )
     76       `("picnic" )
    7777       
    78        `((version ,npccl-version)
     78       `((version ,picnic-version)
    7979         ))
    8080      )
     
    9090
    9191(define SHARED-DIR (installation-chicken-home))
    92 (define NPCCL-DIR (make-pathname SHARED-DIR "npccl"))
     92(define PICNIC-DIR (make-pathname SHARED-DIR "picnic"))
    9393
    9494;; File Copy Operations
    9595
    96 (define (copy-file-to-npccl-dir fn)
     96(define (copy-file-to-picnic-dir fn)
    9797  (let ([fn (->string fn)])
    98     (copy-file fn (make-pathname NPCCL-DIR fn)) ) )
     98    (copy-file fn (make-pathname PICNIC-DIR fn)) ) )
    9999
Note: See TracChangeset for help on using the changeset viewer.