suzanne.soy/whalesong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge commit 'origin/master'

Browse Source
This commit is contained in:
Danny Yoo 2011-07-12 15:27:23 -04:00
commit 70187d3b26
6 changed files with 136 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
js-assembler/package.rkt
View File

@ -11,6 +11,7 @@
"../parser/parse-bytecode.rkt"
racket/match
racket/list
racket/promise
(prefix-in query: "../lang/js/query.rkt")
(planet dyoo/closure-compile:1:1)
(prefix-in runtime: "get-runtime.rkt")
@ -301,22 +302,25 @@ MACHINE.modules[~s] =
(define (compress x)
(if (current-compress-javascript?)
(closure-compile x)
x))
(cond [(current-compress-javascript?)
(log-debug "compressing javascript...")
(closure-compile x)]
[else
(log-debug "not compressing javascript...")
x]))
(define *the-runtime*
(let ([buffer (open-output-string)])
(write-runtime buffer)
(compress
(get-output-string buffer))))
(delay (let ([buffer (open-output-string)])
(write-runtime buffer)
(compress
(get-output-string buffer)))))
;; get-runtime: -> string
(define (get-runtime)
*the-runtime*)
(force *the-runtime*))

101
scribblings/manual.scrbl
View File

@ -153,7 +153,7 @@ and if this does appear, then Whalesong should be installed successfully.
@subsection{Running Whalesong}
@subsection{Making Standalone @tt{.xhtml} files with Whalesong}
Let's try making a simple, standalone executable. At the moment, the
program must be written in the base language of @racket[(planet
@ -234,19 +234,102 @@ web browser, we should see a pale, green page with some output.
@;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@section{Extended example}
@subsection{Using Whalesong functions from JavaScript}
@;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(This example needs to use modules. It should also show how we can use the
other command-line options to compress the javascript, and how to
use @tt{get-javascript} and @tt{get-runtime}, to allow the user to
build a customized html file.)
Whalesong also allows functions defined from Racket to be used from
JavaScript. As an example, we can take the boring @emph{factorial}
function and define it in a module called @filepath{fact.rkt}:
@margin-note{
The files can also be downloaded here:
@itemlist[@item{@link["http://hashcollision.org/whalesong/fact-example/fact.rkt"]{fact.rkt}}
@item{@link["http://hashcollision.org/whalesong/fact-example/index.html"]{index.html}}]
with generated JavaScript binaries here:
@itemlist[
@item{@link["http://hashcollision.org/whalesong/fact-example/fact.js"]{fact.js}}
@item{@link["http://hashcollision.org/whalesong/fact-example/runtime.js"]{runtime.js}}
]
}
@filebox["fact.rkt"]{
@verbatim|{
#lang planet dyoo/whalesong
(provide fact)
(define (fact x)
(cond
[(= x 0)
1]
[else
(* x (fact (sub1 x)))]))
}|}
Instead of creating a standalone @tt{.xhtml}, we can use @tt{whalesong} to
get us the module's code. From the command-line:
@verbatim|{
$ whalesong get-javascript fact.rkt > fact.js
$ ls -l fact.js
-rw-r--r-- 1 dyoo dyoo 27421 2011-07-11 22:02 fact.js
}|
This file does require some runtime support not included in
@filepath{fact.js}; let's generate the @tt{runtime.js} and save
it as well. At the command-line:
@verbatim|{
$ whalesong get-runtime > runtime.js
$ ls -l runtime.js
-rw-r--r-- 1 dyoo dyoo 544322 2011-07-11 22:12 runtime.js
}|
Now that we have these, let's write an @filepath{index.html} that uses
the @racket[fact] function that we @racket[provide]ed from
@filepath{fact.rkt}.
@filebox["index.html"]{
@verbatim|{
<!DOCTYPE html>
<html>
<head>
<script src="runtime.js"></script>
<script src="fact.js"></script>
<script>
// Each module compiled with 'whalesong get-runtime' is treated as a
// main module. invokeMains() will invoke them.
plt.runtime.invokeMains();
plt.runtime.ready(function() {
// Grab the definition of 'fact'...
var myFactClosure = plt.runtime.lookupInMains('fact');
// Make it available as a JavaScript function...
var myFact = plt.baselib.functions.asJavaScriptFunction(
myFactClosure);
// And call it!
myFact(function(v) {
$('#answer').text(v.toString());
},
function(err) {
$('#answer').text(err.message).css("color", "red");
},
10000
// "one-billion-dollars"
);
});
</script>
</head>
<body>
The factorial of 10000 is <span id="answer">being computed</span>.
</body>
</html>
}|
}
Replacing the @racket[10000] with @racket["one-billion-dollars"] should
reliably produce a proper error message.
@;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

4
tests/coersing/Makefile
View File

@ -1,5 +1,5 @@
#!/bin/sh
all:
../../whalesong get-javascript fact.rkt > fact.js
../../whalesong get-runtime > runtime.js
../../whalesong get-javascript --verbose --compress-javascript fact.rkt > fact.js
../../whalesong get-runtime --verbose --compress-javascript > runtime.js

2
tests/coersing/fact.rkt
View File

@ -8,4 +8,4 @@
(* x (fact (sub1 x)))]))
(printf "test: ~s\n" (fact 4))
;;(printf "test: ~s\n" (fact 4))

16
tests/coersing/index.html
View File

@ -3,29 +3,29 @@
<script src="runtime.js"></script>
<script src="fact.js"></script>
<script>
plt.runtime.invokeMains();
</script>
<script>
plt.runtime.invokeMains();
plt.runtime.ready(function() {
var myFactClosure = plt.runtime.lookupInMains('fact');
var myFact = plt.baselib.functions.asJavaScriptFunction(
myFactClosure);
$(document.body).append("The factorial of 1000 is: ");
myFact(function(v) {
$(document.body).append(v.toString());
$('#answer').text(v.toString());
},
function(err) {
$(document.body).append(err);
$('#answer').text(err.message).css("color", "red");
},
1000);
10000
// "one-billion-dollars"
);
});
</script>
</head>
<body>
The factorial of 10000 is <span id="answer">being computed</span>.
</body>
</html>

26
whalesong.rkt
View File

@ -8,6 +8,7 @@
"js-assembler/package.rkt"
"private/command.rkt"
"logger.rkt"
"parameters.rkt"
raco/command-name)
@ -43,6 +44,10 @@
[("-v" "--verbose")
("Display verbose messages.")
(current-verbose? #t)]
[("--compress-javascript")
("Compress JavaScript with Google Closure (requires Java)")
(current-compress-javascript? #t)]
#:args (path)
(do-the-build path)]
["get-runtime" "print the runtime library to standard output"
@ -51,6 +56,10 @@
[("-v" "--verbose")
("Display verbose messages.")
(current-verbose? #t)]
[("--compress-javascript")
("Compress JavaScript with Google Closure (requires Java)")
(current-compress-javascript? #t)]
#:args ()
(print-the-runtime)]
["get-javascript" "Gets just the JavaScript code and prints it to standard output"
@ -59,6 +68,11 @@
[("-v" "--verbose")
("Display verbose messages.")
(current-verbose? #t)]
[("--compress-javascript")
("Compress JavaScript with Google Closure (requires Java)")
(current-compress-javascript? #t)]
#:args (file)
(get-javascript-code file)]))
@ -77,7 +91,8 @@
(let ([msg (sync receiver)])
(match msg
[(vector level msg data)
(printf "~a: ~a\n" level msg)]))
(fprintf (current-error-port)"~a: ~a\n" level msg)
(flush-output (current-error-port))]))
(loop)))))))
@ -109,15 +124,16 @@
(define (print-the-runtime)
(turn-on-logger!)
(write-runtime (current-output-port)))
(display (get-runtime) (current-output-port)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define (get-javascript-code filename)
(turn-on-logger!)
(write-standalone-code
(make-ModuleSource (build-path filename))
(current-output-port)))
(display (get-standalone-code
(make-ModuleSource (build-path filename)))
(current-output-port)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;