cmucl-cvs

cmucl-cvs@common-lisp.net

2904 discussions

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-7-gb040afc
by Raymond Toy 21 Apr '12

21 Apr '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via b040afc230f3b1647620756c64f462d2570c2ae7 (commit) from a60274829b62c938292920f8f19b1c269240e8c2 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit b040afc230f3b1647620756c64f462d2570c2ae7 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Fri Apr 20 19:44:04 2012 -0700 Fix bug in handling the state BOM marker and also extend to work composing external formats. The state BOM marker also needs to indicate how long the BOM is. * src/code/stream.lisp * Handle the BOM marker correctly for composed format. * Handle the new values for the state BOM marker. * src/pcl/simple-streams/external-formats/utf-16.lisp * Change BOM state marker to +2 and -2 instead of 1 and 2 to indicate the length of the BOM. * src/pcl/simple-streams/external-formats/utf-32.lisp * Change BOM state marker to +4 and -4 instead of 1 and 2 to indicate the length of the BOM. diff --git a/src/code/stream.lisp b/src/code/stream.lisp index b5d34ad..0e27cba 100644 --- a/src/code/stream.lisp +++ b/src/code/stream.lisp @@ -850,39 +850,34 @@ (format t "octet-count = ~A~%" octet-count) (format t "in-index = ~A~%" (lisp-stream-in-index stream)) (format t "new state = ~S~%" new-state)) - ;; FIXME: We need to know if a BOM - ;; character was read so that we can - ;; adjust the octet count correctly - ;; because OCTETS-TO-CHAR does not include - ;; the BOM in the number of octets - ;; processed. To do that, we look into - ;; the state, and thus is very fragile. - ;; OCTETS-TO-CHAR and thus - ;; OCTETS-TO-STRING-COUNTED should - ;; indicate that instead of doing it here. + ;; FIXME: We need to know if a BOM character was read so that + ;; we can adjust the octet count correctly because + ;; OCTETS-TO-CHAR does not include the BOM in the number of + ;; octets processed. To do that, we look into the state, and + ;; thus is very fragile. OCTETS-TO-CHAR and thus + ;; OCTETS-TO-STRING-COUNTED should indicate that instead of + ;; doing it here. ;; - ;; So far, only utf-16 and utf-32 needs to - ;; handle BOM specially. In both of these - ;; cases, (cadr state) contains - ;; information about whether a BOM - ;; character was read or not. If a BOM - ;; was read, then we need to increment the - ;; octet-count by 2 for the BOM because - ;; OCTETS-TO-STRING doesn't include that - ;; in its count. + ;; So far, only utf-16 and utf-32 needs to handle BOM + ;; specially. In both of these cases, (cadr state) contains + ;; information about whether a BOM character was read or not. + ;; If a BOM was read, then we need to increment the + ;; octet-count by 2 for the BOM because OCTETS-TO-STRING + ;; doesn't include that in its count. + ;; + ;; But we could have a composing external format too, like + ;; :crlf, so what we really want to look at is the last + ;; element of the state. (when (and (consp (cdr new-state)) - (not (eql (cadr old-state) - (cadr new-state)))) + (not (eq (car (last old-state)) + (car (last new-state))))) #+debug-frc-sr (format t "state changed from ~S to ~S~%" old-state new-state) - ;; See utf-16.lisp and utf-32.lisp to - ;; see where the 1 and 2 come from. - ;; They indicate that the BOM was read, - ;; and whether we're reading big-endian - ;; or little-endian data. - (when (member (cadr new-state) '(1 2)) - ;; We read a BOM. - (incf octet-count 2))) + ;; See utf-16.lisp and utf-32.lisp. The part of the state + ;; we're interested in encodes the endianness and the size + ;; of the BOM in octets. + (incf octet-count (abs (the (integer -4 4) + (car (last new-state)))))) (when (> char-count 0) (setf (fd-stream-oc-state stream) new-state) (setf (lisp-stream-string-buffer-len stream) (1+ char-count)) diff --git a/src/pcl/simple-streams/external-formats/utf-16.lisp b/src/pcl/simple-streams/external-formats/utf-16.lisp index d25fdea..d197aea 100644 --- a/src/pcl/simple-streams/external-formats/utf-16.lisp +++ b/src/pcl/simple-streams/external-formats/utf-16.lisp @@ -13,15 +13,19 @@ ;; one here, anyway. This should be compatible with the Unicode spec. ;; The state is a cons. The car is an integer: -;; 0 = initial state, nothing has been read yet -;; 1 = BOM has been read, little-endian -;; 2 = BOM has been read, big-endian, or non-BOM char has been read +;; 0 = initial state, nothing has been read yet +;; -2 = BOM has been read, little-endian +;; 2 = BOM has been read, big-endian, or non-BOM char has been read +;; +;; The absolute value of car specifies the size of the BOM in octets. +;; This is used in stream.lisp to account for the BOM. ;; ;; The cdr is either NIL or a codepoint which is used for converting ;; surrogate pairs into codepoints. If the cdr is non-NIL, then it is ;; the leading (high) surrogate of a surrogate pair. ;; -;; When writing, never output a BOM. +;; +;; When writing, always output a BOM. (define-external-format :utf-16 (:size 2 :documentation "UTF-16 is a variable length character encoding for Unicode. On @@ -42,8 +46,10 @@ Unicode replacement character.") (let* ((,st (car ,state)) (,c1 ,input) (,c2 ,input) - (,code (if (oddp ,st) + (,code (if (minusp ,st) + ;; Little endian (+ (* 256 ,c2) ,c1) + ;; Big endian (including BOM, if any) (+ (* 256 ,c1) ,c2))) (,wd 2)) (declare (type (integer 0 2) ,st) @@ -79,9 +85,9 @@ Unicode replacement character.") (setf (cdr ,state) ,code) (let* ((,c1 ,input) (,c2 ,input) - (,next (if (oddp ,st) - (+ (* 256 ,c2) ,c1) - (+ (* 256 ,c1) ,c2)))) + (,next (if (plusp ,st) + (+ (* 256 ,c1) ,c2) + (+ (* 256 ,c2) ,c1)))) ;; We read the trailing surrogate, so clear the state. (setf (cdr ,state) nil) ;; If we don't have a high and low surrogate, @@ -99,8 +105,10 @@ Unicode replacement character.") (funcall ,error "High surrogate followed by #x~4,'0X instead of low surrogate" ,next ,wd)) +replacement-character-code+))))) ((and (= ,code #xFFFE) (zerop ,st)) - (setf (car ,state) 1) (go :again)) + ;; BOM for little-endian order + (setf (car ,state) -2) (go :again)) ((and (= ,code #xFEFF) (zerop ,st)) + ;; BOM for big-endian order (setf (car ,state) 2) (go :again)) ((= ,code #xFFFE) ;; Replace with REPLACEMENT CHARACTER. diff --git a/src/pcl/simple-streams/external-formats/utf-32.lisp b/src/pcl/simple-streams/external-formats/utf-32.lisp index 1fd3cf1..c0fa820 100644 --- a/src/pcl/simple-streams/external-formats/utf-32.lisp +++ b/src/pcl/simple-streams/external-formats/utf-32.lisp @@ -17,16 +17,18 @@ ;; ;; This is modeled after the utf-16 format. -;; make state an integer: -;; or (or state 0) to cope with NIL case -;; 0 = initial state, nothing has been read yet -;; 1 = BOM has been read, little-endian -;; 2 = BOM has been read, big-endian, or non-BOM char has been read +;; The state is a cons. The car is an integer: +;; 0 = initial state, nothing has been read yet +;; -4 = BOM has been read, little-endian +;; 4 = BOM has been read, big-endian, or non-BOM char has been read ;; -;; (oddp state) = little-endian -;; (evenp state) = big-endian +;; (minusp state) = little-endian +;; (plusp state) = big-endian ;; (zerop state) = #xFEFF/#xFFFE is BOM (to be skipped) ;; +;; The absolute value of the car specifies the size of the BOM in +;; octets. This is used in stream.lisp to account for the BOM. +;; (define-external-format :utf-32 (:size 4 :documentation "UTF-32 is a fixed-length character encoding of 4 octets for Unicode. On input, a byte-order mark is recognized. If no byte-order mark is @@ -40,21 +42,21 @@ Unicode replacement character.") (octets-to-code (state input unput error code c1 c2 c3 c4 st wd) `(block nil - (when (null ,state) (setf ,state 0)) + (when (null ,state) (setf ,state (cons 0 nil))) (tagbody :again - (let* ((,st ,state) + (let* ((,st (car ,state)) (,c1 ,input) (,c2 ,input) (,c3 ,input) (,c4 ,input) - (,code (if (oddp ,st) + (,code (if (minusp ,st) ;; Little-endian (+ ,c1 (ash ,c2 8) (ash ,c3 16) (ash ,c4 24)) - ;; Big-endian + ;; Big-endian (including BOM, if any) (+ (ash ,c1 24) (ash ,c2 16) (ash ,c3 8) @@ -80,11 +82,11 @@ Unicode replacement character.") +replacement-character-code+))) ((and (zerop ,st) (= ,code #xFFFE0000)) ;; BOM for little-endian - (setf ,state 1) + (setf (car ,state) -4) (go :again)) ((and (zerop ,st) (= ,code #xFEFF)) ;; BOM for big-endian - (setf ,state 2) + (setf (car ,state) 4) (go :again))) (return (values ,code ,wd)))))) ----------------------------------------------------------------------- Summary of changes: src/code/stream.lisp | 53 +++++++++----------- .../simple-streams/external-formats/utf-16.lisp | 26 ++++++--- .../simple-streams/external-formats/utf-32.lisp | 28 ++++++----- 3 files changed, 56 insertions(+), 51 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-6-ga602748
by Raymond Toy 20 Apr '12

20 Apr '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via a60274829b62c938292920f8f19b1c269240e8c2 (commit) via 99d39125b83f6173912c2a689e41db4c40096061 (commit) from 9f6b065b0ea4b758a00fa9b3b790b5ef2bb8853d (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a60274829b62c938292920f8f19b1c269240e8c2 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Fri Apr 20 09:35:43 2012 -0700 Oops. Debugging print accidentally left in. diff --git a/src/code/stream.lisp b/src/code/stream.lisp index a91d4d7..b5d34ad 100644 --- a/src/code/stream.lisp +++ b/src/code/stream.lisp @@ -829,6 +829,7 @@ (flet ((convert-buffer () (let ((old-state (fd-stream-oc-state stream))) + #+(or debug-frc-sr) (format t "old-state = ~S~%" old-state) (multiple-value-bind (s char-count octet-count new-state) (stream::octets-to-string-counted commit 99d39125b83f6173912c2a689e41db4c40096061 Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Fri Apr 20 09:34:48 2012 -0700 UTF-16-BE and UTF-16-LE external formats were returning the incorrect number of octets for surrogate pairs. Two was returned instead of four. * src/pcl/simple-streams/external-formats/utf-16-be.lisp: * src/pcl/simple-streams/external-formats/utf-16-le.lisp: * Return correct number of octets * src/general-info/release-20d.txt * Update. diff --git a/src/general-info/release-20d.txt b/src/general-info/release-20d.txt index 6bd52d5..fe9baaf 100644 --- a/src/general-info/release-20d.txt +++ b/src/general-info/release-20d.txt @@ -61,6 +61,9 @@ New in this release: double-float multiplier from being used when sse3 is available. * External format for UTF-32 was generating an error when converting octets to a string. + * The UTF-16-BE and UTF-16-LE external formats were returning the + incorrect number of octets when surrogates pairs were decoded. + This confuses the stream buffering code. * Trac Tickets: * #50: Print/read error with make-pathname. diff --git a/src/pcl/simple-streams/external-formats/utf-16-be.lisp b/src/pcl/simple-streams/external-formats/utf-16-be.lisp index e2780ea..948a24e 100644 --- a/src/pcl/simple-streams/external-formats/utf-16-be.lisp +++ b/src/pcl/simple-streams/external-formats/utf-16-be.lisp @@ -21,10 +21,11 @@ By default, illegal inputs and illegal outputs are replaced by the Unicode replacement character.") () - (octets-to-code (state input unput error c1 c2 code next) + (octets-to-code (state input unput error c1 c2 code wd next) `(let* ((,c1 ,input) (,c2 ,input) - (,code (+ (* 256 ,c1) ,c2))) + (,code (+ (* 256 ,c1) ,c2)) + (, wd 2)) (declare (type lisp:codepoint ,code)) (cond ((lisp::surrogatep ,code :low) ;; Got low surrogate. Combine with the state (high @@ -55,7 +56,8 @@ Unicode replacement character.") ;; unput 2 so it'll be read as another character ;; next time around? (if (lisp::surrogatep ,next :low) - (setq ,code (+ (ash (- ,code #xD800) 10) ,next #x2400)) + (setq ,code (+ (ash (- ,code #xD800) 10) ,next #x2400) + ,wd 4) (setf ,code (if ,error (locally @@ -74,7 +76,7 @@ Unicode replacement character.") (funcall ,error "BOM is not valid within a UTF-16 stream" ,code 2)) +replacement-character-code+))) (t (setf ,state nil))) - (values ,code 2))) + (values ,code ,wd))) (code-to-octets (code state output error c c1 c2) `(flet ((output (code) (,output (ldb (byte 8 8) code)) diff --git a/src/pcl/simple-streams/external-formats/utf-16-le.lisp b/src/pcl/simple-streams/external-formats/utf-16-le.lisp index b7faa28..6fb4b65 100644 --- a/src/pcl/simple-streams/external-formats/utf-16-le.lisp +++ b/src/pcl/simple-streams/external-formats/utf-16-le.lisp @@ -22,10 +22,11 @@ By default, illegal inputs and illegal outputs are replaced by the Unicode replacement character.") () - (octets-to-code (state input unput error c1 c2 code next) + (octets-to-code (state input unput error c1 c2 code wd next) `(let* ((,c1 ,input) (,c2 ,input) - (,code (+ (* 256 ,c2) ,c1))) + (,code (+ (* 256 ,c2) ,c1)) + (,wd 2)) (declare (type lisp:codepoint ,code)) (cond ((lisp::surrogatep ,code :low) ;; If possible combine this low surrogate with the @@ -56,14 +57,15 @@ Unicode replacement character.") ;; unput 2 so it'll be read as another character ;; next time around? (if (lisp::surrogatep ,next :low) - (setq ,code (+ (ash (- ,code #xD800) 10) ,next #x2400)) + (setq ,code (+ (ash (- ,code #xD800) 10) ,next #x2400) + ,wd 4) (setq ,code (if ,error (locally ;; No warnings about fdefinition (declare (optimize (ext:inhibit-warnings 3))) (funcall ,error "High surrogate followed by #x~4,'0X ~ - instead of low surrogate" ,next 2)) + instead of low surrogate" ,next ,wd)) +replacement-character-code+))))) ((= ,code #xFFFE) ;; replace with REPLACEMENT CHARACTER. @@ -75,7 +77,7 @@ Unicode replacement character.") (funcall ,error "BOM is not valid within a UTF-16 stream" ,code 2)) +replacement-character-code+))) (t (setf ,state nil))) - (values ,code 2))) + (values ,code ,wd))) (code-to-octets (code state output error c c1 c2) `(flet ((output (code) (,output (ldb (byte 8 0) code)) ----------------------------------------------------------------------- Summary of changes: src/code/stream.lisp | 1 + src/general-info/release-20d.txt | 3 +++ .../simple-streams/external-formats/utf-16-be.lisp | 10 ++++++---- .../simple-streams/external-formats/utf-16-le.lisp | 12 +++++++----- 4 files changed, 17 insertions(+), 9 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-4-g9f6b065
by Raymond Toy 20 Apr '12

20 Apr '12

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-3-gf3db74d
by Raymond Toy 19 Apr '12

19 Apr '12

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-2-g4c7f35d
by Raymond Toy 19 Apr '12

19 Apr '12

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-04-1-g236396d
by Raymond Toy 19 Apr '12

19 Apr '12

1 0

[cmucl-cvs] [git] CMU Common Lisp annotated tag snapshot-2012-04 created. snapshot-2012-04
by Raymond Toy 02 Apr '12

02 Apr '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The annotated tag, snapshot-2012-04 has been created at 87c20607e9bca49530f1d5d9d7604dad604ed0e7 (tag) tagging 3b9e43c17458d68ccf262530c34459eb007d58e1 (commit) replaces snapshot-2012-03 tagged by Raymond Toy on Sat Mar 31 13:14:23 2012 -0700 - Log ----------------------------------------------------------------- Snapshot 2012-04 Alex Goncharov (1): .gitignore: add build-* Raymond Toy (7): Set the generator costs for the complex multiply vops to be the number Oops. Long-standing bug that cmu-contribs was defined so it couldn't Add contrib for packed SSE2 operations. Update. Microoptimization: (logand x #xffffffff) can be just a register move Add comments, clean up code a little. Clarify a comment. ----------------------------------------------------------------------- hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-03-8-g3b9e43c
by Raymond Toy 30 Mar '12

30 Mar '12

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-03-7-g26419b3
by Raymond Toy 29 Mar '12

29 Mar '12

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "CMU Common Lisp". The branch, master has been updated via 26419b3ce542bb406d08585c051a1dc97ba208fb (commit) via bd6f5eacbbf9869a0a69973d50d14577c9bfb3cc (commit) from b08f245dbb9de963ca05142bb20d8fd27071a343 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 26419b3ce542bb406d08585c051a1dc97ba208fb Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Wed Mar 28 21:14:12 2012 -0700 Add comments, clean up code a little. diff --git a/src/contrib/packed-sse2/packed-sse2.lisp b/src/contrib/packed-sse2/packed-sse2.lisp index c3b9668..4d8de08 100644 --- a/src/contrib/packed-sse2/packed-sse2.lisp +++ b/src/contrib/packed-sse2/packed-sse2.lisp @@ -9,7 +9,11 @@ ;; SSE2 Packed operations. ;; -;; We use (complex double-float) variables to hold the packed values. +;; We use (complex double-float) variables to hold the packed values, +;; including packed doubles and packed singles. For convenience, use +;; sse2-setpd or sse2-setps to initialize the packed variables with +;; the given scalar values. To extract the individual components of +;; the packed values, use sse2-getpd or sse2-getps. (in-package #:vm) @@ -128,47 +132,51 @@ (declaim (inline sse2-shufpd sse2-shufps)) -(defun sse2-shufpd (x y i) +;; This needs better documentation. I (rtoy) can never remember what +;; the magic I values actually do. +(defun sse2-shufpd (dst src i) "Shuffle packed doubles in X and Y according to I." - (declare (type (complex double-float) x y) + (declare (type (complex double-float) dst src) (type (unsigned-byte 2) i)) (ecase i (0 - (%sse2-shufpd x y 0)) + (%sse2-shufpd dst src 0)) (1 - (%sse2-shufpd x y 1)) + (%sse2-shufpd dst src 1)) (2 - (%sse2-shufpd x y 2)) + (%sse2-shufpd dst src 2)) (3 - (%sse2-shufpd x y 3)))) + (%sse2-shufpd dst src 3)))) -(defun sse2-shufps (x y i) +(defun sse2-shufps (dst src i) "Shuffle packed singles in X and Y according to I." - (declare (type (complex double-float) x y) + (declare (type (complex double-float) dst src) (type (unsigned-byte 4) i)) (ecase i (0 - (%sse2-shufps x y 0)) + (%sse2-shufps dst src 0)) (1 - (%sse2-shufps x y 1)) + (%sse2-shufps dst src 1)) (2 - (%sse2-shufps x y 2)) + (%sse2-shufps dst src 2)) (3 - (%sse2-shufps x y 3)) + (%sse2-shufps dst src 3)) (4 - (%sse2-shufps x y 4)) + (%sse2-shufps dst src 4)) (5 - (%sse2-shufps x y 5)) + (%sse2-shufps dst src 5)) (6 - (%sse2-shufps x y 6)) + (%sse2-shufps dst src 6)) (7 - (%sse2-shufps x y 7)))) + (%sse2-shufps dst src 7)))) ;; x is the high part and y is the low part. (declaim (inline sse2-setpd sse2-getpd sse2-setps sse2-getps)) (defun sse2-setpd (x y) "Create a packed double with X in the high part and Y in the low part" (declare (type double-float x y)) + ;; Complex double-floats store the real part in the low half of the + ;; sse2 register. (complex y x)) (defun sse2-getpd (pd) @@ -185,7 +193,12 @@ (flet ((pack-singles-to-double (hi lo) (let ((hi-bits (single-float-bits hi)) (lo-bits (single-float-bits lo))) + ;; Create a double-float where the most significant 32 + ;; bits contain the hi float and the low 32-bits contain + ;; the low float. (make-double-float hi-bits (logand #xffffffff lo-bits))))) + ;; Pack the singles into a double and the pack the two doubles + ;; into a (complex double-float). (sse2-setpd (pack-singles-to-double x3 x2) (pack-singles-to-double x1 x0)))) commit bd6f5eacbbf9869a0a69973d50d14577c9bfb3cc Author: Raymond Toy <toy.raymond(a)gmail.com> Date: Wed Mar 28 21:11:18 2012 -0700 Microoptimization: (logand x #xffffffff) can be just a register move without and'ing. (If x is a signed-byte 32.) diff --git a/src/compiler/x86/arith.lisp b/src/compiler/x86/arith.lisp index 96b480e..69d3426 100644 --- a/src/compiler/x86/arith.lisp +++ b/src/compiler/x86/arith.lisp @@ -348,8 +348,18 @@ (define-vop (fast-logand-c/signed-unsigned=>unsigned fast-logand-c/unsigned=>unsigned) (:args (x :target r :scs (signed-reg signed-stack))) - (:arg-types signed-num (:constant (unsigned-byte 32)))) - + (:arg-types signed-num (:constant (unsigned-byte 32))) + (:generator 1 + (cond ((and (= y #xffffffff) + (sc-is x signed-reg)) + ;; Just move x to the result if we're and'ing with all + ;; ones, which doesn't change the bits. + (unless (location= x r) + (move r x))) + (t + (move r x) + (inst and r y))))) + (define-vop (fast-logand/unsigned-signed=>unsigned fast-logand/unsigned=>unsigned) (:args (x :target r :scs (unsigned-reg) ----------------------------------------------------------------------- Summary of changes: src/compiler/x86/arith.lisp | 14 +++++++- src/contrib/packed-sse2/packed-sse2.lisp | 47 +++++++++++++++++++----------- 2 files changed, 42 insertions(+), 19 deletions(-) hooks/post-receive -- CMU Common Lisp

1 0

[cmucl-cvs] [git] CMU Common Lisp branch master updated. snapshot-2012-03-5-gb08f245
by Raymond Toy 28 Mar '12

28 Mar '12

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

cmucl-cvs