docs: add Japanese translations for all chapters

4 files changed, 541 insertions, 0 deletions

diff --git a/chapter14/README.ja.md b/chapter14/README.ja.md
new file mode 100644
index 00000000..76d8bf4f
--- /dev/null
+++ b/chapter14/README.ja.md
@@ -0,0 +1,409 @@
+# 第14章: 数値型
+
+[English](README.md) | 日本語
+
+[前: 第13章](../chapter13/README.ja.md) |
+[次: 第15章](../chapter15/README.ja.md)
+
+この文書は [原文](README.md) の日本語訳です。
+
+# 目次
+
+1. [浮動小数点演算](#浮動小数点演算)
+2. [狭いワード型](#狭い型とサブワード型)
+3. [オーバーフローの処理](#オーバーフローの処理)
+4. [整数の範囲](#整数の範囲)
+5. [ビット演算](#ビット演算)
+6. [優先順位](#優先順位)
+7. [型の束](#型の実装)
+
+> 訳注: 原文の目次にある「Nodes」に対応する節は、原文本文にはありません。
+
+構造体、参照フィールド、スケジューリングがそろったので、この章では、それらが運ぶ数値を拡張します。浮動小数点演算、狭い整数型と浮動小数点型、整数の範囲を追加します。
+
+[linear](https://github.com/SeaOfNodes/Simple/tree/linear) ブランチの線形の Git リビジョン履歴で[この章](https://github.com/SeaOfNodes/Simple/tree/linear-chapter14)を読むことや、前章との[差分](https://github.com/SeaOfNodes/Simple/compare/linear-chapter13...linear-chapter14)を見ることもできます。
+
+## 浮動小数点演算
+
+浮動小数点値は `flt` 型から始まり、IEEE754 の64ビット演算を行います。整数式は、浮動小数点式に含まれると自動的に浮動小数点へ拡張されます。
+
+```java
+flt f = 0.5;
+int x = 2;
+f = f+x;     // Auto-widen x to 2.0, result is 2.5
+f = f+true;  // Since bools are just synonyms for integers 0,1 they auto-widen also
+```
+
+今のところ、逆に `flt` を丸めて `int` に戻す方法はありません。
+
+```java
+int x = 3.14; // error
+```
+
+平方根を計算するニュートン法を示します。
+
+```java
+flt guess = arg;  // Initial guess is just argument
+while( true ) {
+    // Next guess from Newton's method
+    flt next = (arg/guess + guess)/2;
+    // Break if hit fixed point
+    if( next == guess ) break;
+    guess = next;
+}
+return guess;
+```
+
+引数 2 で実行すると 1.414213562373095 を生成します。
+
+浮動小数点演算には専用の Node があります。
+
+| ノード | 演算 |
+|---|---|
+| AddF, SubF, MulF, DivF | 基本的な二項浮動小数点演算 |
+| MinusF | 単項の符号反転 |
+| EQF, LTF, LEF | 浮動小数点の比較演算子 |
+
+パーサーは [`Node.widen()`](src/main/java/com/seaofnodes/simple/node/Node.java) を使って浮動小数点演算を選び、`ToFloatNode` による変換を挿入します。浮動小数点の束は、範囲導入前の整数の束のように、`TOP` と `BOT` の間に定数を持ちます。[`TypeFloat`](src/main/java/com/seaofnodes/simple/type/TypeFloat.java) は、値が `f32` に収まるかどうかも記録します。`f32` への代入では、その精度に丸めます。浮動小数点から整数への変換は、別の未実装の言語機能として残ります。
+
+## 狭い型とサブワード型
+
+狭い整数型、またはサブワード整数型とは、システムやプログラミング言語が提供する標準的な「全幅」（通常32または64ビット）の整数型よりも、使用するメモリ（ビット数）が少ない整数データ型のことです。
+
+配列、特にあらゆるネットワークコードでよく使うバイト配列の前段階として、Simple にはサブワード整数型を操作する方法が必要です。整数と浮動小数点の演算は、常に64ビットで計算しますが、変数やフィールドへの代入時には切り詰め（丸め）、ロード時には（符号）拡張します。
+
+```java
+i8 x = 123456789;
+if( x != 21 )
+  return false;
+return true;
+```
+
+変数 `x` は符号付き8ビットに制限されます。非常に大きい値 `123456789`（16進数では `0x75BCD15`）を代入すると、単に8ビットに切り詰めて `21 (0x15)` になります。ロード時には符号拡張されます。
+
+```java
+i16 x = 123456789;
+if( x != -13035 )
+  return false;
+return true;
+```
+
+変数 `x` は符号付き16ビットに制限されます。非常に大きい値 `0x75BCD15` を代入すると、単に16ビットに切り詰めて `0xCD15` になります。ロード時には符号拡張され、`-13035 (0xFFFF FFFF FFFF CD15)` になります。
+
+```java
+u16 x = 123456789;
+if( x != 52501 )
+  return false;
+return true;
+```
+
+変数 `x` は符号なし16ビットに制限されます。非常に大きい値 `0x75BCD15` を代入すると、単に16ビットに切り詰めて `0xCD15` になります。ロード時にはゼロ拡張され、`52501 (0x0000 0000 0000 CD15)` になります。
+
+同様に、浮動小数点数を IEEE754 の標準32ビット形式に制限できます。代入時には丸め、ロード時には64ビットに拡張します。
+
+これでプリミティブ型の完全な一覧は次のようになります。
+
+| データ型 | サイズ（ビット） | 説明 |
+|---|---|---|
+| `int`, `i64` | 64 | 現代のハードウェアに対応する64ビット符号付き整数。 |
+| `u64` | 64 | **未実装**。64ビットを超える振る舞いを示唆します。 |
+| `i32` | 32 | 32ビット符号付き整数。ロード時に符号拡張。 |
+| `u32` | 32 | 32ビット符号なし整数。ロード時にゼロ拡張。 |
+| `i16` | 16 | 16ビット符号付き整数。ロード時に符号拡張。 |
+| `u16` | 16 | 16ビット符号なし整数。ロード時にゼロ拡張。 |
+| `i8` | 8 | 8ビット符号付き整数。ロード時に符号拡張。 |
+| `u8` | 8 | 8ビット符号なし整数。ロード時にゼロ拡張。 |
+| `i1` | 1 | 1ビット符号付き整数。ロード時に符号拡張。 |
+| `u1` | 1 | 1ビット符号なし整数。ロード時にゼロ拡張。 |
+| `bool` | 1 | `u1` の別名。 |
+| `flt`, `f64` | 64 | IEEE 754 の64ビット浮動小数点数。一般に double と呼ばれます。 |
+| `f32` | 32 | IEEE 754 の32ビット浮動小数点数。 |
+
+## オーバーフローの処理
+
+整数変数が保持できる最大値より大きな値を、その変数に格納しようとすると整数オーバーフローが起きます。オーバーフローにはいくつかの場合があります。
+
+#### 符号なし（固定幅）整数のオーバーフロー
+
+```java
+u8 a = 255;
+u8 b = a + 1; // match u8 type against expr.type
+// a = 256
+// u8 = [0...255]
+return b;
+```
+
+式の型は、指定した型に一致しません。expr: ConstantNode(256) t: u8(0, 255)
+
+```java
+private Node parseExpressionStatement() {
+    Type t = type(); // u8 = [0...255]
+    ...
+    // expr.type = TypeInteger(256);
+    // Auto-narrow wide ints to narrow ints
+    expr = zsMask(expr,t);
+}
+```
+
+符号なしなので、指定した型からあふれる新しい値にビットマスクをかけるだけです。「ビットごとの AND」のオペランドは、値（256）とマスク（255、上限）です。これを切り詰めと呼びます。
+
+`ZsMask:`
+
+```java
+    // zero/sign extend.  "i" is limited to either classic unsigned (min==0) or
+    // classic signed (min=minus-power-of-2); max=power-of-2-minus-1.
+private Node zsMask(Node val, Type t ) {
+    if( !(val._type instanceof TypeInteger tval && t instanceof TypeInteger t0 && !tval.isa(t0)) ) {
+        if( !(val._type instanceof TypeFloat tval && t instanceof TypeFloat t0 && !tval.isa(t0)) )
+            return val;
+        // Float rounding
+        return new RoundF32Node(val).peephole();
+    }
+    if( t0._min==0 )        // Unsigned
+        return new AndNode(val,new ConstantNode(TypeInteger.constant(t0._max)).peephole()).peephole();
+    // Signed extension
+    int shift = Long.numberOfLeadingZeros(t0._max)-1;
+    Node shf = new ConstantNode(TypeInteger.constant(shift)).peephole();
+    if( shf._type==TypeInteger.ZERO )
+        return val;
+    return new SarNode(new ShlNode(val,shf.keep()).peephole(),shf.unkeep()).peephole();
+}
+```
+
+切り詰めは `AndNode` が行います。
+
+```java
+...
+if( t0._min==0 )       // Unsigned
+        return new AndNode(val,con(t0._max)).peephole();
+```
+
+これらは定数なので、peephole を呼ぶと `256 & 255` = 0 になります。出力は次の通りです。
+
+```
+return 0;
+```
+
+#### 最大整数のオーバーフロー
+
+```java
+i64 a = 9223372036854775807;
+i64 b = a + 1;
+return b;
+```
+
+加算の計算時には、オーバーフローしないことを確認します。
+
+`AddNode.overflow:`
+
+```java
+private static boolean overflow( long x, long y ) {
+    if(    (x ^      y ) < 0 ) return false; // unequal signs, never overflow
+    return (x ^ (x + y)) < 0; // sum has unequal signs, so overflow
+}
+```
+
+`AddNode.compute`
+
+```java
+...
+// Fold ranges like {0-1} + {2-3} into {2-4}.
+if( !overflow(i1._min,i2._min) &&
+    !overflow(i1._max,i2._max) )
+    return TypeInteger.make(i1._min+i2._min,i1._max+i2._max);
+```
+
+ここで **x + y** はオーバーフローして**負**になり、x ^ 負の値 = 負の値になります。負の数はすべて 0 より小さいので、true を返します。**オーバーフロー**する場合、TypeInteger のボトム型を返すだけです。
+
+```
+       return TypeInteger.BOT; // []
+```
+
+ただし、この例では定数を扱っているので、ここではそのまま自然にオーバーフローさせます。
+
+```java
+// i1: 9223372036854775807
+// i2: 1
+// i1 + i2 will overflow.
+return TypeInteger.constant(i1.value()+i2.value()); // -9223372036854775808;
+```
+
+#### 定数の範囲の加算
+
+```java
+u8 a = 12;
+u8 b = 13;
+u8 c = 124;
+u8 d = a + b + c;
+return d;
+```
+
+`is_con` が true なら、一般に `min = max` と言えます。したがって次のようになります。
+
+```java
+public static TypeInteger make(boolean is_con, long con) {
+    return make(is_con ? con : (con==0 ? Long.MAX_VALUE : Long.MIN_VALUE),
+                is_con ? con : (con==0 ? Long.MIN_VALUE : Long.MAX_VALUE));
+```
+
+- この結果は次の通りです。
+
+```java
+return make(con, con);
+```
+
+`value()` は定数に対してだけ呼ばれます。つまり `_min == _max;` という不変条件が成り立つため、`min_` と `max_` は等しく、どちらを返してもかまいません。
+
+これは通常の加算と同じです。
+
+```java
+public long value() { assert isConstant(); return _min; }
+```
+
+#### さらに切り詰める
+
+```java
+u8 a = arg;  // arg & 255
+u8 b = arg;  // arg & 255 (same as a)
+u8 c = a + b; // (arg&255)*2, type = TypeInteger.BOT
+return c; // (((arg&255)*2)&255), type = TypeInteger.U8
+```
+
+前と同じく、**arg** は **(arg&255)** になります。このノードを **GVN** テーブルに挿入し、**b** はその値を取得します。AddNode のピープホール最適化はこれらを `((arg&255)*2)` に変え、式に追加のマスクをかけて有効な境界内に保ちます。
+
+## 整数の範囲
+
+一般的な範囲の計算については、Hacker's Delight を参照してください。[^1]
+
+## ビット演算
+
+次のビット演算子をサポートします。
+AND `&`、OR `|`、XOR `^`、左シフト `<<`、右シフト `>>`、ゼロ埋め右シフト `>>>`
+
+| 演算子 | 記号 | 説明 |
+|---|---|---|
+| **AND** | `&` | ビットごとの AND 演算。 |
+| **OR** | `\|` | ビットごとの OR（包含的論理和）演算。 |
+| **XOR** | `^` | ビットごとの XOR（排他的論理和）演算。 |
+| **左シフト** | `<<` | ビットを左にずらし、ゼロで埋めます。 |
+| **右シフト** | `>>` | ビットを右にずらし、空いた位置に符号ビットの値を複製して埋めます。 |
+| **符号なし右シフト** | `>>>` | ビットを右にずらし、空いた位置を常にゼロで埋めます。 |
+
+`>>>` は算術シフトではなく論理シフトです。
+
+これらの論理演算のピープホール最適化の例を示します。
+
+#### AndNode:
+
+##### lhs & -1 = lhs;
+
+```java
+// And of -1.  We do not check for (-1&x) because this will already
+// canonicalize to (x&-1)
+if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==-1 )
+return lhs;
+
+```
+
+#### OrNode:
+
+##### lhs | 0 = lhs;
+
+```java
+// Or of 0.  We do not check for (0|x) because this will already
+// canonicalize to (x|0)
+if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==0 )
+return lhs;
+
+```
+
+#### 右シフト
+
+lhs >> 0 = lhs;
+
+```java
+// Sar of 0.
+if( t2.isConstant() && t2 instanceof TypeInteger i && (i.value()&63)==0 )
+    return lhs;
+```
+
+#### 左シフト
+
+lhs << 0 = lhs;
+
+```java
+// Shl of 0.
+if( t2.isConstant() && t2 instanceof TypeInteger i && (i.value()&63)==0 )
+    return lhs;
+
+```
+
+#### 符号なし右シフト
+
+lhs >>> 0 = lhs;
+
+```java
+// Shr of 0.
+if( t2.isConstant() && t2 instanceof TypeInteger i && (i.value()&63)==0 )
+return lhs;
+```
+
+#### XorNode:
+
+##### lhs ^ 0 = lhs;
+
+```java
+// Xor of 0.  We do not check for (0^x) because this will already
+// canonicalize to (x^0)
+if( t2.isConstant() && t2 instanceof TypeInteger i && i.value()==0 )
+    return lhs;
+
+```
+
+### 優先順位
+
+ビット演算子の優先順位は最も低くなります。たとえば次のようになります。
+
+```
+arg + 123 & 3 = (arg + 123) & 3
+```
+
+## 型の実装
+
+![整数](../chapter10/docs/type-integer.svg)の `TypeInteger` クラスを作り直し、min/max 値のあらゆる範囲をサポートします。今のところ、プログラマーに公開するのはサイズが2のべき乗になる一部の範囲だけですが、最適化器の内部ではすべての範囲をサポートします。MEET 操作は最小値の最小と最大値の最大を取ります。DUAL 操作は最小値と最大値を入れ替えます。
+
+例: 定数 `0` は `[0...0]` です。
+
+例: `bool` 型は範囲 `[0...1]` を持ちます。
+
+例: `u8` 型は範囲 `[0...255]` を持ちます。
+
+例: `i8` 型は範囲 `[-128...127]` を持ちます。
+
+例: `bool` の `dual` は `[1...0]` です（最小値と最大値を交換するだけです）。
+
+ここで導入する![浮動小数点](../docs/type-float.svg)の `TypeFloat` クラスは、32ビットと64ビットの両方のサイズをサポートします。
+
+整数範囲の図は模式図で、取り得る範囲の例としてブール値の範囲とその双対を示しています。ほかの領域は、前の章の名前付き構造体、null 許容ポインタ、精密なメモリエイリアスを維持します。
+
+![グラフ1](./docs/lattice.svg)
+
+### meet:
+
+2つの範囲の Meet は次の通りです。
+
+```java
+@Override
+public Type xmeet(Type other) {
+// Invariant from caller: 'this' != 'other' and same class (TypeInteger)
+TypeInteger i = (TypeInteger)other; // Contract
+return make(Math.min(_min,i._min), Math.max(_max,i._max));
+}
+```
+
+これによって、どちらかの範囲内に起こり得るすべての値を組み合わせます。また、実装もごく単純です。
+
+[^1]: Hacker's delight.
+    4-2 Propagating Bounds through Adds and Subtracts
+
+次の章では、これらの数値型を配列の長さ、添字、バイト配列を含む要素の格納に使います。
diff --git a/chapter14/README.md b/chapter14/README.md
index 84207f52..dbfaa549 100644
--- a/chapter14/README.md
+++ b/chapter14/README.md
@@ -1,5 +1,7 @@
 # Chapter 14: Numeric Types
 
+English | [日本語](README.ja.md)
+
 [Previous: Chapter 13](../chapter13/README.md) |
 [Next: Chapter 15](../chapter15/README.md)
 
diff --git a/chapter14/docs/14-grammar.ja.md b/chapter14/docs/14-grammar.ja.md
new file mode 100644
index 00000000..0b52ecdd
--- /dev/null
+++ b/chapter14/docs/14-grammar.ja.md
@@ -0,0 +1,128 @@
+# 第14章の文法
+
+[English](14-grammar.md) | 日本語
+
+この文書は [原文](14-grammar.md) の日本語訳です。
+
+[第14章に戻る](../README.ja.md)
+
+```antlrv4
+grammar SimpleLanguage;
+
+program : block EOF ;
+
+block : statement+ ;
+
+
+statement
+    : '{' block '}'
+    | returnStatement
+    | ifStatement
+    | whileStatement
+    | breakStatement
+    | continueStatement
+    | structDeclaration
+    | expressionStatement
+    ;
+
+
+returnStatement : 'return' expression ';' ;
+
+ifStatement : 'if' '(' expression ')' statement ('else' statement)? ;
+
+whileStatement : 'while' '(' expression ')' statement ;
+
+breakStatement : 'break' ';' ;
+
+continueStatement : 'continue' ';' ;
+
+
+structDeclaration : 'struct' IDENTIFIER '{' fields '}'  ;
+
+fields : field+ ;
+
+field : type IDENTIFIER ';'  ;
+
+
+expressionStatement
+    : type IDENTIFIER ';'
+    | type IDENTIFIER '=' expression ';'
+    |      IDENTIFIER '=' expression ';'
+    |                     expression
+    ;
+
+PRIMTYPE
+    : 'int'
+    | 'i8'
+    | 'i16'
+    | 'i32'
+    | 'i64'
+    | 'u8'
+    | 'u16'
+    | 'u32'
+    | 'flt'
+    | 'f32'
+    | 'f64'
+    | 'bool'
+    ;
+
+type
+    : PRIMTYPE
+    | typeName ('?')?
+    ;
+
+typeName : IDENTIFIER ;
+
+
+expression : bitWiseExpression ;
+
+bitWiseExpression
+    : comparisonExpression ( '&' | '|' | '^' ) comparisonExpression)*
+    ;
+    
+comparisonExpression
+    : shiftExpression (('==' | '!='| '>'| '<'| '>='| '<=') shiftExpression)*
+    ;
+
+shiftExpression
+    : additiveExpression ( '<<' | '>>>' | '>>' ) additiveExpression)*
+    ;
+    
+additiveExpression
+    : multiplicativeExpression (('+' | '-') multiplicativeExpression)*
+    ;
+
+multiplicativeExpression
+    : unaryExpression (('*' | '/') unaryExpression)*
+    ;
+
+unaryExpression
+    : ('-') unaryExpression
+    | '!' unaryExpression
+    | primaryExpression postFix*
+    ;
+
+primaryExpression
+    : INTEGER_LITERAL
+    | '(' expression ')'
+    | 'true'
+    | 'false'
+    | 'null'
+    | newExpression
+    | IDENTIFIER
+    ;
+
+newExpression : 'new' IDENTIFIER ;
+
+postFix : '.' IDENTIFIER [ '=' expression ] ;
+
+INTEGER_LITERAL
+    : [1-9]DIGIT*
+    | [0]
+    ;
+
+IDENTIFIER : NON_DIGIT (NON_DIGIT | DIGIT)*  ;
+
+NON_DIGIT: [a-zA-Z_];
+DIGIT: [0-9];
+```
diff --git a/chapter14/docs/14-grammar.md b/chapter14/docs/14-grammar.md
index f23f81cd..a5258925 100644
--- a/chapter14/docs/14-grammar.md
+++ b/chapter14/docs/14-grammar.md
@@ -1,5 +1,7 @@
 # Grammar for Chapter 14
 
+English | [日本語](14-grammar.ja.md)
+
 ```antlrv4
 grammar SimpleLanguage;