pprint* ( obj -- )
Factor handbook » Developer tools » The prettyprinter » Extending the prettyprinter » Prettyprinting more complex literals

Next:

pprint-object ( obj -- )

Vocabulary
prettyprint.custom

Inputs

obj

an object

Outputs
None

Generic word contract
Adds sections to the current block corresponding to the prettyprinted representation of the object.

Notes
This word should only be called from inside the with-pprint combinator.

See also
pprint, with-pprint

Definition

IN: prettyprint.custom

GENERIC: pprint* ( obj -- )

Methods

USING: kernel lists prettyprint.backend prettyprint.custom
prettyprint.sections ;

M: +nil+ pprint*
    <flow pprint-delims [ pprint-word ] bi@ block> ;


USING: alien alien.syntax combinators kernel math.parser
prettyprint.backend prettyprint.custom prettyprint.sections ;

M: alien pprint*
    {
        { [ dup expired? ] [ drop \ BAD-ALIEN pprint-word ] }
        {
            [ dup pinned-c-ptr? not ]
            [ drop "( displaced alien )" text ]
        }
        [ \ ALIEN: [ alien-address >hex text ] pprint-prefix ]
    } cond ;


USING: classes.algebra.private prettyprint.custom ;

M: anonymous-complement pprint* pprint-object ;


USING: classes.algebra.private prettyprint.custom ;

M: anonymous-intersection pprint* pprint-object ;


USING: classes.algebra.private prettyprint.custom ;

M: anonymous-predicate pprint* pprint-object ;


USING: classes.algebra.private prettyprint.custom ;

M: anonymous-union pprint* pprint-object ;


USING: bit-arrays prettyprint.custom ;

M: bit-array pprint* pprint-object ;


USING: bit-vectors prettyprint.custom ;

M: bit-vector pprint* pprint-object ;


USING: math.blas.matrices prettyprint.custom ;

M: blas-matrix-base pprint* pprint-object ;


USING: math.blas.vectors prettyprint.custom ;

M: blas-vector-base pprint* pprint-object ;


USING: prettyprint.custom
specialized-vectors.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-vector pprint* pprint-object ;


USING: byte-vectors prettyprint.custom ;

M: byte-vector pprint* pprint-object ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: char-32 pprint* pprint-object ;


USING: math prettyprint.custom ;

M: complex pprint* pprint-object ;


USING: kernel prettyprint.custom ;

M: composed pprint* pprint-object ;


USING: kernel lists make math namespaces prettyprint.backend
prettyprint.config prettyprint.custom prettyprint.sections
sequences ;

M: cons-state pprint*
    [
        <flow dup pprint-delims [
            pprint-word dup pprint-narrow? <inset [
                building get length-limit get
                [ [ ~quotation~ ] dip [ length ] curry compose ]
                dip [ < and ] curry compose
                [ uncons swap , ] while
            ] { } make [ pprint* ] each dup list?
            [ nil? [ "~more~" text ] unless ]
            [ "." text pprint* ] if block>
        ] dip pprint-word block>
    ] check-recursion ;


USING: kernel prettyprint.custom ;

M: curried pprint* pprint-object ;


USING: accessors decimals kernel math math.parser
prettyprint.backend prettyprint.custom prettyprint.sections
sequences strings ;

M: decimal pprint*
    \ DECIMAL: [
        [ mantissa>> abs number>string ] [
            exponent>> dup 0 >
            [ 48 <string> append ] [
                dup 0 < [
                    abs [ 48 pad-head ] [ cut-slice* ] bi
                    over empty?
                    [ nip "0." prepend ] [ "." glue ] if
                ] [ drop ] if
            ] if
        ] [ mantissa>> 0 < [ "-" prepend ] when ] tri text
    ] pprint-prefix ;


USING: dlists prettyprint.custom ;

M: dlist pprint* pprint-object ;


USING: alien alien.strings kernel prettyprint.backend
prettyprint.custom ;

M: dll pprint* dll-path dup "DLL\" " "\"" pprint-string ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: double-4 pprint* pprint-object ;


USING: compiler.cfg.registers compiler.prettyprint
prettyprint.custom ;

M: ds-loc pprint* \ D: pprint-loc ;


USING: effects prettyprint.custom prettyprint.sections ;

M: effect pprint* effect>string text ;


USING: kernel prettyprint.backend prettyprint.custom ;

M: f pprint* drop \ f pprint-word ;


USING: prettyprint.custom
specialized-vectors.instances.math.vectors.simd.float-4 ;

M: float-4-vector pprint* pprint-object ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: float-8 pprint* pprint-object ;


USING: combinators generic kernel math math.parser
prettyprint.backend prettyprint.custom prettyprint.sections ;

M: float pprint*
    {
        { [ dup 0/0. fp-bitwise= ] [ drop "0/0." text ] }
        { [ dup -0/0. fp-bitwise= ] [ drop "-0/0." text ] }
        {
            [ dup fp-nan? ]
            [
                \ NAN: [
                    [ fp-nan-payload ] [ fp-sign ] bi
                    [ 4503599627370495 bitxor 1 + neg ] when
                    >hex text
                ] pprint-prefix
            ]
        }
        { [ dup 1/0. = ] [ drop "1/0." text ] }
        { [ dup -1/0. = ] [ drop "-1/0." text ] }
        { [ dup 0.0 fp-bitwise= ] [ drop "0.0" text ] }
        { [ dup -0.0 fp-bitwise= ] [ drop "-0.0" text ] }
        [ M\ float pprint* (call-next-method) ]
    } cond ;


USING: prettyprint.backend prettyprint.custom ui.gadgets ;

M: gadget pprint* pprint-tuple ;


USING: prettyprint.custom
specialized-vectors.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-vector pprint* pprint-object ;


USING: hash-sets prettyprint.custom ;

M: hash-set pprint* pprint-object ;


USING: hashtables prettyprint.backend prettyprint.custom ;

M: hashtable pprint*
    [ pprint-object ] with-extra-nesting-level ;


USING: generic images images.viewer.prettyprint kernel
namespaces prettyprint.custom prettyprint.sections ;

M: image pprint*
    prettyprint-images? get
    [ <image-section> add-section ]
    [ M\ image pprint* (call-next-method) ] if ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: int-8 pprint* pprint-object ;


USING: accessors kernel locals.prettyprint locals.types
prettyprint.backend prettyprint.custom prettyprint.sections ;

M: lambda pprint*
    <flow \ [| pprint-word dup vars>> pprint-vars "|" text
    f <inset body>> pprint-elements block> \ ] pprint-word
    block> ;


USING: locals.prettyprint locals.types prettyprint.custom ;

M: let pprint* \ [let pprint-let ;


USING: linked-assocs.prettyprint prettyprint.backend
prettyprint.custom ;

M: linked-hash pprint*
    [ pprint-object ] with-extra-nesting-level ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: longlong-4 pprint* pprint-object ;


USING: classes.maybe prettyprint.custom ;

M: maybe pprint* pprint-object ;


USING: accessors mongodb.driver prettyprint.custom
prettyprint.sections ;

M: mdb-error pprint* msg>> text ;


USING: generic kernel prettyprint.backend prettyprint.custom
prettyprint.sections words ;

M: method pprint*
    <block
    [ \ M\ pprint-word "method-class" word-prop pprint* ]
    [ "method-generic" word-prop pprint-word ] bi block> ;


USING: accessors combinators kernel locals.prettyprint
locals.types math prettyprint.backend prettyprint.custom
prettyprint.sections sequences words ;

M: multi-def pprint*
    dup locals>> [ word? ] all? [
        <block \ :> pprint-word locals>> {
            [ length 1 > [ "(" text ] when ]
            [ [ pprint-var ] each ]
            [ length 1 > [ ")" text ] when ]
        } cleave block>
    ] [ pprint-tuple ] if ;


USING: multisets prettyprint.custom ;

M: multiset pprint* pprint-object ;


USING: nibble-arrays prettyprint.custom ;

M: nibble-array pprint* pprint-object ;


USING: kernel prettyprint.custom ;

M: object pprint* pprint-object ;


USING: accessors colors prettyprint.backend prettyprint.custom
prettyprint.sections ;

M: parsed-color pprint*
    \ COLOR: [ string>> text ] pprint-prefix ;


USING: prettyprint.backend prettyprint.custom words ;

M: parsing-word pprint*
    \ POSTPONE: [ pprint-word ] pprint-prefix ;


USING: accessors io.pathnames kernel prettyprint.backend
prettyprint.custom ;

M: pathname pprint* dup string>> "P\" " "\"" pprint-string ;


USING: persistent.hashtables prettyprint.custom ;

M: persistent-hash pprint* pprint-object ;


USING: persistent.vectors prettyprint.custom ;

M: persistent-vector pprint* pprint-object ;


USING: accessors alien.c-types alien.syntax prettyprint.backend
prettyprint.custom prettyprint.sections ;

M: pointer pprint*
    <flow \ pointer: pprint-word to>> pprint* block> ;


USING: combinators math math.parser namespaces
prettyprint.backend prettyprint.config prettyprint.custom
prettyprint.sections ;

M: real pprint*
    number-base get {
        { 10 [ number>string text ] }
        { 16 [ [ >hex ] "0x" pprint-prefixed-number ] }
        { 8 [ [ >oct ] "0o" pprint-prefixed-number ] }
        { 2 [ [ >bin ] "0b" pprint-prefixed-number ] }
        [ unsupported-number-base ]
    } case ;


USING: accessors kernel math.rectangles prettyprint.backend
prettyprint.custom ;

M: rect pprint*
    [
        \ RECT:
        [ [ loc>> ] [ dim>> ] bi [ pprint* ] bi@ ] pprint-prefix
    ] check-recursion ;


USING: accessors kernel make prettyprint.backend
prettyprint.custom regexp regexp.parser splitting ;

M: regexp pprint*
    [
        [
            [ raw>> "/" "\\/" replace "R/ " % % "/" % ]
            [ options>> options>string % ] bi
        ] "" make
    ] keep present-text ;


USING: compiler.cfg.registers compiler.prettyprint
prettyprint.custom ;

M: rs-loc pprint* \ R: pprint-loc ;


USING: kernel prettyprint.backend prettyprint.custom sbufs ;

M: sbuf pprint* dup "SBUF\" " "\"" pprint-string ;


USING: arrays.shaped prettyprint.custom ;

M: shaped-array pprint* pprint-object ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: short-16 pprint* pprint-object ;


USING: prettyprint.custom
specialized-vectors.instances.alien.c-types.short ;

M: short-vector pprint* pprint-object ;


USING: accessors compiler.tree.debugger effects
prettyprint.custom prettyprint.sections ;

M: shuffle-node pprint* effect>> effect>string text ;


USING: math.vectors.simd prettyprint.custom ;

M: simd-128 pprint* pprint-object ;


USING: accessors inspector.private prettyprint.custom
prettyprint.sections ;

M: slot-name pprint* name>> text ;


USING: prettyprint.backend prettyprint.custom specialized-arrays
specialized-arrays.prettyprint ;

M: specialized-array pprint*
    [ pprint-object ] [ pprint-direct-array ] pprint-c-object ;


USING: kernel prettyprint.backend prettyprint.custom strings ;

M: string pprint* dup "\"" "\"" pprint-string ;


USING: classes.struct classes.struct.prettyprint.private
prettyprint.backend prettyprint.custom ;

M: struct pprint*
    [ pprint-struct ] [ pprint-struct-pointer ] pprint-c-object
    ;


USING: prettyprint.custom tensors ;

M: tensor pprint* pprint-object ;


USING: kernel prettyprint.backend prettyprint.custom ;

M: tuple pprint* pprint-tuple ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: uchar-32 pprint* pprint-object ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: uint-8 pprint* pprint-object ;


USING: prettyprint.custom
specialized-vectors.instances.alien.c-types.uint ;

M: uint-vector pprint* pprint-object ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: ulonglong-4 pprint* pprint-object ;


USING: kernel present prettyprint.backend prettyprint.custom
prettyprint.sections urls ;

M: url pprint*
    \ URL" record-vocab dup present "URL\" " "\"" pprint-string
    ;


USING: math.vectors.simd.cords prettyprint.custom ;

M: ushort-16 pprint* pprint-object ;


USING: prettyprint.custom
specialized-vectors.instances.alien.c-types.ushort ;

M: ushort-vector pprint* pprint-object ;


USING: prettyprint.custom vlists ;

M: valist pprint* pprint-object ;


USING: prettyprint.custom vectors ;

M: vector pprint* pprint-object ;


USING: prettyprint.custom vlists ;

M: vlist pprint* pprint-object ;


USING: kernel prettyprint.backend prettyprint.custom words ;

M: word pprint*
    [ pprint-word ] [ ?start-group ] [ ?end-group ] tri ;


USING: continuations hash-sets.wrapped namespaces
prettyprint.config prettyprint.custom ;

M: wrapped-hash-set pprint*
    nesting-limit inc
    [ pprint-object ] [ nesting-limit dec ] finally ;


USING: continuations hashtables.wrapped namespaces
prettyprint.config prettyprint.custom ;

M: wrapped-hashtable pprint*
    nesting-limit inc
    [ pprint-object ] [ nesting-limit dec ] finally ;


USING: accessors combinators generic kernel prettyprint.backend
prettyprint.custom prettyprint.sections words ;

M: wrapper pprint*
    {
        { [ dup wrapped>> method? ] [ wrapped>> pprint* ] }
        {
            [ dup wrapped>> word? ]
            [
                <block \ \ pprint-word wrapped>> pprint-word
                block>
            ]
        }
        [ pprint-object ]
    } cond ;


USING: accessors images.viewer.prettyprint prettyprint.custom
prettyprint.sections xkcd ;

M: xkcd pprint* image>> <image-section> add-section ;