GitLab

at 2021-01-29T17:30:03-08:00

ldb prints out Unicode characters

When printing out a base-char, only the low 8 bits of the code were
used.  But with Unicode support, we need to take all the bits and
print them out.  For control codes we use the form "#\^x".  (Was
#\C-x, which isn't a valid supported character form.)  Ascii is
printed as normal "#\a", and everything else use uses "#\u+<hex>".

While we're at it, we also added special cases like #\Vt that are
listed in
https://cmucl.org/docs/cmu-user/html/Characters.html#Characters.

With this, we can print out all unicode characters in a form that can
be pasted back into lisp.

@@ -19,8 +19,6 @@ public domain.
  ## New in this release:
    * Known issues:
 -    * Building with gcc8 or later doesn't work with the default -O option. Use -O1 instead.  This shouldn't really impact overall speed much.
 -    * Added simple support to compile with clang instead, which works. (Use x86_linux_clang).
    * Feature enhancements
    * Changes
      * Update to ASDF 3.3.4
@@ -35,6 +33,12 @@ public domain.
      * ~~#80~~ Use ASDF to load contribs.  cmu-contribs still exists but does nothing.  The contrib names are the same, except it's best to use a keyword instead of a string.  So, `:contrib-demos` instead of `"contrib-demos"`.
      * ~~#81~~ Added contribs from Eric Marsden
      * ~~#82~~ Replace bc with expr in GNUMakefile
 +    * ~~#86~~ Building with gcc 8 and later works when using -O2 optimization
 +    * ~~#90~~ Some static symbols have been removed.  This probably makes the fasl files incompatible with older versions.
 +    * ~~#91~~ Loop destructuring no longer incorrectly signals an error
 +    * ~~#95~~ Disassembler syntax of x86 je and movzx is incorrect
 +    * ~~#98~~ fstpd is not an Intel instruction; disassemble as `fstp dword ptr [addr]`
 +    * ~~#100~~ ldb prints out unicode base-chars correctly instead of just the low 8 bits.
    * Other changes:
    * Improvements to the PCL implementation of CLOS:
    * Changes to building procedure:

@@ -212,12 +212,15 @@ static void
  brief_otherimm(lispobj obj)
+ {
      int type, c, idx;
 -    char buffer[10];
      type = TypeOf(obj);
      switch (type) {
        case type_BaseChar:
 -	  c = (obj >> 8) & 0xff;
 +          /*
 +           * A base-char should only be 16 bits long now.  But
 +           * sometimes it uses all 24.  So just grab all the bits.
 +           */
 +	  c = (obj >> 8) & 0xfffff;
  	  switch (c) {
  	    case '\0':
  		printf("#\\Null");
@@ -228,20 +231,35 @@ brief_otherimm(lispobj obj)
  	    case '\b':
  		printf("#\\Backspace");
  		break;
 +            case '\11':
 +                printf("#\\Tab");
 +                break;
 +            case '\13':
 +                printf("#\\Vt");
 +                break;
 +            case '\15':
 +                printf("#\\Return");
 +                break;
 +            case '\33':
 +                printf("#\\Escape");
 +                break;
 +            case '\40':
 +                printf("#\\Space");
 +                break;
  	    case '\177':
  		printf("#\\Delete");
  		break;
  	    default:
 -		strcpy(buffer, "#\\");
  		if (c >= 128) {
 -		    strcat(buffer, "m-");
 -		    c -= 128;
 -		}
 -		if (c < 32) {
 -		    strcat(buffer, "c-");
 -		    c += '@';
 -		}
 -		printf("%s%c", buffer, c);
 +                    /* Just print out the code value */
 +		    printf("#\\u+%04X", c);
 +		} else if (c < 32) {
 +                    /* Print it out as a control character */
 +                    printf("#\\^%c", c + '@');
 +		} else {
 +                    /* Plain ASCII character */
 +                    printf("#\\%c", c);
 +                }
  		break;
+ 	  }
  	  break;

@@ -655,7 +655,7 @@ asm_complex_double_float(lispobj* ptr, lispobj object, FILE* f)
  #endif
  void
 -init_asmtab()
 +init_asmtab(void)
+ {
      int k = 0;
@@ -674,6 +674,9 @@ init_asmtab()
          asmtab[type_OtherPointer | (k << 3)] = asm_other_pointer;
+     }
 +    asmtab[type_Ratio] = asm_boxed;
 +    asmtab[type_Complex] = asm_boxed;
 +    asmtab[type_SimpleArray] = asm_boxed;
      asmtab[type_SymbolHeader] = asm_boxed;
      asmtab[type_Fdefn] = asm_fdefn;
      asmtab[type_InstanceHeader] = asm_boxed;
@@ -683,6 +686,7 @@ init_asmtab()
      asmtab[type_BaseChar] = asm_immediate;
      /* Just use asm_boxed or have a special version for a value cell? */
      asmtab[type_ValueCellHeader] = asm_boxed;
++
+ }
  void

@@ -544,3 +544,15 @@
    ;; the correct value.
    (assert-false
     (funcall (compile nil '(lambda () (array-displacement "aaaaaaaa"))))))
++
 +(define-test issue.101
 +    (:tag :issues)
 +  ;; Verifies that we don't get unexpected overflow.  The actual value
 +  ;; is not really important.  The important part is no overflow is
 +  ;; signaled.
 +  ;;
 +  ;; See https://gitlab.common-lisp.net/cmucl/cmucl/-/issues/101 for
 +  ;; more details.
 +  (assert-equalp
 +   3.0380154777955097d205
 +   (expt 1.7976931348623157d308 0.6666)))

Raymond Toy pushed to branch native-image at cmucl / cmucl

Commits:

4 changed files:

Changes: