[e-cvs] cvs commit: e/doc/elang/tools updoc.html
markm@eros.cs.jhu.edu
markm@eros.cs.jhu.edu
Sun, 15 Jul 2001 23:28:30 -0400
markm 01/07/15 23:28:30
Modified: doc/elang same-ref.html
doc/elang/blocks defVar.html forKVExpr.html miranda.html
whileExpr.html
doc/elang/io text-file-io.html uri-exprs.html
doc/elang/scalars char-ref.html float64-ref.html
integer-ref.html
doc/elang/tools updoc.html
Log:
more files pass updoc
Revision Changes Path
1.35 +22 -22 e/doc/elang/same-ref.html
Index: same-ref.html
===================================================================
RCS file: /cvs/e/doc/elang/same-ref.html,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -r1.34 -r1.35
--- same-ref.html 2001/04/30 20:36:04 1.34
+++ same-ref.html 2001/07/16 03:28:30 1.35
@@ -87,8 +87,8 @@
is always false. What is were E to adopt this rule and so lose reflexivity?
Consider: </p>
<blockquote>
- <pre>? def m := [] asMap diverge
-# value: [] diverge
+ <pre>? def m := [] asMap() diverge()
+# value: [] diverge()
? m[a] := "foo"
# value: foo
@@ -115,7 +115,7 @@
? 0 == 0.0
# value: false
-? 'a' == 'a' asInteger
+? 'a' == 'a' asInteger()
# value: false</pre>
</blockquote>
<p>Surprisingly, <a href="scalars/float64-ref.html#SameFloat64">when applied
@@ -123,10 +123,10 @@
<h3>Selfish and Selfless Objects</h3>
<p>For a surprise, let's revisit our familiar PointMaker example:</p>
<blockquote>
- <pre>? def PointMaker new(x, y) :any {
+ <pre>? def PointMaker(x, y) :any {
> def point {
-> to getX :any { x }
-> to getY :any { y }
+> to getX() :any { x }
+> to getY() :any { y }
> to printOn(oo) {
> oo print(`<$x, $y>`)
> }
@@ -134,10 +134,10 @@
> }
# value: <PointMaker>
-? def a := PointMaker new(3, 5)
+? def a := PointMaker(3, 5)
# value: <3, 5>
-? def b := PointMaker new(3, 5)
+? def b := PointMaker(3, 5)
# value: <3, 5>
? a == a
@@ -165,14 +165,14 @@
<3, 5> point wasn't the same as another. Here's how you'd create
mathematically respectable selfless points:</p>
<blockquote>
- <pre>? def PointMaker new(x :final, y :final) :any {
+ <pre>? def PointMaker(x :final, y :final) :any {
> def point :: selfless {
-> to getX :any { x }
-> to getY :any { y }
-> to openState :any {
-> meta scope
+> to getX() :any { x }
+> to getY() :any { y }
+> to openState() :any {
+> meta scope()
> }
-> to openSource :any {
+> to openSource() :any {
> meta sourceTree(point)
> }
> to printOn(oo) {
@@ -182,13 +182,13 @@
> }
# value: <PointMaker>
-? def c := PointMaker new(3, 5)
+? def c := PointMaker(3, 5)
# value: <3, 5>
-? def d := PointMaker new(3, 5)
+? def d := PointMaker(3, 5)
# value: <3, 5>
-? def e := PointMaker new(7, 5)
+? def e := PointMaker(7, 5)
# value: <7, 5>
? c == c
@@ -258,11 +258,11 @@
? def cl := [2, 3]
# value: [2, 3]
-? def fla := cl diverge
-# value: [2, 3] diverge
+? def fla := cl diverge()
+# value: [2, 3] diverge()
-? def flb := cl diverge
-# value: [2, 3] diverge
+? def flb := cl diverge()
+# value: [2, 3] diverge()
? fla == fla
# value: true
@@ -270,7 +270,7 @@
? fla == flb
# value: false
-? fla snapshot == flb snapshot
+? fla snapshot == flb snapshot()
# value: true
</pre>
</blockquote>
1.19 +3 -2 e/doc/elang/blocks/defVar.html
Index: defVar.html
===================================================================
RCS file: /cvs/e/doc/elang/blocks/defVar.html,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -r1.18 -r1.19
--- defVar.html 2001/07/15 23:10:24 1.18
+++ defVar.html 2001/07/16 03:28:30 1.19
@@ -120,8 +120,9 @@
<pre class="updoc">? var i :integer := 2 + 3
# value: 5</pre>
<pre class="updoc">? var j :char := 2 + 3
-# problem: <ClassCastException: java.math.BigInteger \
-# doesn't coerce to a Character></pre></blockquote>
+# problem: <ClassCastException: BigInteger \
+# doesn't coerce to a Character></pre>
+ </blockquote>
(Note that the above example doesn't yet pass as an Updoc test case due
to the <i><a href="../tools/updoc.html#continuation-bug">line continuation
bug</a></i>.)
1.20 +29 -27 e/doc/elang/blocks/forKVExpr.html
Index: forKVExpr.html
===================================================================
RCS file: /cvs/e/doc/elang/blocks/forKVExpr.html,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -r1.19 -r1.20
--- forKVExpr.html 2001/07/15 23:10:24 1.19
+++ forKVExpr.html 2001/07/16 03:28:30 1.20
@@ -113,14 +113,14 @@
<code><var>value-pattern</var></code> can be just variable names, which
will get bound to each of the key-value pairs in the entire collection.
<blockquote>
- <pre><code><font color="#808080">?</font> for key => value in [1, 3, 5, 100, 6] {
-<font color="#808080">></font> println(`$key maps to $value`)
-<font color="#808080">></font> }
-<font color="#808080">0 maps to 1
-1 maps to 3
-2 maps to 5
-3 maps to 100
-4 maps to 6</font></code> </pre>
+ <pre><font color="#808080">?</font> for key => value in [1, 3, 5, 100, 6] {
+<font color="#808080">></font> println(`$key maps to $value`)
+<font color="#808080">></font> }
+<font color="#808080">0 maps to 1
+1 maps to 3
+2 maps to 5
+3 maps to 100
+4 maps to 6</font> </pre>
</blockquote>
<p>As we can see, the keys of a list are the indices into the list. More
interestingly, E's map collections are hash tables with arbitrary keys
@@ -147,7 +147,7 @@
<font color="#808080">?</font> capitals["New York"]
<font color="#808080"># value: "Albany"</font>
-<font color="#808080">?</font> def result := ""
+<font color="#808080">?</font> var result := ""
<font color="#808080"># value: ""</font>
<font color="#808080">?</font> for state => city in capitals {
@@ -157,19 +157,20 @@
<font color="#808080">></font> }
<font color="#808080">?</font> result
-<font color="#808080"># value: "Albany Philadelphia "</font></pre>
+<font color="#808080"># value: "Philadelphia Albany "</font></pre>
</blockquote>
<p>But since the body of the loop is only executed if both pattern matches
succeed, we can move tests up into these patterns. Since the above loop
makes no other use of the "state" variable, it can be rewritten this
way:
<blockquote>
- <pre><code><font color="#808080">?</font> def result := ""
-<font color="#808080"># value: ""</font>
-
-<font color="#808080"></font><font color="#808080">?</font> for `@{_}e@_` => city in capitals {
-<font color="#808080">></font> result += city + " "
-<font color="#808080">></font> }</code></pre>
+
+ <pre><font color="#808080">?</font> var result := ""
+<font color="#808080"># value: ""</font>
+
+<font color="#808080"></font><font color="#808080">?</font> for `@{_}e@_` => city in capitals {
+<font color="#808080">></font> result += city + " "
+<font color="#808080">></font> }</pre>
</blockquote>
<p>The <code><var>key-pattern</var></code> in this last example will only
match strings containing the letter "e".
@@ -194,7 +195,7 @@
We can accomplish this with the following function:
<blockquote>
- <pre><code><font color="#808080">?</font> def leaves(filedir) :any {
+ <pre><font color="#808080">?</font> def leaves(filedir) :any {
<font color="#808080">></font> def leafCollection {
<font color="#808080">></font> to iterate(assocFunc) {
<font color="#808080">></font> if (filedir isDirectory()) {
@@ -207,7 +208,7 @@
<font color="#808080">></font> }
<font color="#808080"></font><font color="#808080">></font> }
<font color="#808080">></font> }
-<font color="#808080"># value: <getLeaves></font></code></pre>
+<font color="#808080"># value: <leaves></font></pre>
</blockquote>
<p>Now <code>leaves(<var>filedir</var>)</code> defines an object <code>leafCollection</code>
that acts like a collection of the leaves of the directory tree rooted
@@ -219,16 +220,17 @@
<p>For example, I got curious about how many Java files I had in a particular
directory tree:
<blockquote>
- <pre><code><font color="#808080">?</font> def count := 0
-<font color="#808080"># value: 0</font>
-
+
+ <pre><font color="#808080">?</font> var count := 0
+<font color="#808080"># value: 0</font>
+
<font
-color="#808080">?</font> for `@_.java` => _ in leaves(<file:/e/src>) {
-<font color="#808080">></font> count += 1
-<font color="#808080">></font> }
-
-<font color="#808080">?</font> count
-<font color="#808080"># value: 32</font></code></pre>
+color="#808080">?</font> for `@_.java` => _ in leaves(<d:/e/src>) {
+<font color="#808080">></font> count += 1
+<font color="#808080">></font> }
+
+<font color="#808080">?</font> count
+<font color="#808080"># value: 455</font></pre>
</blockquote>
<!-- #EndEditable --></TD>
1.22 +1 -1 e/doc/elang/blocks/miranda.html
Index: miranda.html
===================================================================
RCS file: /cvs/e/doc/elang/blocks/miranda.html,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -r1.21 -r1.22
--- miranda.html 2001/07/14 12:54:10 1.21
+++ miranda.html 2001/07/16 03:28:30 1.22
@@ -56,7 +56,7 @@
<pre class="updoc">
? def PointMaker(x, y) :any {
> def point {
-> to printOn(out) { out(`<$x, $y>`) }
+> to printOn(out) { out print(`<$x, $y>`) }
> to getX() :any {x}
> to getY() :any {y}
> }
1.18 +4 -3 e/doc/elang/blocks/whileExpr.html
Index: whileExpr.html
===================================================================
RCS file: /cvs/e/doc/elang/blocks/whileExpr.html,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -r1.17 -r1.18
--- whileExpr.html 2001/07/14 12:54:10 1.17
+++ whileExpr.html 2001/07/16 03:28:30 1.18
@@ -98,9 +98,10 @@
> }
# value: <findFirst></pre>
<pre class="leftupdoc">
-? findFirst(<file:/jabberwocky.txt>, "and")
-# value: Twas Brillig and the Slithy Toves</pre>
- <pre class="leftupdoc">? findFirst(<file:/jabberwocky.txt>, "foo") == null
+? findFirst(<c:/jabbertest/jabberwocky.txt>, "and")
+# value: "\'Twas brillig and the slithy toves "
+</pre>
+ <pre class="leftupdoc">? findFirst(<c:/jabbertest/jabberwocky.txt>, "foo") == null
# value: true</pre>
</blockquote>
<p class="Body"> As we'll see, this and many similar examples are better
1.4 +77 -71 e/doc/elang/io/text-file-io.html
Index: text-file-io.html
===================================================================
RCS file: /cvs/e/doc/elang/io/text-file-io.html,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- text-file-io.html 2001/04/30 20:36:05 1.3
+++ text-file-io.html 2001/07/16 03:28:30 1.4
@@ -55,8 +55,8 @@
that doesn't yet exist -- a potential file or directory. You can test
which as follows:</p>
<blockquote>
- <pre>? def j1 := <file:/jabberwocky.txt>
-# value: <file:/jabberwocky.txt>
+ <pre>? def j1 := <file:c:/jabbertest/jabberwocky.txt>
+# value: <file:c:/jabbertest/jabberwocky.txt>
? j1 <b>exists</b>()
# value: true
@@ -70,8 +70,8 @@
<p>Not surprisingly, the jabberwocky.txt file we created earlier exists,
and is a normal file, and therefore is not a directory.
<blockquote>
- <pre>? def j2 := <file:/jabberwocky2.txt>
-# value: <file:/jabberwocky2.txt>
+ <pre>? def j2 := <c:/jabbertest/jabberwocky2.txt>
+# value: <file:c:/jabbertest/jabberwocky2.txt>
? j2 exists()
# value: false
@@ -85,8 +85,8 @@
<p>On the other hand, "jabberwocky2.txt" does not yet exist, and
is therefore neither normal nor a directory.</p>
<blockquote>
- <pre>? def desk := <file:/windows/desktop>
-# value: <file:/windows/desktop/>
+ <pre>? def desk := <c:/windows/desktop>
+# value: <file:c:/windows/desktop/>
? desk exists()
# value: true
@@ -99,30 +99,33 @@
</blockquote>
<p>"desk" now represents our Windows Desktop which, as you can
see, is a directory.</p>
- <blockquote>
+ <blockquote>
<pre>? desk <b>getCanonicalPath</b>()
-# value: C:\WINDOWS\DESKTOP</pre>
+# value: "C:/WINDOWS/Desktop/"
+</pre>
</blockquote>
<p>To aid portability, E enables (and encourages) you to deal with Files
using "/" as the path separator character. But you can use "getCanonicalPath"
when you want to see what the path-name of the file looks like to your
operating system.
- <blockquote>
+ <blockquote>
<pre>? desk <b>getName</b>()
-# value: desktop
+# value: "desktop"
? desk <b>getParent</b>()
-# value: /windows/
+# value: "c:/windows/"
? j1 getName()
-# value: jabberwocky.txt
+# value: "jabberwocky.txt"
? j1 getParent()
-# value: /</pre>
+# value: "c:/jabbertest/"
+</pre>
</blockquote>
- <p>"getName" and "getParent" both return Strings (not
- Files) representing the local name of the file within its containing directory,
- and the name of this containing directory, respectively.</p>
+ <p>"<code>getName()</code>" and "<code>getParent()</code>"
+ both return Strings (not Files) representing the local name of the file
+ within its containing directory, and the name of this containing directory,
+ respectively.</p>
<p>The methods <b>canRead</b>(), <b>canWrite</b>(), <b>delete</b>(), and
<b>renameTo</b>(file) all behave just as in Java, and operate on both
normal files and directories. See the javadoc-umentation.</p>
@@ -131,43 +134,45 @@
collection of a for loop, E assumes the file is a text file, and treats
it as a collection of lines.</p>
<blockquote>
- <pre>? def size := 0
+ <pre>? var size := 0
# value: 0
-
-? for line in <file:/jabberwocky.txt> {
+
+? for line in <c:/jabbertest/jabberwocky.txt> {
> size += line size()
> }
+
? size
-# value: 256</pre>
+# value: 270</pre>
</blockquote>
<p>To aid portability, each of these lines ends with a newline character,
'\n', independent of how newlines are actually represented on the current
platform. On Windows newlines are represented with a pair of characters,
so the above size is smaller than the Windows file size.
<blockquote>
- <pre>? <file:/jabberwocky.txt> <b>asString</b> size()
-# value: 256</pre>
+ <pre>? <c:/jabbertest/jabberwocky.txt> <b></b>getText() size()
+# value: 270</pre>
</blockquote>
- <p>You can also read the whole (presumed) text file into one big String
- using "asString". As you might be able to guess from the agreement
- on size, asString also turns platform-specific newlines into newline characters.</p>
+ <p>You can also read the whole (presumed) text file into one big String
+ using "<code>getText()</code>". As you might be able to guess
+ from the agreement on size, <code>getText()</code> also turns platform-specific
+ newlines into newline characters.</p>
<p>When you don't want to read the whole file at once, you instead open
a text reading stream on the File using "textReader":</p>
- <blockquote>
- <pre>? def reader := <file:/jabberwocky.txt> <b>textReader</b>()
-# value: java.io.BufferedReader@1c1cb7
-
+ <blockquote>
+ <pre>? def reader := <c:/jabbertest/jabberwocky.txt> <b>textReader</b>()
+# value: <BufferedReader>
+
? reader <b>readChar</b>()
-# value: T
+# value: '\''
? reader <b>readLine</b>()
-# value: was Brillig and the Slithy Toves
+# value: "Twas brillig and the slithy toves "
? reader <b>readString</b>(10)
-# value: Did gyre a
+# value: "Did gyre a"
? reader <b>readString</b>(1000) size()
-# value: 212</pre>
+# value: 232</pre>
</blockquote>
<p>"readChar" returns the next character. "readLine"
reads a line of text, but, following Java conventions, without the terminating
@@ -181,20 +186,20 @@
</blockquote>
<p>When the stream is at end of file, the above read-requests all return
null.</p>
- <blockquote>
+ <blockquote>
<pre>? reader <b>close</b>()
? reader readChar()
-# problem: java.io.IOException: Stream closed</pre>
+# problem: <IOException: Stream closed></pre>
</blockquote>
<p>When you're done with a stream, you should always be sure to close it.
That's fine for interactive use, but how can you be sure your program
will close the stream when an I/O error might throw you out of your function
before you get to your close message? By using try/finally:</p>
- <blockquote>
- <pre>? reader := <file:/jabberwocky.txt> textReader()
-# value: java.io.BufferedReader@1c2967
+ <blockquote>
+ <pre>? def reader := <c:/jabbertest/jabberwocky.txt> textReader()
+# value: <BufferedReader>
-? def size := 0
+? var size := 0
# value: 0
? try {
@@ -205,7 +210,7 @@
> } finally {
> reader close()
> }
-# value: 246</pre>
+# value: 261</pre>
</blockquote>
<p>This loop uses a reader to loop through the file one line at a time.
The "finally" clause will be sure we close the stream no matter
@@ -215,31 +220,32 @@
<p>Notice that the cumulative size is smaller than before. This is because
"readLine" produces lines <i>not</i> terminated by any form
of newline.</p>
- <blockquote>
- <pre>? <file:/jabberwocky2.txt> exists()
+ <blockquote>
+ <pre>? <c:/jabbertest/jabberwocky2.txt> exists()
# value: false
-? <file:/jabberwocky2.txt> textReader()
-# problem: java.io.FileNotFoundException: \jabberwocky2.txt</pre>
+? <c:/jabbertest/jabberwocky2.txt> textReader()
+# problem: <FileNotFoundException: c:\jabbertest\jabberwocky2.txt \
+# (The system cannot find the file specified)></pre>
</blockquote>
<p>Not surprisingly, you can't open a text Reader on a file that doesn't
exist. However...
<h2><a name="WritingText"></a>Writing Text</h2>
<blockquote>
- <pre>? def writer := <file:/jabberwocky2.txt> <b>textWriter</b>()
-# value: org.erights.e.elib.base.TextWriter@1c5c32
-
-? <file:/jabberwocky2.txt> exists()
+ <pre>? def writer := <c:/jabbertest/jabberwocky2.txt> <b>textWriter</b>()
+# value: <TextWriter>
+
+? <c:/jabbertest/jabberwocky2.txt> exists()
# value: true</pre>
</blockquote>
<p>... you can open a TextWriter, which also causes the file to be created
if needed. You then fill the file with content by writing to the TextWriter,
and then closing it. For example, to copy the contents of
-<file:/jabberwocky.txt>
- into <file:/jabberwock2.txt>:</p>
+<c:/jabbertest/jabberwocky.txt>
+ into <c:/jabbertest/jabberwock2.txt>:</p>
<blockquote>
<pre>? try {
-> for line in <file:/jabberwocky.txt> {
+> for line in <c:/jabbertest/jabberwocky.txt> {
> writer <b>print</b>(line)
> }
> } finally {
@@ -264,8 +270,8 @@
<p>This is the form that would get written to a file if these values were
used as the argument of a "print" message.</p>
<blockquote>
- <pre>? <file:/jabberwocky2.txt> asString size()
-# value: 256</pre>
+ <pre>? <c:/jabbertest/jabberwocky2.txt> getText() size()
+# value: 270</pre>
</blockquote>
<p>As we see from the size, our file-copy code copied the whole file.</p>
<p>We can turn the above pattern into a useful little function for copying
@@ -285,16 +291,16 @@
</blockquote>
<p>Using this function, we can copy files simply:
<blockquote>
- <pre>? textFileCopy(<file:/jabberwocky.txt>,
-> <file:/jabberwocky2.txt>)</pre>
+ <pre>? textFileCopy(<c:/jabbertest/jabberwocky.txt>,
+> <c:/jabbertest/jabberwocky2.txt>)</pre>
</blockquote>
<p>Your interactive command-line interpreter already has an TextWriter that's
always open, called "stdout", that displays text on your command
line interpreter window:</p>
<blockquote>
<pre>? stdout
-# value: org.erights.e.elib.base.TextWriter@1c4134
-
+# value: <TextWriter>
+
? stdout <b>println</b>(2/3)
0.6666666666666666</pre>
</blockquote>
@@ -312,8 +318,8 @@
> }
# value: <textStreamCopy>
-? def reader := <file:/jabberwocky.txt> textReader()
-# value: java.io.BufferedReader@1c94aa
+? def reader := <c:/jabbertest/jabberwocky.txt> textReader()
+# value: <BufferedReader>
? try {
> textStreamCopy(reader, stdout)
@@ -355,7 +361,7 @@
it returns a new TextWriter that writes to the same destination, but adding
the extra prefix after every newline.
<blockquote>
- <pre>? stdout indent("...") <b>lnPrint</b>(<file:/jabberwocky.txt> asString)
+ <pre>? stdout indent("...") <b>lnPrint</b>(<c:/jabbertest/jabberwocky.txt> getText())
...Twas Brillig and the Slithy Toves
...Did gyre and gimbal in the wabe
@@ -384,7 +390,7 @@
of information, we can now write our first non-trivial useful program:</p>
<blockquote>
<pre>? def writeDirMap(filedir, writer) {
-> writer lnPrint(filedir getName)
+> writer lnPrint(filedir getName())
> if (filedir isDirectory()) {
> writer print("/")
> def indentation := (" " * filedir getName() size()) + "/"
@@ -432,7 +438,7 @@
of our directory hierarchy. For example, when I map out my Windows Start
Menu:
<blockquote>
- <pre>? dirMapper(<file:"/Windows/Start Menu">,
+ <pre>? dirMapper(<file: "/Windows/Start Menu">,
> <file:/startMenuMap.txt>)</pre>
</blockquote>
<pre>The beginning of my resulting file looks like</pre>
@@ -458,8 +464,8 @@
<p>We've seen how to create new normal files -- by opening up a textWriter.
How do we create directories? With "mkdir" or "mkdirs":</p>
<blockquote>
- <pre>? def abc := <file:/a/b/c>
-# value: <file:/a/b/c>
+ <pre>? def abc := <c:/a/b/c>
+# value: <file:c:/a/b/c>
? abc exists()
# value: false</pre>
@@ -481,19 +487,19 @@
# value: true
? abc
-# value: <file:/a/b/c/></pre>
+# value: <file:c:/a/b/c/></pre>
</blockquote>
<p>abc now prints out with a terminal slash to indicate that it represents
a directory.</p>
- <blockquote>
- <pre>? def ab := <file:/a/b>
-# value: <file:/a/b/>
+ <blockquote>
+ <pre>? def ab := <c:/a/b>
+# value: <file:c:/a/b/>
? ab<b>[</b>"c"<b>]</b>
-# value: <file:/a/b/c/>
+# value: <file:c:/a/b/c/>
? ab[".."]
-# problem: java.lang.RuntimeException: \a\b\..: .. not allowed</pre>
+# problem: <SecurityException: ".." not allowed: ..></pre>
</blockquote>
<p>Directories are collections, mapping from local file names to the contained
Files (normal files or directories). We've already seen that directories
@@ -503,7 +509,7 @@
For reasons explained in <i>Capability Programming Patterns</i> E disallows
the use of ".." to navigate upwards.
<h2><a name="URLs"></a>URLs</h2>
- <p>*** to be written</p>
+ <p><font color="#ff0000">*** to be written</font></p>
<p>
<P ALIGN="left">
<!-- #EndEditable --></TD>
1.4 +4 -4 e/doc/elang/io/uri-exprs.html
Index: uri-exprs.html
===================================================================
RCS file: /cvs/e/doc/elang/io/uri-exprs.html,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- uri-exprs.html 2001/04/13 19:23:51 1.3
+++ uri-exprs.html 2001/07/16 03:28:30 1.4
@@ -56,7 +56,7 @@
<th>Value</th>
</tr>
<tr>
- <td><code><file:/jabberwocky.txt></code></td>
+ <td><code><c:/jabbertest/jabberwocky.txt></code></td>
<td>A file on the local file system</td>
<td>a java.io.File object</td>
</tr>
@@ -129,13 +129,13 @@
<pre><<i>protocol-name</i>: <i>expression</i>></pre>
</blockquote>
<p>So, for example, both</p>
- <blockquote>
- <pre>def name := "/jabberwocky.txt"
+ <blockquote>
+ <pre>def name := "c:/jabbertest/jabberwocky.txt"
<file: name></pre>
</blockquote>
<p>and</p>
<blockquote>
- <pre><file:/jabberwocky.txt></pre>
+ <pre><file:c:/jabbertest/jabberwocky.txt></pre>
</blockquote>
<p>mean the same thing. You can also use the URI unary expression to look
up names that contain non-URI characters. For example, Windows machines
1.3 +3 -3 e/doc/elang/scalars/char-ref.html
Index: char-ref.html
===================================================================
RCS file: /cvs/e/doc/elang/scalars/char-ref.html,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- char-ref.html 2001/04/08 19:59:11 1.2
+++ char-ref.html 2001/07/16 03:28:30 1.3
@@ -54,10 +54,10 @@
specifier can be a single non-special character, or a backslash followed
by an escape sequence.</p>
<blockquote>
- <pre>? 'a' asInteger
+ <pre>? 'a' asInteger()
# value: 97
-? '\n' asInteger
+? '\n' asInteger()
# value: 10</pre>
</blockquote>
<p>Here are the char operators in precedence order:</p>
@@ -172,7 +172,7 @@
<p>In addition to the messages corresponding to the above operators, chars
respond to the following messages.</p>
<blockquote>
- <pre>? 'a' <b>asInteger</b>
+ <pre>? 'a' <b>asInteger</b>()
# value: 97</pre>
</blockquote>
<p>For additional messages, see the javadoc-umentation for java.lang.Character.
1.4 +34 -40 e/doc/elang/scalars/float64-ref.html
Index: float64-ref.html
===================================================================
RCS file: /cvs/e/doc/elang/scalars/float64-ref.html,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -r1.3 -r1.4
--- float64-ref.html 2001/04/13 19:23:51 1.3
+++ float64-ref.html 2001/07/16 03:28:30 1.4
@@ -98,7 +98,7 @@
<tr>
<td><code>5.1 != 6.1</code></td>
<td>Are they different?</td>
- <td><code>E same(5.1, 6.1) not</code></td>
+ <td><code>E same(5.1, 6.1) not()</code></td>
<td><code>true</code></td>
</tr>
</table>
@@ -114,15 +114,19 @@
</pre>
</blockquote>
<p>You can use following function to test for arithmetic equality:</p>
- <blockquote>
+ <blockquote>
<pre>? def arithEqual(x, y) :any {
-> x compareTo(y) isZero
-> }</pre>
+> x compareTo(y) isZero()
+> }
+# value: <arithEqual></pre>
</blockquote>
<p>The following cases are all those for which being the same differs from
being arithmetically equal:</p>
- <blockquote>
- <pre>? NaN == NaN
+ <blockquote>
+ <pre>? def NaN := 0.0/0.0
+# value: NaN
+
+? NaN == NaN
# value: true
@@ -157,14 +161,14 @@
</blockquote>
<p>Of course, integer values are distinct from floating point values, even
when they represent the same real number.</p>
- <blockquote>
+ <blockquote>
<pre>? 3 == 3.0
# value: false
? arithEqual(3, 3.0)
-# problem: java.lang.IllegalArgumentException
+# problem: <ClassCastException: Double doesn't coerce to a integer>
</pre>
</blockquote>
<p>Why did this last throw an exception? As explained on ***, in expressions
@@ -188,7 +192,7 @@
</td>
<td>less than</td>
<td>
- <pre><code>5.1 compareTo(6.1) belowZero</code></pre>
+ <pre><code>5.1 compareTo(6.1) belowZero()</code></pre>
</td>
<td><code>true</code></td>
</tr>
@@ -198,7 +202,7 @@
</td>
<td>less or equal to</td>
<td>
- <pre><code>5.1 compareTo(6.1) atMostZero</code></pre>
+ <pre><code>5.1 compareTo(6.1) atMostZero()</code></pre>
</td>
<td><code>true</code></td>
</tr>
@@ -208,7 +212,7 @@
</td>
<td>greater or equal to</td>
<td>
- <pre><code>5.1 compareTo(6.1) atLeastZero</code></pre>
+ <pre><code>5.1 compareTo(6.1) atLeastZero()</code></pre>
</td>
<td><code>false</code></td>
</tr>
@@ -218,7 +222,7 @@
</td>
<td>greater than</td>
<td>
- <pre><code>5.1 compareTo(6.1) aboveZero</code></pre>
+ <pre><code>5.1 compareTo(6.1) aboveZero()</code></pre>
</td>
<td><code>false</code></td>
</tr>
@@ -407,11 +411,11 @@
</tr>
<tr>
<td>
- <pre><code>- 5.0</code></pre>
+ <pre><code>-5.0</code></pre>
</td>
<td>negation</td>
<td>
- <pre><code>5.0 negate</code></pre>
+ <pre><code>5.0 negate()</code></pre>
</td>
<td>
<pre><code>-5.0</code></pre>
@@ -427,50 +431,41 @@
<p>In addition to the messages corresponding to the above operators, float64s
respond to the following messages.</p>
<blockquote>
- <pre>? -5.1 <b>truncDivide</b>(3.1)
+ <pre>? (-5.1) <b>truncDivide</b>(3.1)
# value: -1</pre>
</blockquote>
<p>"truncDivide" is integer division where the answer is rounded
to an integer by rounding towards zero. It correspond to Java's "/"
operator on integers.</p>
<blockquote>
- <pre>? (-5.1) <b>ceil</b>
+ <pre>? (-5.1) <b>ceil</b>()
# value: -5</pre>
</blockquote>
<p>Nearest integer by rounding towards positive infinity.
<blockquote>
- <pre>? (-5.1) <b>floor</b>
+ <pre>? (-5.1) <b>floor</b>()
# value: -6</pre>
</blockquote>
<p>Nearest integer by rounding towards negative infinity.
<blockquote>
- <pre>? (-5.1) <b>round</b>
+ <pre>? (-5.1) <b>round</b>()
# value: -5
-? (-5.6) <b>round</b>
+? (-5.6) <b>round</b>()
# value: -6</pre>
</blockquote>
<p>The actually nearest integer.
<blockquote>
- <pre>? (-5.1) <b>truncate</b>
+ <pre>? (-5.1) <b>truncate</b>()
# value: -5
-? (-5.1) <b>truncate</b>
+? (-5.1) <b>truncate</b>()
# value: -5</pre>
</blockquote>
<p>Nearest integer by rounding towards zero.</p>
<blockquote>
- <pre>? (-5.1) <b>abs</b>
+ <pre>? (-5.1) <b>abs</b>()
# value: 5.1</pre>
</blockquote>
<p>Absolute value.</p>
- <blockquote>
- <pre>? (-5.1) <b>random</b>
-# value: -4.445243316379318
-
-? (-5.1) <b>random</b>
-# value: -1.352346415160266</pre>
- </blockquote>
- <p>Produces a new random number between 0 and this number. The randomness
- is good enough for government work but not for security.</p>
<p>
<hr align="CENTER">
<p></p>
@@ -484,18 +479,18 @@
<blockquote>
<pre>? def NaN := 0.0 / 0.0
# value: NaN</pre>
- <pre>? NaN <b>isNaN</b>
+ <pre>? NaN <b>isNaN</b>()
# value: true</pre>
<pre>? def Infinity := 1.0 / 0.0
# value: Infinity</pre>
- <pre>? Infinity <b>isInfinite</b>
+ <pre>? Infinity <b>isInfinite</b>()
# value: true</pre>
- <pre>? def PI := (0.0 acos) * 2.0
+ <pre>? def PI := (0.0 acos()) * 2.0
# value: 3.141592653589793
-? def E := 1.0 exp
-# value: 2.718281828459045</pre>
+? def e := 1.0 exp()
+# value: 2.7182818284590455</pre>
</blockquote>
<p>
<hr align="CENTER">
@@ -507,21 +502,20 @@
Integers are happy to adapt by automatically converting to float64. However,
since there's no one right way for a float64 to convert to an integer,
the programmer must specify:</p>
- <blockquote>
+ <blockquote>
<pre>? 3.1 + 5
# value: 8.1
? 3 + 5.1
-# problem: java.lang.IllegalArgumentException: argument type mismatch
+# problem: <ClassCastException: Double doesn't coerce to a integer>
-? 3 + 5.1 round
+? 3 + 5.1 round()
# value: 8</pre>
</blockquote>
<p>The chapter on capability programming style will explain how the left-side-wins
rule accomodates both extensibility and security.
- <P ALIGN="left">
<!-- #EndEditable --></TD>
<TD WIDTH="10%"> </TD>
</TR>
1.3 +18 -27 e/doc/elang/scalars/integer-ref.html
Index: integer-ref.html
===================================================================
RCS file: /cvs/e/doc/elang/scalars/integer-ref.html,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- integer-ref.html 2001/04/08 19:59:11 1.2
+++ integer-ref.html 2001/07/16 03:28:30 1.3
@@ -140,7 +140,7 @@
<td><code>5 < 6</code></td>
<td>less than</td>
<td>
- <pre><code>5 compareTo(6) belowZero</code></pre>
+ <pre><code>5 compareTo(6) belowZero()</code></pre>
</td>
<td><code>true</code></td>
</tr>
@@ -148,7 +148,7 @@
<td><code>5 <= 6</code></td>
<td>less or equal to</td>
<td>
- <pre><code>5 compareTo(6) atMostZero</code></pre>
+ <pre><code>5 compareTo(6) atMostZero()</code></pre>
</td>
<td><code>true</code></td>
</tr>
@@ -156,7 +156,7 @@
<td><code>5 >= 6</code></td>
<td>greater or equal to</td>
<td>
- <pre><code>5 compareTo(6) atLeastZero</code></pre>
+ <pre><code>5 compareTo(6) atLeastZero()</code></pre>
</td>
<td><code>false</code></td>
</tr>
@@ -164,7 +164,7 @@
<td><code>5 > 6</code></td>
<td>greater than</td>
<td>
- <pre><code>5 compareTo(6) aboveZero</code></pre>
+ <pre><code>5 compareTo(6) aboveZero()</code></pre>
</td>
<td><code>false</code></td>
</tr>
@@ -408,8 +408,8 @@
<pre>? def JoeSecret := 298724
# value: 298724
-? def JoePublic := \
- base ** JoeSecret %% mod
+? def JoePublic :=
+> base ** JoeSecret %% mod
# value: 3280
</pre>
</td>
@@ -417,8 +417,8 @@
<pre>? def BettySecret := 378627
# value: 378627
-? def BettyPublic := \
- base ** BettySecret %% mod
+? def BettyPublic :=
+> base ** BettySecret %% mod
# value: 8
</pre>
</td>
@@ -496,7 +496,7 @@
</td>
<td>twos-complement</td>
<td>
- <pre><code>5 negate</code></pre>
+ <pre><code>5 negate()</code></pre>
</td>
<td>
<pre><code>-5</code></pre>
@@ -508,7 +508,7 @@
</td>
<td>bitwise-complement</td>
<td>
- <pre><code>5 complement</code></pre>
+ <pre><code>5 complement()</code></pre>
</td>
<td>
<pre><code>-6</code></pre>
@@ -531,13 +531,13 @@
to an integer by rounding towards zero. It correspond to Java's "/"
operator.</p>
<blockquote>
- <pre>? (-5) <b>ceil</b>
+ <pre>? (-5) <b>ceil</b>()
# value: -5
-? (-5) <b>floor</b>
+? (-5) <b>floor</b>()
# value: -5
-? (-5) <b>round</b>
+? (-5) <b>round</b>()
# value: -5
-? (-5) <b>truncate</b>
+? (-5) <b>truncate</b>()
# value: -5</pre>
</blockquote>
<p>On float64s, "ceil", "floor", "round",
@@ -546,17 +546,17 @@
way, if you've got a number and you ask for an integer, it works even
if you already have an integer.</p>
<blockquote>
- <pre>? 33 <b>asChar</b>
+ <pre>? 33 <b>asChar</b>()
# value: !</pre>
</blockquote>
<p>Returns the character whose character code in unicode is 33.</p>
<blockquote>
- <pre>? 33 <b>asFloat64</b>
+ <pre>? 33 <b>asFloat64</b>()
# value: 33.0</pre>
</blockquote>
<p>Converts to a floating point number.</p>
<blockquote>
- <pre>? (-5) <b>abs</b>
+ <pre>? (-5) <b>abs</b>()
# value: 5</pre>
</blockquote>
<p>Absolute value.
@@ -565,18 +565,9 @@
# value: 2</pre>
</blockquote>
<p>Greatest Common Divisor.
- <blockquote>
- <pre>? 874284687687567 <b>isProbablePrime</b>(10)
-# value: false</pre>
- </blockquote>
- <p>When this says "false", we know the number isn't prime. When
- it says "true", then it's probability of being non-prime is
- only 1 part in 2 ** n, where n is the argument to isProbablePrime. If
- the answer above had been true, then there'd be 1 chance in a thousand
- that it still wasn't prime.</p>
<hr>
<h2>Integer Syntax</h2>
- <p> </p>
+ <p><font color="#ff0000">** To be written</font></p>
<!-- #EndEditable --></TD>
<TD WIDTH="10%"> </TD>
</TR>
1.6 +15 -3 e/doc/elang/tools/updoc.html
Index: updoc.html
===================================================================
RCS file: /cvs/e/doc/elang/tools/updoc.html,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- updoc.html 2001/07/15 23:10:24 1.5
+++ updoc.html 2001/07/16 03:28:30 1.6
@@ -41,7 +41,8 @@
<TD ALIGN="RIGHT">
<P ALIGN="RIGHT"><FONT SIZE="7"><!-- #BeginEditable "BigTitle" --><FONT SIZE="7"><B>What's
Updoc?</B></FONT><br>
- <font size="4">by Mark Miller & Terry Stanley</font><!-- #EndEditable --></FONT>
+ <font size="4">by Mark Miller & <a href="http://www.cocoon.com/">Terry
+ Stanley</a></font><!-- #EndEditable --></FONT>
</TD>
</TR>
</TABLE>
@@ -348,7 +349,7 @@
a test script can pause between a test case that is supposed to cause
some effect to eventually happen and a test case written assuming the
effect has happened (such as a promise being resolved).</p>
- <p><i><b><a name="exit-bug"></a>Nesting exiting</b></i>. The "<code>interp</code>"
+ <p><i><b><a name="nest-exit-bug"></a>Nesting exiting</b></i>. The "<code>interp</code>"
object seen by an Updoc test case also needs to support the message "<code>exitAtTop(exitCode)</code>",
as does the normal E interpreter. E programs should call this, rather
than "<code>System exit(exitCode)</code>", in order to terminate
@@ -356,8 +357,19 @@
an E program being run by another E program (as with an Updoc test script)
may exit its nested interpreter without causing the JVM to exit. <font color="#ff0000">(**
Put this issue into documentation of the normal E interpreter.)</font></p>
+ <p><i><b><a name="exitcode-bug"></a>Updoc's own exitCode</b></i>. Updoc
+ should remember whether any problems were encountered during an Updoc
+ run, or if instead all the test cases passed. Only if all the cases passed
+ should Updoc exit with an exitCode of 0. Otherwise it should exit with
+ a non-zero exitCode, indicating a problem. This would allow shell scripts
+ and makefiles to test or stop on a test failure. (Currently, Updoc always
+ returns an exitCode of 0.) Of course, once the E interpreter supports
+ <code>exitAtTop(exitCode)</code>, Updoc should use it for this purpose.</p>
<p><a name="syntax-error-bug"></a>An Updoc <b><i>syntax error</i></b> report
- doesn't yet conform to Updoc's output format.</p>
+ doesn't yet conform to Updoc's output format. In addition, because of
+ the order in which Updoc processes a test script, if a script contains
+ a syntax error, no feedback from earlier test cases in that script will
+ be seen.</p>
<p><i><b><a name="continuation-bug"></a>Line continuation</b></i>. Updoc
should understand "\" at the end of a line in the original answer
to mean, ignore the following newline. This would let answers in documentation