Igalia

July 09, 2019 04:00 AM · Bugallal Marchesi, 22, 1º 15008 A Coruña Galicia (Spain) Tel.: +34 981 913991 Fax: +34 981 913949

fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

fib
fib:
    push   %r12
    mov    %rdi,%rax
    push   %rbp
    mov    %rdi,%rbp
    push   %rbx
    cmp    $0x1,%rdi
    jle    finish
    mov    %rdi,%rbx
    xor    %r12d,%r12d
again:
    lea    -0x1(%rbx),%rdi
    sub    $0x2,%rbx
    callq  fib
    add    %rax,%r12
    cmp    $0x1,%rbx
    jg     again
    and    $0x1,%ebp
    lea    0x0(%rbp,%r12,1),%rax
finish:
    pop    %rbx
    pop    %rbp
    pop    %r12
    retq   

fib
fib:
   push   %r14
   push   %rbx
   push   %rax
   mov    %rdi,%rbx
   cmp    $0x2,%rdi
   jge    recurse
   mov    %rbx,%rax
   add    $0x8,%rsp
   pop    %rbx
   pop    %r14
   retq   
recurse:
   lea    -0x1(%rbx),%rdi
   callq  fib
   mov    %rax,%r14
   add    $0xfffffffffffffffe,%rbx
   mov    %rbx,%rdi
   callq  fib
   add    %r14,%rax
   add    $0x8,%rsp
   pop    %rbx
   pop    %r14
   retq   

fib
ocamlopt

fib_tramp:
    jmp    fib

fib:
    push   %rbp
    mov    %rsp,%rbp
    pushq  $0xa
    push   %rsi
    sub    $0x10,%rsp
    mov    %rsi,%rbx
    mov    0x2f(%rbx),%rdx
    mov    %rax,-0x18(%rbp)
    cmp    %rsp,(%rdx)
    jae    stack_check
post_stack_check:
    cmp    $0x2,%eax
    jl     return_n
    lea    -0x2(%rax),%edx
    mov    %rbx,%rsi
    mov    %rax,%r10
    mov    %rdx,%rax
    mov    %r10,%rdx
    callq  fib_tramp
    mov    -0x18(%rbp),%rbx
    sub    $0x1,%ebx
    mov    %rax,-0x20(%rbp)
    mov    -0x10(%rbp),%rsi
    mov    %rax,%r10
    mov    %rbx,%rax
    mov    %r10,%rbx
    callq  fib_tramp
return:
    mov    -0x20(%rbp),%rbx
    add    %ebx,%eax
    mov    %rbp,%rsp
    pop    %rbp
    retq   
return_n:
    jmp    return
stack_check:
    callq  WasmStackGuard
    mov    -0x10(%rbp),%rbx
    mov    -0x18(%rbp),%rax
    jmp    post_stack_check

fib
rsi
rax
fib
fib(n)
fib
fib(n+1) ~= φ * fib(n)
fib(n)
2 * fib(n+1)
fib(40)
n > 2
fib
(define (fib n)
  (if (< n 2)
      n
      (+ (fib (- n 1)) (fib (- n 2)))))

(define (fib n)
  (define (fib* n)
    (if (< n 2)
        n
        (+ (fib* (- n 1)) (fib* (- n 2)))))
  (fib* n))

fib
--program
--script
local function fib(n)
function fib(n)
fib
fib
fib
#f
fib

 #terminal {
  font: 20px/1 monospace;
  width: 340px;
  height: 5ch;
  background: black;
  color: green;
  overflow: hidden;
  white-space: break-spaces;
  word-break: break-all;
 }

body { width: 1300px; }
#logging {
  font: 20px/1 monospace;
  background: black;
  color: green;

  animation: resize 7s infinite alternate;

  white-space: break-spaces;
  word-break: break-all;
}
@keyframes resize {
  0% { width: 25%; }
  100% { width: 100%; }
}

Hash: 5a2a3d23f88174970ed8
Version: webpack 3.12.0
Time: 22209ms
                                         Asset       Size  Chunks                    Chunk Names
   pages/widgets/index.51838abe9967a9e0b5ff.js    1.17 kB      10  [emitted]         pages/widgets/index
                       img/icomoon.7f1da5a.svg    5.38 kB          [emitted]         
                     fonts/icomoon.2d429d6.ttf    2.41 kB          [emitted]         
           img/fontawesome-webfont.912ec66.svg     444 kB          [emitted]  [big]  
         fonts/fontawesome-webfont.b06871f.ttf     166 kB          [emitted]         
                        img/mobile.8891a7c.png    39.6 kB          [emitted]         
                   img/play_button.6b15900.png    14.8 kB          [emitted]         
                  img/keyword-back.f95e10a.jpg    43.4 kB          [emitted]         

.
.
.

.container {
  font: 20px/1 monospace;
  width: 5ch;
  white-space: break-spaces;
  border: 1px solid;
}

XX               XX

.container {
  font: 20px/1 monospace;
  width: 3ch;
  white-space: break-spaces;
  border: 1px solid;
}

 XX  XX

.container {
  font: 20px/1 monospace;
  width: 3ch;
  white-space: break-spaces;
  border: 1px solid;
}

XXX  XX

.container {
  font: 20px/1 monospace;
  width: 4ch;
  white-space: break-spaces;
  overflow-wrap: break-word;
  border: 1px solid;
}

XXXX  X

.container {
  font: 20px/1 monospace;
  width: 4ch;
  white-space: break-spaces;
  overflow-wrap: break-word;
  border: 1px solid;
}

XX X X

.container {
  font: 20px/1 monospace;
  width: 2ch;
  white-space: pre-wrap;
  border: 1px solid;
}

 XX

.container {
  font: 20px/1 monospace;
  width: 4ch;
  white-space: break-spaces;
  overflow-wrap: break-word;
  word-break: break-all;
  border: 1px solid;
}

XX X X

.container {
  font: 20px/1 monospace;
  width: 4ch;
  white-space: break-spaces;
  overflow-wrap: break-word;
  word-break: break-all;
  border: 1px solid;
}

X XX X

git
subtree
jit_ldr_f
float
jit_ldr_f
#guile
n
var a = 1n;
var b = a + 42n;
b << 64n
// result: 793209995169510719488n

+
-
*
/
%
<<
>>
**
typeof
typeof 1n
// result: 'bigint'

WebKitWebView* create_view (void)
{
    g_autoptr(WebKitWebContext) ctx = webkit_web_context_new ();
    /*
     * Configure "ctx" to your liking here. At the end of the scope (this
     * function), a g_object_unref(ctx) call will be automatically done.
     */
    return webkit_web_view_new_with_context (ctx);
}

gst-validate-launcher --sync -L

"qtdemux_change_edit_list":
{
    "pipeline": "appsrc ! qtdemux ! fakesink async=false",
    "config": [
        "%(validateflow)s, pad=fakesink0:sink, record-buffers=false"
    ],
    "scenarios": [
        {
            "name": "default",
            "actions": [
                "description, seek=false, handles-states=false",
                "appsrc-push, target-element-name=appsrc0, file-name=\"%(medias)s/fragments/car-20120827-85.mp4/init.mp4\"",
                "appsrc-push, target-element-name=appsrc0, file-name=\"%(medias)s/fragments/car-20120827-85.mp4/media1.mp4\"",
                "checkpoint, text=\"A moov with a different edit list is now pushed\"",
                "appsrc-push, target-element-name=appsrc0, file-name=\"%(medias)s/fragments/car-20120827-86.mp4/init.mp4\"",
                "appsrc-push, target-element-name=appsrc0, file-name=\"%(medias)s/fragments/car-20120827-86.mp4/media2.mp4\"",
                "stop"
            ]
        }
    ]
},

gst-validate-launcher -L |grep launch_pipeline

gst-validate-launcher -v validate.launch_pipeline.qtdemux_change_edit_list.default

$ gst-validate-launcher -m 'validate.launch_pipeline\.appsrc_.*'

Setting up GstValidate default tests

[3 / 3]  validate.launch_pipeline.appsrc_preroll_test.single_push: Passed

Statistics:
-----------                                                  

           Total time spent: 0:00:00.369149 seconds

           Passed: 3
           Failed: 0
           ---------
           Total: 3

~/gst-validate/gst-integration-testsuites/flow-expectations/qtdemux_change_edit_list/log-fakesink0:sink-expected

~/gst-validate/logs/qtdemux_change_edit_list/log-fakesink0:sink-actual

event stream-start: GstEventStreamStart, flags=(GstStreamFlags)GST_STREAM_FLAG_NONE, group-id=(uint)1;
event caps: video/x-h264, stream-format=(string)avc, alignment=(string)au, level=(string)2.1, profile=(string)main, codec_data=(buffer)014d4015ffe10016674d4015d901b1fe4e1000003e90000bb800f162e48001000468eb8f20, width=(int)426, height=(int)240, pixel-aspect-ratio=(fraction)1/1;
event segment: format=TIME, start=0:00:00.000000000, offset=0:00:00.000000000, stop=none, time=0:00:00.000000000, base=0:00:00.000000000, position=0:00:00.000000000
event tag: GstTagList-stream, taglist=(taglist)"taglist\,\ video-codec\=\(string\)\"H.264\\\ /\\\ AVC\"\;";
event tag: GstTagList-global, taglist=(taglist)"taglist\,\ datetime\=\(datetime\)2012-08-27T01:00:50Z\,\ container-format\=\(string\)\"ISO\\\ fMP4\"\;";
event tag: GstTagList-stream, taglist=(taglist)"taglist\,\ video-codec\=\(string\)\"H.264\\\ /\\\ AVC\"\;";
event caps: video/x-h264, stream-format=(string)avc, alignment=(string)au, level=(string)2.1, profile=(string)main, codec_data=(buffer)014d4015ffe10016674d4015d901b1fe4e1000003e90000bb800f162e48001000468eb8f20, width=(int)426, height=(int)240, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction)24000/1001;

CHECKPOINT: A moov with a different edit list is now pushed

event caps: video/x-h264, stream-format=(string)avc, alignment=(string)au, level=(string)3, profile=(string)main, codec_data=(buffer)014d401effe10016674d401ee8805017fcb0800001f480005dc0078b168901000468ebaf20, width=(int)640, height=(int)360, pixel-aspect-ratio=(fraction)1/1;
event segment: format=TIME, start=0:00:00.041711111, offset=0:00:00.000000000, stop=none, time=0:00:00.000000000, base=0:00:00.000000000, position=0:00:00.041711111
event tag: GstTagList-stream, taglist=(taglist)"taglist\,\ video-codec\=\(string\)\"H.264\\\ /\\\ AVC\"\;";
event tag: GstTagList-stream, taglist=(taglist)"taglist\,\ video-codec\=\(string\)\"H.264\\\ /\\\ AVC\"\;";
event caps: video/x-h264, stream-format=(string)avc, alignment=(string)au, level=(string)3, profile=(string)main, codec_data=(buffer)014d401effe10016674d401ee8805017fcb0800001f480005dc0078b168901000468ebaf20, width=(int)640, height=(int)360, pixel-aspect-ratio=(fraction)1/1, framerate=(fraction)24000/1001;

description, seek=false, handles-states=true
appsrc-push, target-element-name=appsrc0, file-name="raw_h264.0.mp4"
set-state, state=playing
appsrc-eos, target-element-name=appsrc0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
(define-language simple-language
  ;; values
  (v ::= number)

  ;; expressions
  (e ::= v
         (add e e)
         (if e e e))

  ;; evaluation contexts
  (E ::= hole
         (add E e)
         (add v E)
         (if E e e)))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
(define simple-red-v0
  (reduction-relation simple-language
    ;; machine states are just expressions "e"
    #:domain e

    (--> (add v_1 v_2)               ; pattern match
         ,(+ (term v_1) (term v_2))  ; result of reduction
         ;; this part is just the name of the rule
         addition)

    ;; two rules for conditionals, true and false
    (--> (if 1 e_t e_f) ; the _ is used to name pattern occurences, like e_t
         e_t
         if-true)

    (--> (if 0 e_t e_f) e_f
         if-false)))

1
2
(test-->> simple-red-v0 (term (add 3 4)) (term 7))
(test-->> simple-red-v0 (term (if 0 1 2)) (term 2))

1
2
3
4
> (test-->> simple-red-v0 (term (add (if 0 (add 3 4) (add 18 2)) 5)) (term 25))
FAILED ::2666
expected: 25
  actual: '(add (if 0 (add 3 4) (add 18 2)) 5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
(define simple-red-v1
  (reduction-relation simple-language
    #:domain e

    ;; note the in-hole that's added
    (--> (in-hole E (add v_1 v_2))
         (in-hole E ,(+ (term v_1) (term v_2)))
         addition)

    (--> (in-hole E (if 1 e_t e_f))
         (in-hole E e_t)
         if-true)

    (--> (in-hole E (if 0 e_t e_f))
         (in-hole E e_f)
         if-false)))

1
(test-->> simple-red-v0 (term (add (if 0 (add 3 4) (add 18 2)) 5)) (term 25))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
> (redex-match
   simple-language
   (in-hole E (if 0 e_1 e_2))
   (term (add (if 0 (add 3 4) (add 18 2)) 5)))
(list
 (match
  (list
   (bind 'E '(add hole 5))
   (bind 'e_1 '(add 3 4))
   (bind 'e_2 '(add 18 2)))))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
(define-language wasm-lang
  ;; basic types
  (t   ::= t-i t-f)
  (t-f ::= f32 f64)
  (t-i ::= i32 i64)

  ;; function types
  (tf  ::= (-> (t ...) (t ...)))

  ;; instructions (excerpted)
  (e-no-v ::= drop                      ; drop stack value
              select                    ; select 1 of 2 values
              (block tf e*)             ; control block
              (loop tf e*)              ; looping
              (if tf e* else e*)        ; conditional
              (br i)                    ; branch
              (br-if i)                 ; conditional branch
              (call i)                  ; call (function by index)
              (call cl)                 ; call (a closure)
              return                    ; return from function
              (get-local i)             ; get local variable
              (set-local i)             ; set local variable
              (label n {e*} e*)         ; branch target
              (local n {i (v ...)} e*)  ; function body instruction

              ...                       ; and so on
              )

  ;; instructions including constant values
  (e    ::= e-no-v
            (const t c))
  (c    ::= number)

  ;; sequences of instructions
  (e*   ::= ϵ
            (e e*))

  ;; various kinds of indices
  ((i j l k m n a o) integer)

  ;; modules and various other forms omitted
  )

1
2
3
(E ::= hole
       (v E)
       ((label n (e*) E) e*))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
(define wasm->
  (reduction-relation
   wasm-runtime-lang

   ;; the machine states
   #:domain (s F e* i)

   ;; a subset of reduction rules shown below

   ;; rule for binary operations, like add or sub
   (++> ;; this pattern matches two consts on the stack
        (in-hole E ((const t c_1) ((const t c_2) ((binop t) e*))))
        ;; the two consts are consumed, and replaced with a result const
        (in-hole E ((const t c) e*))
        ;; do-binop is a helper function for executing the operations
        (where c (do-binop binop t c_1 c_2))
        binop)

   ;; rule for just dropping a stack value
   (++> (in-hole E (v (drop e*))) ; consumes one v = (const t c)
        (in-hole E e*)            ; return remaining instructions e*
        drop)

   ;; more rules would go here
   ...

   ;; shorthand reduction definitions
   with
   [(--> (s F x i)
         (s F y i))
    (++> x y)]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
  ;; stores: contains modules, tables, memories
  (s       ::= {(inst modinst ...)
                (tab tabinst ...)
                (mem meminst ...)})

  ;; modules with a list of closures cl, global values v,
  ;; table index and memory index
  (modinst ::= {(func cl ...) (glob v ...)}
               ;; tab and mem are optional, hence all these cases
               {(func cl ...) (glob v ...) (tab i)}
               {(func cl ...) (glob v ...) (mem i)}
               {(func cl ...) (glob v ...) (tab i) (mem i)})

  ;; tables are lists of closures
  (tabinst ::= (cl ...))

  ;; memories are lists of bytes
  (meminst ::= (b ...))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
   ;; reductions for operating on memory
   (--> ;; one stack argument for address in memory, k
        (s F (in-hole E ((const i32 k) ((load t a o) e*))) i)

        ;; reintrepret bytes as the appropriately typed data
        (s F (in-hole E ((const t (const-reinterpret t (b ...))) e*)) i)

        ;; helper function fetches bytes from appropriate memory in s
        (where (b ...) (store-mem s i ,(+ (term k) (term o)) (sizeof t)))
        load)

   (--> ;; stack arguments for address k and new value c
        (s F (in-hole E ((const i32 k) ((const t c) ((store t a o) e*)))) i)

        ;; installs a new store s_new with the memory changed
        (s_new F (in-hole E e*) i)

        ;; the size in bytes for the given type
        (where n (sizeof t))

        ;; helper function modifies the memory in s, creating s_new
        (where s_new (store-mem= s i ,(+ (term k) (term o)) n (bits n t c)))
        store)

1
2
3
4
5
(==> ((label n {e*_0} (in-hole E ((br j) e*_1))) e*_2)
     (e*-append (in-hole E_v e*_0) e*_2)
     (where j (label-depth E))
     (where (E_outer E_v) (v-split E n))
     label-br)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
;; specifies how to reduce inside a local/frame instruction via a
;; recursive use of the reduction relation
(--> (s_0 F_0 (in-hole E ((local n {i F_1} e*_0) e*_2)) j)
     (s_1 F_0 (in-hole E ((local n {i F_2} e*_1) e*_2)) j)

     ;; apply --> recursively
     (where any_rec
            ,(apply-reduction-relation/tag-with-names
              wasm-> (term (s_0 F_1 e*_0 i))))

     ;; only apply this rule if this reduction was valid
     (side-condition (not (null? (term any_rec))))

     ;; the relation should be deterministic, so just take the first
     (where (string_tag (s_1 F_2 e*_1 i)) ,(first (term any_rec)))

     (computed-name (term string_tag)))

$ Tools/wpe/install-dependencies
$ Tools/Scripts/webkit-flatpak --wpe --wpe-extension=qt update
$ Tools/Scripts/build-webkit --wpe --cmakeargs="-DENABLE_WPE_QT=ON"

$ cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DENABLE_WPE_QT=ON -GNinja

PACKAGECONFIG_append_pn-wpewebkit = " qtwpe"

IMAGE_INSTALL_append = " wpewebkit-qtwpe-qml-plugin qt-wpe-simple-browser"

$ qt-wpe-simple-browser -platform wayland-egl https://wpewebkit.org

$ # stop weston
$ qt-wpe-simple-browser -platform eglfs https://wpewebkit.org

$ Tools/Scripts/run-qt-wpe-minibrowser -platform wayland <url>

import QtQuick 2.11
import QtQuick.Window 2.11
import org.wpewebkit.qtwpe 1.0

Window {
    id: main_window
    visible: true
    width: 1280
    height: 720
    title: qsTr("Hello WPE!")

    WPEView {
        url: initialUrl
        focus: true
        anchors.fill: parent
        onTitleChanged: {
            main_window.title = title;
        }
    }
}

	Chrome	Safari	Firefox
Experimental	M73	STP 80	Public support
Ship	M76	Unknown	Unknown

white-space	overflow-wrap	word-break
pre-wrap-008 pre-wrap-015 pre-wrap-016 break-spaces-003 break-spaces-004 break-spaces-005 break-spaces-006 break-spaces-007 break-spaces-008 break-spaces-009	break-word-004 break-word-005 break-word-006 break-word-007 break-word-008	break-all-010 break-all-011 break-all-012 break-all-013 break-all-014 break-all-015

.container { font: 20px/1 monospace; width: 2ch; white-space: pre-wrap; border: 1px solid; } XX	overflow-wrap: break-word	word-break: break-all

Planet Igalia

July 09, 2019

June 30, 2019

June 28, 2019

June 26, 2019

Web applications as first-class citizens

Leveraging existing projects

Development process

Wayland

AGL life cycle

AGL security model

Next steps

Try it now!

June 22, 2019

June 18, 2019

VK_EXT_host_query_reset

VK_EXT_discard_rectangles

VK_EXT_pipeline_creation_feedback

Conclusions

June 14, 2019

June 10, 2019

The feature

Use cases

A breaking opportunity exists after any white space character

Single leading white space

Breaking before the first white space

Consider previous breaking opportunities

Current status and support

Web Platform Tests

Implementation in several web engines

Chrome/Blink engine

Safari/WebKit engine

Conclusion

June 06, 2019

June 05, 2019

June 04, 2019

June 03, 2019

May 28, 2019

May 24, 2019

May 23, 2019

May 21, 2019

API & ABI Stability

Security

Content Filtering

It's All Text!

API Ergonomics

“Featurism” and “Embeddability”

May 14, 2019

How to get it

Writing tests

Running tests

Prerolling and appsrc

Documentation

May 06, 2019

April 29, 2019

Why Make an Executable Formal Semantics?

Redex & Reduction Semantics Basics

WebAssembly Design via Redex

Where to go from here

Appendix: More Redex Discussion

April 26, 2019

April 22, 2019

GStreamer Editing Services OpenTimelineIO support

April 14, 2019

April 08, 2019

Building WPEQt

Using a SVN/git WebKit snapshot

Using the WPEWebKit 2.24 source tarball

Using Yocto

Using WPEQt in your application

March 28, 2019

March 27, 2019

Dazzling New Address Bar

Redesigned Tabs Menu

Touchpad Gestures

Variable Fonts

Emoji

Improved Adaptive Mode

Reader Mode

JPEG 2000