From: Paul Eggert <eggert@cs.ucla.edu>
Date: Tue, 19 May 2015 17:38:47 +0000 (-0700)
Subject: Try to port new etags tests to MS-Windows
X-Git-Tag: emacs-25.0.90~2047
X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=c7acb6dd92d3611918b5c5792e0df71101857916;p=emacs.git
Try to port new etags tests to MS-Windows
* test/etags/CTAGS.good, test/etags/ETAGS.good_1:
* test/etags/ETAGS.good_2, test/etags/ETAGS.good_3:
* test/etags/ETAGS.good_4, test/etags/ETAGS.good_5:
Adjust to test-case changes below.
* test/etags/Makefile (CSRC): Remove dostorture.c.
Whatever it was trying to test, wasn't working portably.
(LC_ALL): Remove. Apparently there wasn't an encoding problem,
just a line-ending problem.
* test/etags/c-src/dostorture.c: Remove.
* test/etags/cp-src/c.C: Remove stray CR.
* test/etags/html-src/algrthms.html: Remove trailing CRs.
State UTF-8 as the encoding. The file is ASCII so it doesn't matter,
but if someone edits it later it should stay UTF-8-compatible.
---
diff --git a/test/etags/CTAGS.good b/test/etags/CTAGS.good
index 5a518f1ff66..d747265bcf3 100644
--- a/test/etags/CTAGS.good
+++ b/test/etags/CTAGS.good
@@ -3580,9 +3580,7 @@ not_bol c-src/emacs/src/regex.h 391
not_eol c-src/emacs/src/regex.h 394
not_single_kboard_state c-src/emacs/src/keyboard.c /^not_single_kboard_state (KBOARD *kboard)$/
notag2 c-src/torture.c 26
-notag2 c-src/dostorture.c 26
notag4 c-src/torture.c 45
-notag4 c-src/dostorture.c 45
notinname c-src/etags.c /^#define notinname(c) (_nin[CHAR (c)]) \/* c is not /
npending c-src/emacs/src/keyboard.c 7244
ntool_bar_items c-src/emacs/src/keyboard.c 7974
@@ -3737,11 +3735,8 @@ post pyt-src/server.py /^ def post(self):$/
post pyt-src/server.py /^ def post(self):$/
pot_etags_version c-src/etags.c 81
pp1 c-src/torture.c /^int pp1($/
-pp1 c-src/dostorture.c /^int pp1($/
pp2 c-src/torture.c /^pp2$/
-pp2 c-src/dostorture.c /^pp2$/
pp3 c-src/torture.c /^pp3(int bar)$/
-pp3 c-src/dostorture.c /^pp3(int bar)$/
pp_bas_cat prol-src/natded.prolog /^pp_bas_cat(Cat):-$/
pp_cat prol-src/natded.prolog /^pp_cat(Syn:Sem):-$/
pp_exp prol-src/natded.prolog /^pp_exp('NIL'):-$/
@@ -4118,18 +4113,12 @@ tag-re-match-p el-src/emacs/lisp/progmodes/etags.el /^(defun tag-re-match-p (re)
tag-symbol-match-p el-src/emacs/lisp/progmodes/etags.el /^(defun tag-symbol-match-p (tag)$/
tag-word-match-p el-src/emacs/lisp/progmodes/etags.el /^(defun tag-word-match-p (tag)$/
tag1 c-src/torture.c /^(*tag1 (sig, handler)) ()$/
-tag1 c-src/dostorture.c /^(*tag1 (sig, handler)) ()$/
tag1 c-src/h.h 110
tag2 c-src/torture.c /^(*tag2 (sig, handler)) ()$/
-tag2 c-src/dostorture.c /^(*tag2 (sig, handler)) ()$/
tag3 c-src/torture.c /^(*tag3 (int sig, void (*handler) (int))) (int)$/
-tag3 c-src/dostorture.c /^(*tag3 (int sig, void (*handler) (int))) (int)$/
tag4 c-src/torture.c /^(*tag4 (int sig, void (*handler) (int))) (int)$/
-tag4 c-src/dostorture.c /^(*tag4 (int sig, void (*handler) (int))) (int)$/
tag5 c-src/torture.c /^tag5 (handler, arg)$/
-tag5 c-src/dostorture.c /^tag5 (handler, arg)$/
tag6 c-src/torture.c /^tag6 (void (*handler) (void *), void *arg)$/
-tag6 c-src/dostorture.c /^tag6 (void (*handler) (void *), void *arg)$/
tag_or_ch c-src/emacs/src/lisp.h 3026
taggedfname c-src/etags.c 207
tags-add-tables el-src/emacs/lisp/progmodes/etags.el /^(defcustom tags-add-tables 'ask-user$/
diff --git a/test/etags/ETAGS.good_1 b/test/etags/ETAGS.good_1
index 7ccc5a06bb1..370d0574781 100644
--- a/test/etags/ETAGS.good_1
+++ b/test/etags/ETAGS.good_1
@@ -579,19 +579,6 @@ char **tab_fill(tab_fill70,1129
int tab_delete_first(91,1638
int tab_count_words(103,1820
-c-src/dostorture.c,198
-(*tag1 tag118,468
-#define notag2 26,577
-(*tag2 tag229,657
-(*tag3 tag339,809
-#define notag4 45,904
-(*tag4 tag448,1001
-tag5 57,1136
-tag6 66,1272
-int pp1(74,1389
-pp287,1504
-pp3(100,1616
-
c-src/emacs/src/gmalloc.c,3539
#define USE_PTHREAD25,1002
#undef get_current_dir_name33,1126
@@ -1909,46 +1896,46 @@ template <class C, int n> class AT 52,1668
class AU 53,1716
class B<B54,1735
class B<int> { void f(B::f54,1735
-const A::B::T& abt 55,1766
-class A 56,1792
-class A { class B A::B56,1792
-class A 57,1827
- A operator+(A::operator+59,1861
-is_muldiv_operation(61,1888
-domain foo 68,1956
- void f(foo::f69,1969
-void A::A(72,1990
-struct A 73,2005
-struct B 74,2023
-void B::B(75,2042
-void BE_Node::BE_Node(76,2057
-class BE_Node 77,2084
-struct foo 79,2103
-class test 86,2157
- int f(test::f87,2170
- int ff(test::ff89,2232
- int g(test::g90,2255
-class AST_Root 92,2279
-AST_ConcreteType::AST_ConcreteType(99,2394
-AST_Array::AST_Array(107,2533
- void f(::f115,2734
-struct A 117,2754
-A::~A(120,2778
-struct B 122,2790
- ~B(B::~B123,2801
-enum {dog,::dog126,2818
-enum {dog, cat}::cat126,2818
-enum {dog, cat} animals;126,2818
-struct {int teats;} cow;127,2843
-class Boo 129,2869
- enum {dog,Boo::dog130,2881
- enum {dog, cat}Boo::cat130,2881
- foo(Boo::foo133,2955
- Boo(Boo::Boo137,2996
-Boo::Boo(141,3071
-typedef int should_see_this_one_enclosed_in_extern_C;149,3156
-typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3229
-typedef int should_see_this_array_type[should_see_this_array_type156,3311
+const A::B::T& abt 55,1765
+class A 56,1791
+class A { class B A::B56,1791
+class A 57,1826
+ A operator+(A::operator+59,1860
+is_muldiv_operation(61,1887
+domain foo 68,1955
+ void f(foo::f69,1968
+void A::A(72,1989
+struct A 73,2004
+struct B 74,2022
+void B::B(75,2041
+void BE_Node::BE_Node(76,2056
+class BE_Node 77,2083
+struct foo 79,2102
+class test 86,2156
+ int f(test::f87,2169
+ int ff(test::ff89,2231
+ int g(test::g90,2254
+class AST_Root 92,2278
+AST_ConcreteType::AST_ConcreteType(99,2393
+AST_Array::AST_Array(107,2532
+ void f(::f115,2733
+struct A 117,2753
+A::~A(120,2777
+struct B 122,2789
+ ~B(B::~B123,2800
+enum {dog,::dog126,2817
+enum {dog, cat}::cat126,2817
+enum {dog, cat} animals;126,2817
+struct {int teats;} cow;127,2842
+class Boo 129,2868
+ enum {dog,Boo::dog130,2880
+ enum {dog, cat}Boo::cat130,2880
+ foo(Boo::foo133,2954
+ Boo(Boo::Boo137,2995
+Boo::Boo(141,3070
+typedef int should_see_this_one_enclosed_in_extern_C;149,3155
+typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3228
+typedef int should_see_this_array_type[should_see_this_array_type156,3310
cp-src/burton.cpp,103
::dummy::dummy test::dummy1(1,0
@@ -2291,15 +2278,15 @@ Comunicati e iniziative32,976
Ultime notizie dall'associazione63,2030
html-src/algrthms.html,467
-Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,282
-Descriptionalgorithms10,486
-Generating the Datagenalgorithm48,2000
-Convolutionallyconalgorithm55,2517
-Nextstatetable262,11592
-Outputoutputtable350,13920
-Mapping the Channel Symbolsmapping433,16218
-Adding Noise to theaddnoise439,16612
-Quantizing the Receivedquantizing469,19105
+Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,271
+Descriptionalgorithms10,472
+Generating the Datagenalgorithm48,1948
+Convolutionallyconalgorithm55,2458
+Nextstatetable262,11326
+Outputoutputtable350,13566
+Mapping the Channel Symbolsmapping433,15781
+Adding Noise to theaddnoise439,16169
+Quantizing the Receivedquantizing469,18632
html-src/software.html,439
Francesco Potortì Software Page9,280
diff --git a/test/etags/ETAGS.good_2 b/test/etags/ETAGS.good_2
index bd20d149e46..b09e61e5628 100644
--- a/test/etags/ETAGS.good_2
+++ b/test/etags/ETAGS.good_2
@@ -646,19 +646,6 @@ char **tab_fill(tab_fill70,1129
int tab_delete_first(91,1638
int tab_count_words(103,1820
-c-src/dostorture.c,198
-(*tag1 tag118,468
-#define notag2 26,577
-(*tag2 tag229,657
-(*tag3 tag339,809
-#define notag4 45,904
-(*tag4 tag448,1001
-tag5 57,1136
-tag6 66,1272
-int pp1(74,1389
-pp287,1504
-pp3(100,1616
-
c-src/emacs/src/gmalloc.c,6643
#define USE_PTHREAD25,1002
#undef get_current_dir_name33,1126
@@ -2415,53 +2402,53 @@ template <class C, int n> class AT 52,1668
class AU 53,1716
class B<B54,1735
class B<int> { void f(B::f54,1735
-const A::B::T& abt 55,1766
-class A 56,1792
-class A { class B A::B56,1792
-class A { class B { int f(A::B::f56,1792
-class A 57,1827
- int get_data(A::get_data58,1837
- A operator+(A::operator+59,1861
-is_muldiv_operation(61,1888
-domain foo 68,1956
- void f(foo::f69,1969
-void A::A(72,1990
-struct A 73,2005
-struct A { A(A::A73,2005
-struct B 74,2023
-struct B { B(B::B74,2023
-void B::B(75,2042
-void BE_Node::BE_Node(76,2057
-class BE_Node 77,2084
-struct foo 79,2103
-class test 86,2157
- int f(test::f87,2170
- int ff(test::ff89,2232
- int g(test::g90,2255
-class AST_Root 92,2279
-class AST_Root;96,2328
-AST_ConcreteType::AST_ConcreteType(99,2394
-AST_Array::AST_Array(107,2533
- void f(::f115,2734
-struct A 117,2754
- ~A(A::~A118,2765
-A::~A(120,2778
-struct B 122,2790
- ~B(B::~B123,2801
-enum {dog,::dog126,2818
-enum {dog, cat}::cat126,2818
-enum {dog, cat} animals;126,2818
-struct {int teats;} cow;127,2843
-class Boo 129,2869
- enum {dog,Boo::dog130,2881
- enum {dog, cat}Boo::cat130,2881
- foo(Boo::foo133,2955
- Boo(Boo::Boo137,2996
- Boo(Boo::Boo138,3053
-Boo::Boo(141,3071
-typedef int should_see_this_one_enclosed_in_extern_C;149,3156
-typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3229
-typedef int should_see_this_array_type[should_see_this_array_type156,3311
+const A::B::T& abt 55,1765
+class A 56,1791
+class A { class B A::B56,1791
+class A { class B { int f(A::B::f56,1791
+class A 57,1826
+ int get_data(A::get_data58,1836
+ A operator+(A::operator+59,1860
+is_muldiv_operation(61,1887
+domain foo 68,1955
+ void f(foo::f69,1968
+void A::A(72,1989
+struct A 73,2004
+struct A { A(A::A73,2004
+struct B 74,2022
+struct B { B(B::B74,2022
+void B::B(75,2041
+void BE_Node::BE_Node(76,2056
+class BE_Node 77,2083
+struct foo 79,2102
+class test 86,2156
+ int f(test::f87,2169
+ int ff(test::ff89,2231
+ int g(test::g90,2254
+class AST_Root 92,2278
+class AST_Root;96,2327
+AST_ConcreteType::AST_ConcreteType(99,2393
+AST_Array::AST_Array(107,2532
+ void f(::f115,2733
+struct A 117,2753
+ ~A(A::~A118,2764
+A::~A(120,2777
+struct B 122,2789
+ ~B(B::~B123,2800
+enum {dog,::dog126,2817
+enum {dog, cat}::cat126,2817
+enum {dog, cat} animals;126,2817
+struct {int teats;} cow;127,2842
+class Boo 129,2868
+ enum {dog,Boo::dog130,2880
+ enum {dog, cat}Boo::cat130,2880
+ foo(Boo::foo133,2954
+ Boo(Boo::Boo137,2995
+ Boo(Boo::Boo138,3052
+Boo::Boo(141,3070
+typedef int should_see_this_one_enclosed_in_extern_C;149,3155
+typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3228
+typedef int should_see_this_array_type[should_see_this_array_type156,3310
cp-src/burton.cpp,103
::dummy::dummy test::dummy1(1,0
@@ -2858,15 +2845,15 @@ Comunicati e iniziative32,976
Ultime notizie dall'associazione63,2030
html-src/algrthms.html,467
-Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,282
-Descriptionalgorithms10,486
-Generating the Datagenalgorithm48,2000
-Convolutionallyconalgorithm55,2517
-Nextstatetable262,11592
-Outputoutputtable350,13920
-Mapping the Channel Symbolsmapping433,16218
-Adding Noise to theaddnoise439,16612
-Quantizing the Receivedquantizing469,19105
+Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,271
+Descriptionalgorithms10,472
+Generating the Datagenalgorithm48,1948
+Convolutionallyconalgorithm55,2458
+Nextstatetable262,11326
+Outputoutputtable350,13566
+Mapping the Channel Symbolsmapping433,15781
+Adding Noise to theaddnoise439,16169
+Quantizing the Receivedquantizing469,18632
html-src/software.html,439
Francesco Potortì Software Page9,280
diff --git a/test/etags/ETAGS.good_3 b/test/etags/ETAGS.good_3
index b3abf5f3915..5a9a2bfc25b 100644
--- a/test/etags/ETAGS.good_3
+++ b/test/etags/ETAGS.good_3
@@ -648,19 +648,6 @@ char **tab_fill(tab_fill70,1129
int tab_delete_first(91,1638
int tab_count_words(103,1820
-c-src/dostorture.c,198
-(*tag1 tag118,468
-#define notag2 26,577
-(*tag2 tag229,657
-(*tag3 tag339,809
-#define notag4 45,904
-(*tag4 tag448,1001
-tag5 57,1136
-tag6 66,1272
-int pp1(74,1389
-pp287,1504
-pp3(100,1616
-
c-src/emacs/src/gmalloc.c,4207
#define USE_PTHREAD25,1002
#undef get_current_dir_name33,1126
@@ -2199,54 +2186,54 @@ class AU 53,1716
class AU { T x;AU::x53,1716
class B<B54,1735
class B<int> { void f(B::f54,1735
-const A::B::T& abt 55,1766
-class A 56,1792
-class A { class B A::B56,1792
-class A 57,1827
- A operator+(A::operator+59,1861
-is_muldiv_operation(61,1888
-domain foo 68,1956
- void f(foo::f69,1969
-void A::A(72,1990
-struct A 73,2005
-struct B 74,2023
-void B::B(75,2042
-void BE_Node::BE_Node(76,2057
-class BE_Node 77,2084
-struct foo 79,2103
- int x;foo::x80,2116
-class test 86,2157
- int f(test::f87,2170
- int ff(test::ff89,2232
- int g(test::g90,2255
-class AST_Root 92,2279
-AST_ConcreteType::AST_ConcreteType(99,2394
-AST_Array::AST_Array(107,2533
- void f(::f115,2734
-struct A 117,2754
-A::~A(120,2778
-struct B 122,2790
- ~B(B::~B123,2801
-enum {dog,::dog126,2818
-enum {dog, cat}::cat126,2818
-enum {dog, cat} animals;126,2818
-struct {int teats;::teats127,2843
-struct {int teats;} cow;127,2843
-class Boo 129,2869
- enum {dog,Boo::dog130,2881
- enum {dog, cat}Boo::cat130,2881
- enum {dog, cat} animals;Boo::animals130,2881
- struct {int treats;Boo::treats131,2910
- struct {int treats;} cow;Boo::cow131,2910
- int i,Boo::i132,2940
- int i,a,Boo::a132,2940
- int i,a,b;Boo::b132,2940
- foo(Boo::foo133,2955
- Boo(Boo::Boo137,2996
-Boo::Boo(141,3071
-typedef int should_see_this_one_enclosed_in_extern_C;149,3156
-typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3229
-typedef int should_see_this_array_type[should_see_this_array_type156,3311
+const A::B::T& abt 55,1765
+class A 56,1791
+class A { class B A::B56,1791
+class A 57,1826
+ A operator+(A::operator+59,1860
+is_muldiv_operation(61,1887
+domain foo 68,1955
+ void f(foo::f69,1968
+void A::A(72,1989
+struct A 73,2004
+struct B 74,2022
+void B::B(75,2041
+void BE_Node::BE_Node(76,2056
+class BE_Node 77,2083
+struct foo 79,2102
+ int x;foo::x80,2115
+class test 86,2156
+ int f(test::f87,2169
+ int ff(test::ff89,2231
+ int g(test::g90,2254
+class AST_Root 92,2278
+AST_ConcreteType::AST_ConcreteType(99,2393
+AST_Array::AST_Array(107,2532
+ void f(::f115,2733
+struct A 117,2753
+A::~A(120,2777
+struct B 122,2789
+ ~B(B::~B123,2800
+enum {dog,::dog126,2817
+enum {dog, cat}::cat126,2817
+enum {dog, cat} animals;126,2817
+struct {int teats;::teats127,2842
+struct {int teats;} cow;127,2842
+class Boo 129,2868
+ enum {dog,Boo::dog130,2880
+ enum {dog, cat}Boo::cat130,2880
+ enum {dog, cat} animals;Boo::animals130,2880
+ struct {int treats;Boo::treats131,2909
+ struct {int treats;} cow;Boo::cow131,2909
+ int i,Boo::i132,2939
+ int i,a,Boo::a132,2939
+ int i,a,b;Boo::b132,2939
+ foo(Boo::foo133,2954
+ Boo(Boo::Boo137,2995
+Boo::Boo(141,3070
+typedef int should_see_this_one_enclosed_in_extern_C;149,3155
+typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3228
+typedef int should_see_this_array_type[should_see_this_array_type156,3310
cp-src/burton.cpp,103
::dummy::dummy test::dummy1(1,0
@@ -2608,15 +2595,15 @@ Comunicati e iniziative32,976
Ultime notizie dall'associazione63,2030
html-src/algrthms.html,467
-Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,282
-Descriptionalgorithms10,486
-Generating the Datagenalgorithm48,2000
-Convolutionallyconalgorithm55,2517
-Nextstatetable262,11592
-Outputoutputtable350,13920
-Mapping the Channel Symbolsmapping433,16218
-Adding Noise to theaddnoise439,16612
-Quantizing the Receivedquantizing469,19105
+Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,271
+Descriptionalgorithms10,472
+Generating the Datagenalgorithm48,1948
+Convolutionallyconalgorithm55,2458
+Nextstatetable262,11326
+Outputoutputtable350,13566
+Mapping the Channel Symbolsmapping433,15781
+Adding Noise to theaddnoise439,16169
+Quantizing the Receivedquantizing469,18632
html-src/software.html,439
Francesco Potortì Software Page9,280
diff --git a/test/etags/ETAGS.good_4 b/test/etags/ETAGS.good_4
index 438e8b573a8..f6023ea7b3d 100644
--- a/test/etags/ETAGS.good_4
+++ b/test/etags/ETAGS.good_4
@@ -603,19 +603,6 @@ char **tab_fill(tab_fill70,1129
int tab_delete_first(91,1638
int tab_count_words(103,1820
-c-src/dostorture.c,198
-(*tag1 tag118,468
-#define notag2 26,577
-(*tag2 tag229,657
-(*tag3 tag339,809
-#define notag4 45,904
-(*tag4 tag448,1001
-tag5 57,1136
-tag6 66,1272
-int pp1(74,1389
-pp287,1504
-pp3(100,1616
-
c-src/emacs/src/gmalloc.c,3539
#define USE_PTHREAD25,1002
#undef get_current_dir_name33,1126
@@ -2073,46 +2060,46 @@ template <class C, int n> class AT 52,1668
class AU 53,1716
class B<B54,1735
class B<int> { void f(B::f54,1735
-const A::B::T& abt 55,1766
-class A 56,1792
-class A { class B A::B56,1792
-class A 57,1827
- A operator+(A::operator+59,1861
-is_muldiv_operation(61,1888
-domain foo 68,1956
- void f(foo::f69,1969
-void A::A(72,1990
-struct A 73,2005
-struct B 74,2023
-void B::B(75,2042
-void BE_Node::BE_Node(76,2057
-class BE_Node 77,2084
-struct foo 79,2103
-class test 86,2157
- int f(test::f87,2170
- int ff(test::ff89,2232
- int g(test::g90,2255
-class AST_Root 92,2279
-AST_ConcreteType::AST_ConcreteType(99,2394
-AST_Array::AST_Array(107,2533
- void f(::f115,2734
-struct A 117,2754
-A::~A(120,2778
-struct B 122,2790
- ~B(B::~B123,2801
-enum {dog,::dog126,2818
-enum {dog, cat}::cat126,2818
-enum {dog, cat} animals;126,2818
-struct {int teats;} cow;127,2843
-class Boo 129,2869
- enum {dog,Boo::dog130,2881
- enum {dog, cat}Boo::cat130,2881
- foo(Boo::foo133,2955
- Boo(Boo::Boo137,2996
-Boo::Boo(141,3071
-typedef int should_see_this_one_enclosed_in_extern_C;149,3156
-typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3229
-typedef int should_see_this_array_type[should_see_this_array_type156,3311
+const A::B::T& abt 55,1765
+class A 56,1791
+class A { class B A::B56,1791
+class A 57,1826
+ A operator+(A::operator+59,1860
+is_muldiv_operation(61,1887
+domain foo 68,1955
+ void f(foo::f69,1968
+void A::A(72,1989
+struct A 73,2004
+struct B 74,2022
+void B::B(75,2041
+void BE_Node::BE_Node(76,2056
+class BE_Node 77,2083
+struct foo 79,2102
+class test 86,2156
+ int f(test::f87,2169
+ int ff(test::ff89,2231
+ int g(test::g90,2254
+class AST_Root 92,2278
+AST_ConcreteType::AST_ConcreteType(99,2393
+AST_Array::AST_Array(107,2532
+ void f(::f115,2733
+struct A 117,2753
+A::~A(120,2777
+struct B 122,2789
+ ~B(B::~B123,2800
+enum {dog,::dog126,2817
+enum {dog, cat}::cat126,2817
+enum {dog, cat} animals;126,2817
+struct {int teats;} cow;127,2842
+class Boo 129,2868
+ enum {dog,Boo::dog130,2880
+ enum {dog, cat}Boo::cat130,2880
+ foo(Boo::foo133,2954
+ Boo(Boo::Boo137,2995
+Boo::Boo(141,3070
+typedef int should_see_this_one_enclosed_in_extern_C;149,3155
+typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3228
+typedef int should_see_this_array_type[should_see_this_array_type156,3310
cp-src/burton.cpp,103
::dummy::dummy test::dummy1(1,0
@@ -2455,15 +2442,15 @@ Comunicati e iniziative32,976
Ultime notizie dall'associazione63,2030
html-src/algrthms.html,467
-Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,282
-Descriptionalgorithms10,486
-Generating the Datagenalgorithm48,2000
-Convolutionallyconalgorithm55,2517
-Nextstatetable262,11592
-Outputoutputtable350,13920
-Mapping the Channel Symbolsmapping433,16218
-Adding Noise to theaddnoise439,16612
-Quantizing the Receivedquantizing469,19105
+Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,271
+Descriptionalgorithms10,472
+Generating the Datagenalgorithm48,1948
+Convolutionallyconalgorithm55,2458
+Nextstatetable262,11326
+Outputoutputtable350,13566
+Mapping the Channel Symbolsmapping433,15781
+Adding Noise to theaddnoise439,16169
+Quantizing the Receivedquantizing469,18632
html-src/software.html,439
Francesco Potortì Software Page9,280
diff --git a/test/etags/ETAGS.good_5 b/test/etags/ETAGS.good_5
index b4b27504663..b6bb6260c75 100644
--- a/test/etags/ETAGS.good_5
+++ b/test/etags/ETAGS.good_5
@@ -739,19 +739,6 @@ char **tab_fill(tab_fill70,1129
int tab_delete_first(91,1638
int tab_count_words(103,1820
-c-src/dostorture.c,198
-(*tag1 tag118,468
-#define notag2 26,577
-(*tag2 tag229,657
-(*tag3 tag339,809
-#define notag4 45,904
-(*tag4 tag448,1001
-tag5 57,1136
-tag6 66,1272
-int pp1(74,1389
-pp287,1504
-pp3(100,1616
-
c-src/emacs/src/gmalloc.c,7311
#define USE_PTHREAD25,1002
#undef get_current_dir_name33,1126
@@ -2869,61 +2856,61 @@ class AU 53,1716
class AU { T x;AU::x53,1716
class B<B54,1735
class B<int> { void f(B::f54,1735
-const A::B::T& abt 55,1766
-class A 56,1792
-class A { class B A::B56,1792
-class A { class B { int f(A::B::f56,1792
-class A 57,1827
- int get_data(A::get_data58,1837
- A operator+(A::operator+59,1861
-is_muldiv_operation(61,1888
-domain foo 68,1956
- void f(foo::f69,1969
-void A::A(72,1990
-struct A 73,2005
-struct A { A(A::A73,2005
-struct B 74,2023
-struct B { B(B::B74,2023
-void B::B(75,2042
-void BE_Node::BE_Node(76,2057
-class BE_Node 77,2084
-struct foo 79,2103
- int x;foo::x80,2116
-class test 86,2157
- int f(test::f87,2170
- int ff(test::ff89,2232
- int g(test::g90,2255
-class AST_Root 92,2279
-class AST_Root;96,2328
-AST_ConcreteType::AST_ConcreteType(99,2394
-AST_Array::AST_Array(107,2533
- void f(::f115,2734
-struct A 117,2754
- ~A(A::~A118,2765
-A::~A(120,2778
-struct B 122,2790
- ~B(B::~B123,2801
-enum {dog,::dog126,2818
-enum {dog, cat}::cat126,2818
-enum {dog, cat} animals;126,2818
-struct {int teats;::teats127,2843
-struct {int teats;} cow;127,2843
-class Boo 129,2869
- enum {dog,Boo::dog130,2881
- enum {dog, cat}Boo::cat130,2881
- enum {dog, cat} animals;Boo::animals130,2881
- struct {int treats;Boo::treats131,2910
- struct {int treats;} cow;Boo::cow131,2910
- int i,Boo::i132,2940
- int i,a,Boo::a132,2940
- int i,a,b;Boo::b132,2940
- foo(Boo::foo133,2955
- Boo(Boo::Boo137,2996
- Boo(Boo::Boo138,3053
-Boo::Boo(141,3071
-typedef int should_see_this_one_enclosed_in_extern_C;149,3156
-typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3229
-typedef int should_see_this_array_type[should_see_this_array_type156,3311
+const A::B::T& abt 55,1765
+class A 56,1791
+class A { class B A::B56,1791
+class A { class B { int f(A::B::f56,1791
+class A 57,1826
+ int get_data(A::get_data58,1836
+ A operator+(A::operator+59,1860
+is_muldiv_operation(61,1887
+domain foo 68,1955
+ void f(foo::f69,1968
+void A::A(72,1989
+struct A 73,2004
+struct A { A(A::A73,2004
+struct B 74,2022
+struct B { B(B::B74,2022
+void B::B(75,2041
+void BE_Node::BE_Node(76,2056
+class BE_Node 77,2083
+struct foo 79,2102
+ int x;foo::x80,2115
+class test 86,2156
+ int f(test::f87,2169
+ int ff(test::ff89,2231
+ int g(test::g90,2254
+class AST_Root 92,2278
+class AST_Root;96,2327
+AST_ConcreteType::AST_ConcreteType(99,2393
+AST_Array::AST_Array(107,2532
+ void f(::f115,2733
+struct A 117,2753
+ ~A(A::~A118,2764
+A::~A(120,2777
+struct B 122,2789
+ ~B(B::~B123,2800
+enum {dog,::dog126,2817
+enum {dog, cat}::cat126,2817
+enum {dog, cat} animals;126,2817
+struct {int teats;::teats127,2842
+struct {int teats;} cow;127,2842
+class Boo 129,2868
+ enum {dog,Boo::dog130,2880
+ enum {dog, cat}Boo::cat130,2880
+ enum {dog, cat} animals;Boo::animals130,2880
+ struct {int treats;Boo::treats131,2909
+ struct {int treats;} cow;Boo::cow131,2909
+ int i,Boo::i132,2939
+ int i,a,Boo::a132,2939
+ int i,a,b;Boo::b132,2939
+ foo(Boo::foo133,2954
+ Boo(Boo::Boo137,2995
+ Boo(Boo::Boo138,3052
+Boo::Boo(141,3070
+typedef int should_see_this_one_enclosed_in_extern_C;149,3155
+typedef int (*should_see_this_function_pointer)should_see_this_function_pointer153,3228
+typedef int should_see_this_array_type[should_see_this_array_type156,3310
cp-src/burton.cpp,103
::dummy::dummy test::dummy1(1,0
@@ -3339,15 +3326,15 @@ Comunicati e iniziative32,976
Ultime notizie dall'associazione63,2030
html-src/algrthms.html,467
-Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,282
-Descriptionalgorithms10,486
-Generating the Datagenalgorithm48,2000
-Convolutionallyconalgorithm55,2517
-Nextstatetable262,11592
-Outputoutputtable350,13920
-Mapping the Channel Symbolsmapping433,16218
-Adding Noise to theaddnoise439,16612
-Quantizing the Receivedquantizing469,19105
+Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms7,271
+Descriptionalgorithms10,472
+Generating the Datagenalgorithm48,1948
+Convolutionallyconalgorithm55,2458
+Nextstatetable262,11326
+Outputoutputtable350,13566
+Mapping the Channel Symbolsmapping433,15781
+Adding Noise to theaddnoise439,16169
+Quantizing the Receivedquantizing469,18632
html-src/software.html,439
Francesco Potortì Software Page9,280
diff --git a/test/etags/Makefile b/test/etags/Makefile
index 4a01c280bf0..99ad41ebaab 100644
--- a/test/etags/Makefile
+++ b/test/etags/Makefile
@@ -1,7 +1,7 @@
ADASRC=$(addprefix ./ada-src/,etags-test-for.ada 2ataspri.adb 2ataspri.ads waroquiers.ada)
ASRC=$(addprefix ./a-src/,empty.zz empty.zz.gz)
CSRC=$(addprefix ./c-src/,abbrev.c .//c.c torture.c getopt.h etags.c\
- exit.c exit.strange_suffix sysdep.h tab.c dostorture.c\
+ exit.c exit.strange_suffix sysdep.h tab.c\
emacs/src/gmalloc.c emacs/src/regex.h emacs/src/keyboard.c emacs/src/lisp.h\
machsyscalls.c machsyscalls.h fail.c a/b/b.c) ../etags/c-src/h.h
CPSRC=$(addprefix ./cp-src/,c.C burton.cpp burton.cpp\
@@ -44,14 +44,6 @@ ARGS=- < srclist
infiles = $(filter-out ${NONSRCS},${SRCS}) srclist regexfile
-# Although this test uses UTF-8 data, some platforms lack UTF-8 locales.
-# If the current locale isn't known to use UTF-8, fall back on the C locale.
-# Although the C locale in theory is not safe for UTF-8 data, in practice
-# it should be good enough.
-ifneq ($(shell locale -k charmap), charmap="UTF-8")
- export LC_ALL = C
-endif
-
.PHONY: check cdiff ETAGS CTAGS
# Can't make ediff_1 through ediff_5 .PHONY, as they're implicit.
diff --git a/test/etags/c-src/dostorture.c b/test/etags/c-src/dostorture.c
deleted file mode 100644
index 5190734e0fe..00000000000
--- a/test/etags/c-src/dostorture.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/* Date: Thu, 05 Aug 1993 20:28:03 +0200
- From: "Tom R.Hageman" <tom@basil.icce.rug.nl>
- Subject: more etags torture;-) [etags 7.3 patch#3]
- To: pot@CNUCE.CNR.IT
-
- Hi,
-
- This test file illustrates some more problems with etags (7.3):
-
-
- 1. parentheses are confusing,
- 2. preprocessor directives can disrupt other state machines. */
-
-/* A small torture test for etags. */
-
-/* The classic parenthesis nightmare, based on signal(). */
-void
-(*tag1 (sig, handler)) ()
- int sig;
- void (*handler) ();
-{
- (*handler)(sig);
- return handler;
-}
-
-#define notag2 void
-/* The classic, with user-defined return type. */
-notag2
-(*tag2 (sig, handler)) ()
- int sig;
- void (*handler) ();
-{
- (*handler)(sig);
- return handler;
-}
-
-/* The classic, in ANSI C style. */
-void
-(*tag3 (int sig, void (*handler) (int))) (int)
-{
- (*handler)(sig);
- return handler;
-}
-
-#define notag4 void
-/* The classic, with user-defined return type, in ANSI C style. */
-notag4
-(*tag4 (int sig, void (*handler) (int))) (int)
-{
- (*handler)(sig);
- return handler;
-}
-
-
-/* A less tortuous example. */
-void
-tag5 (handler, arg)
-void (*handler)();
-void *arg;
-{
- (*handler)(arg);
-}
-
-/* A less tortuous example, in ANSI C style. */
-void
-tag6 (void (*handler) (void *), void *arg)
-{
- (*handler)(arg);
-}
-
-
-/* Interfering preprocessing torture */
-
-int pp1(
-#if (__STDC__)
- int
-#endif
- bar)
-#if (!__STDC__)
- int bar;
-#endif
-{
- return bar;
-}
-
-int
-pp2
-#if __STDC__
- (int bar)
-#else
- (bar)
- int bar;
-#endif
-{
- return bar;
-}
-
-int
-#if __STDC__
-pp3(int bar)
-#else
-pp3(bar)
- int bar;
-#endif
-{
- return bar;
-}
diff --git a/test/etags/cp-src/c.C b/test/etags/cp-src/c.C
index 2c5f7e01fac..dae933a9a05 100644
--- a/test/etags/cp-src/c.C
+++ b/test/etags/cp-src/c.C
@@ -51,7 +51,7 @@ int A<int>::f(A<int>* x) {}
A<float,B<int> > A<B<float>,int>::f(A<int>* x) {}
template <class C, int n> class AT { C t[n]; };
class AU { T x; };
-class B<int> { void f() {} };
+class B<int> { void f() {} };
const A::B::T& abt = abc;
class A { class B { int f(); }; };
class A {
diff --git a/test/etags/html-src/algrthms.html b/test/etags/html-src/algrthms.html
index 322dafa5054..f051505263c 100644
--- a/test/etags/html-src/algrthms.html
+++ b/test/etags/html-src/algrthms.html
@@ -1,519 +1,519 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
- <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
- <meta name="Author" content="Chip Fleming">
- <meta name="GENERATOR" content="Mozilla/4.7 [en] (Win95; U) [Netscape]">
- <title>Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms</title>
-</head>
-<body>
-<a NAME="algorithms"></a><b><font face="Arial"><font size=+1>Description
-of the Algorithms (Part 1)</font></font></b>
-<p> The steps involved in simulating a communication channel using
-convolutional encoding and Viterbi decoding are as follows:
-<ul>
-<li>
-<a href="#genalgorithm">Generate the data</a> to be transmitted through
-the channel-result is binary data bits</li>
-
-<li>
-<a href="#conalgorithm">Convolutionally encode</a> the data-result is channel
-symbols</li>
-
-<li>
-<a href="#mapping">Map the one/zero channel symbols</a> onto an antipodal
-baseband signal, producing transmitted channel symbols</li>
-
-<li>
-<a href="#addnoise">Add noise</a> to the transmitted channel symbols-result
-is received channel symbols</li>
-
-<li>
-<a href="#quantizing">Quantize</a> the received channel levels-one bit
-quantization is called hard-decision, and two to n bit quantization is
-called soft-decision (n is usually three or four)</li>
-
-<li>
-<a href="algrthms2.html">Perform Viterbi decoding</a> on the quantized
-received channel symbols-result is again binary data bits</li>
-
-<li>
-Compare the decoded data bits to the transmitted data bits and count the
-number of errors.</li>
-</ul>
-<i>Many of you will notice that I left out the steps of modulating the
-channel symbols onto a transmitted carrier, and then demodulating the received
-carrier to recover the channel symbols. You're right, but we can accurately
-model the effects of AWGN even though we bypass those steps.</i>
-<p><a NAME="genalgorithm"></a><b><i><font face="Arial">Generating the Data</font></i></b>
-<p>Generating the data to be transmitted through the channel can be accomplished
-quite simply by using a random number generator. One that produces a uniform
-distribution of numbers on the interval 0 to a maximum value is provided
-in C: <tt>rand ()</tt>. Using this function, we can say that any value
-less than half of the maximum value is a zero; any value greater than or
-equal to half of the maximum value is a one.
-<p><a NAME="conalgorithm"></a><b><i><font face="Arial">Convolutionally
-Encoding the Data</font></i></b>
-<p>Convolutionally encoding the data is accomplished using a shift register
-and associated combinatorial logic that performs modulo-two addition. (A
-shift register is merely a chain of flip-flops wherein the output of the
-nth flip-flop is tied to the input of the (n+1)th flip-flop. Every time
-the active edge of the clock occurs, the input to the flip-flop is clocked
-through to the output, and thus the data are shifted over one stage.) The
-combinatorial logic is often in the form of cascaded exclusive-or gates.
-As a reminder, exclusive-or gates are two-input, one-output gates often
-represented by the logic symbol shown below,
-<center>
-<p><img SRC="figs/xor_gate.gif" ALT="exclusive-or gate symbol" height=64 width=93></center>
-
-<p>that implement the following truth-table:
-<br>
-<br>
-<center><table BORDER CELLPADDING=7 WIDTH="218" >
-<tr>
-<td VALIGN=TOP WIDTH="28%">
-<center><b><tt>Input A</tt></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="27%">
-<center><b><tt>Input B</tt></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="45%">
-<center><b><tt>Output</tt></b>
-<p><b><tt>(A xor B)</tt></b></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="28%">
-<center><tt>0</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="27%">
-<center><tt>0</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="45%">
-<center><tt>0</tt></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="28%">
-<center><tt>0</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="27%">
-<center><tt>1</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="45%">
-<center><tt>1</tt></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="28%">
-<center><tt>1</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="27%">
-<center><tt>0</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="45%">
-<center><tt>1</tt></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="28%">
-<center><tt>1</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="27%">
-<center><tt>1</tt></center>
-</td>
-
-<td VALIGN=TOP WIDTH="45%">
-<center><tt>0</tt></center>
-</td>
-</tr>
-</table></center>
-
-<p>The exclusive-or gate performs modulo-two addition of its inputs. When
-you cascade q two-input exclusive-or gates, with the output of the first
-one feeding one of the inputs of the second one, the output of the second
-one feeding one of the inputs of the third one, etc., the output of the
-last one in the chain is the modulo-two sum of the q + 1 inputs.
-<p>Another way to illustrate the modulo-two adder, and the way that is
-most commonly used in textbooks, is as a circle with a + symbol inside,
-thus:
-<center>
-<p><img SRC="figs/ringsum.gif" ALT="modulo-two adder symbol" height=48 width=48></center>
-
-<p>Now that we have the two basic components of the convolutional encoder
-(flip-flops comprising the shift register and exclusive-or gates comprising
-the associated modulo-two adders) defined, let's look at a picture of a
-convolutional encoder for a rate 1/2, K = 3, m = 2 code:
-<br>
-<br>
-<br>
-<center>
-<p><img SRC="figs/ce_7_5_a.gif" ALT="rate 1/2 K = 3 (7, 5) convolutional encoder" height=232 width=600></center>
-
-<p>In this encoder, data bits are provided at a rate of k bits per second.
-Channel symbols are output at a rate of n = 2k symbols per second. The
-input bit is stable during the encoder cycle. The encoder cycle starts
-when an input clock edge occurs. When the input clock edge occurs, the
-output of the left-hand flip-flop is clocked into the right-hand flip-flop,
-the previous input bit is clocked into the left-hand flip-flop, and a new
-input bit becomes available. Then the outputs of the upper and lower modulo-two
-adders become stable. The output selector (SEL A/B block) cycles through
-two states-in the first state, it selects and outputs the output of the
-upper modulo-two adder; in the second state, it selects and outputs the
-output of the lower modulo-two adder.
-<p>The encoder shown above encodes the K = 3, (7, 5) convolutional code.
-The octal numbers 7 and 5 represent the code generator polynomials, which
-when read in binary (111<sub>2</sub> and 101<sub>2</sub>) correspond to
-the shift register connections to the upper and lower modulo-two adders,
-respectively. This code has been determined to be the "best" code for rate
-1/2, K = 3. It is the code I will use for the remaining discussion and
-examples, for reasons that will become readily apparent when we get into
-the Viterbi decoder algorithm.
-<p>Let's look at an example input data stream, and the corresponding output
-data stream:
-<p>Let the input sequence be 010111001010001<sub>2</sub>.
-<p>Assume that the outputs of both of the flip-flops in the shift register
-are initially cleared, i.e. their outputs are zeroes. The first clock cycle
-makes the first input bit, a zero, available to the encoder. The flip-flop
-outputs are both zeroes. The inputs to the modulo-two adders are all zeroes,
-so the output of the encoder is 00<sub>2</sub>.
-<p>The second clock cycle makes the second input bit available to the encoder.
-The left-hand flip-flop clocks in the previous bit, which was a zero, and
-the right-hand flip-flop clocks in the zero output by the left-hand flip-flop.
-The inputs to the top modulo-two adder are 100<sub>2</sub>, so the output
-is a one. The inputs to the bottom modulo-two adder are 10<sub>2</sub>,
-so the output is also a one. So the encoder outputs 11<sub>2</sub> for
-the channel symbols.
-<p>The third clock cycle makes the third input bit, a zero, available to
-the encoder. The left-hand flip-flop clocks in the previous bit, which
-was a one, and the right-hand flip-flop clocks in the zero from two bit-times
-ago. The inputs to the top modulo-two adder are 010<sub>2</sub>, so the
-output is a one. The inputs to the bottom modulo-two adder are 00<sub>2</sub>,
-so the output is zero. So the encoder outputs 10<sub>2</sub> for the channel
-symbols.
-<p>And so on. The timing diagram shown below illustrates the process:
-<br>
-<br>
-<br>
-<center>
-<p><img SRC="figs/ce_td.gif" ALT="timing diagram for rate 1/2 convolutional encoder" height=322 width=600></center>
-
-<p><br>
-<br>
-<br>
-<p>After all of the inputs have been presented to the encoder, the output
-sequence will be:
-<p>00 11 10 00 01 10 01 11 11 10 00 10 11 00 11<sub>2</sub>.
-<p>Notice that I have paired the encoder outputs-the first bit in each
-pair is the output of the upper modulo-two adder; the second bit in each
-pair is the output of the lower modulo-two adder.
-<p>You can see from the structure of the rate 1/2 K = 3 convolutional encoder
-and from the example given above that each input bit has an effect on three
-successive pairs of output symbols. That is an extremely important point
-and that is what gives the convolutional code its error-correcting power.
-The reason why will become evident when we get into the Viterbi decoder
-algorithm.
-<p>Now if we are only going to send the 15 data bits given above, in order
-for the last bit to affect three pairs of output symbols, we need to output
-two more pairs of symbols. This is accomplished in our example encoder
-by clocking the convolutional encoder flip-flops two ( = m) more times,
-while holding the input at zero. This is called "flushing" the encoder,
-and results in two more pairs of output symbols. The final binary output
-of the encoder is thus 00 11 10 00 01 10 01 11 11 10 00 10 11 00 11 10
-11<sub>2</sub>. If we don't perform the flushing operation, the last m
-bits of the message have less error-correction capability than the first
-through (m - 1)th bits had. This is a pretty important thing to remember
-if you're going to use this FEC technique in a burst-mode environment.
-So's the step of clearing the shift register at the beginning of each burst.
-The encoder must start in a known state and end in a known state for the
-decoder to be able to reconstruct the input data sequence properly.
-<p>Now, let's look at the encoder from another perspective. You can think
-of the encoder as a simple state machine. The example encoder has two bits
-of memory, so there are four possible states. Let's give the left-hand
-flip-flop a binary weight of 2<sup>1</sup>, and the right-hand flip-flop
-a binary weight of 2<sup>0</sup>. Initially, the encoder is in the all-zeroes
-state. If the first input bit is a zero, the encoder stays in the all zeroes
-state at the next clock edge. But if the input bit is a one, the encoder
-transitions to the 10<sub>2</sub> state at the next clock edge. Then, if
-the next input bit is zero, the encoder transitions to the 01<sub>2</sub>
-state, otherwise, it transitions to the 11<sub>2</sub> state. The following
-table gives the next state given the current state and the input, with
-the states given in binary:
-<br>
-<br>
-<center><table BORDER CELLSPACING=2 CELLPADDING=7 WIDTH="282" >
-<tr>
-<td VALIGN=TOP WIDTH="33%"><font face="Arial"><font size=-1> </font></font></td>
-
-<td VALIGN=TOP COLSPAN="2" WIDTH="67%">
-<center><a NAME="statetable"></a><b><font face="Arial"><font size=-1>Next
-State, if </font></font></b></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Current State</font></font></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Input = 0:</font></font></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Input = 1:</font></font></b></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-</tr>
-</table></center>
-
-<br>
-<p>The above table is often called a state transition table. We'll refer
-to it as the <tt>next state</tt> table.<tt> </tt>Now let us look at a table
-that lists the channel output symbols, given the current state and the
-input data, which we'll refer to as the <tt>output</tt> table:
-<br>
-<br>
-<center><table BORDER CELLSPACING=2 CELLPADDING=7 WIDTH="282" >
-<tr>
-<td VALIGN=TOP WIDTH="33%"></td>
-
-<td VALIGN=TOP COLSPAN="2" WIDTH="67%">
-<center><a NAME="outputtable"></a><b><font face="Arial"><font size=-1>Output
-Symbols, if</font></font></b></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Current State</font></font></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Input = 0:</font></font></b></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><b><font face="Arial"><font size=-1>Input = 1:</font></font></b></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>00</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-</tr>
-
-<tr>
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>11</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>01</font></font></center>
-</td>
-
-<td VALIGN=TOP WIDTH="33%">
-<center><font face="Arial"><font size=-1>10</font></font></center>
-</td>
-</tr>
-</table></center>
-
-<br>
-<p>You should now see that with these two tables, you can completely describe
-the behavior of the example rate 1/2, K = 3 convolutional encoder. Note
-that both of these tables have 2<sup>(K - 1)</sup> rows, and 2<sup>k</sup>
-columns, where K is the constraint length and k is the number of bits input
-to the encoder for each cycle. These two tables will come in handy when
-we start discussing the Viterbi decoder algorithm.
-<p><a NAME="mapping"></a><b><i><font face="Arial">Mapping the Channel Symbols
-to Signal Levels</font></i></b>
-<p>Mapping the one/zero output of the convolutional encoder onto an antipodal
-baseband signaling scheme is simply a matter of translating zeroes to +1s
-and ones to -1s. This can be accomplished by performing the operation y
-= 1 - 2x on each convolutional encoder output symbol.
-<p><a NAME="addnoise"></a><b><i><font face="Arial">Adding Noise to the
-Transmitted Symbols</font></i></b>
-<p>Adding noise to the transmitted channel symbols produced by the convolutional
-encoder involves generating Gaussian random numbers, scaling the numbers
-according to the desired energy per symbol to noise density ratio, E<sub>s</sub>/N<sub>0</sub>,
-and adding the scaled Gaussian random numbers to the channel symbol values.
-<p>For the uncoded channel, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>,
-since there is one channel symbol per bit. However, for the coded
-channel, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub> + 10log<sub>10</sub>(k/n).
-For example, for rate 1/2 coding, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>
-+ 10log<sub>10</sub>(1/2) = E<sub>b</sub>/N<sub>0</sub> - 3.01 dB.
-Similarly, for rate 2/3 coding, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>
-+ 10log<sub>10</sub>(2/3) = E<sub>b</sub>/N<sub>0</sub> - 1.76 dB.
-<p>The Gaussian random number generator is the only interesting part of
-this task. C only provides a uniform random number generator, <tt>rand()</tt>.
-In order to obtain Gaussian random numbers, we take advantage of relationships
-between uniform, Rayleigh, and Gaussian distributions:
-<p>Given a uniform random variable U, a Rayleigh random variable R can
-be obtained by:
-<p><img SRC="figs/eqn01.gif" ALT="equation for Rayleigh random deviate given uniform random deviate" height=30 width=297 align=ABSCENTER>
-<p>where <img SRC="figs/eqn02.gif" height=24 width=24 align=ABSCENTER>is
-the variance of the Rayleigh random variable, and given R and a second
-uniform random variable V, two Gaussian random variables G and H can be
-obtained by
-<p><i>G</i> = <i>R</i> cos <i>U</i> and <i>H</i> = <i>R</i> sin <i>V</i>.
-<p>In the AWGN channel, the signal is corrupted by additive noise, n(t),
-which has the power spectrum <i>No</i>/2 watts/Hz. The variance <img SRC="figs/eqn02.gif" ALT="variance" height=24 width=24 align=ABSBOTTOM>of
-this noise is equal to <img SRC="figs/eqn03.gif" ALT="noise density div by two" height=22 width=38 align=TEXTTOP>.
-If we set the energy per symbol <i>E<sub>s</sub></i> equal to 1, then <img SRC="figs/eqn04.gif" ALT="equation relating variance to SNR" height=28 width=110 align=ABSBOTTOM>.
-So <img SRC="figs/eqn05.gif" ALT="equation for AWGN st dev given SNR" height=28 width=139 align=ABSCENTER>.
-<p><a NAME="quantizing"></a><b><i><font face="Arial">Quantizing the Received
-Channel Symbols</font></i></b>
-<p>An ideal Viterbi decoder would work with infinite precision, or at least
-with floating-point numbers. In practical systems, we quantize the received
-channel symbols with one or a few bits of precision in order to reduce
-the complexity of the Viterbi decoder, not to mention the circuits that
-precede it. If the received channel symbols are quantized to one-bit precision
-(< 0V = 1, <u>></u> 0V = 0), the result is called hard-decision data.
-If the received channel symbols are quantized with more than one bit of
-precision, the result is called soft-decision data. A Viterbi decoder with
-soft decision data inputs quantized to three or four bits of precision
-can perform about 2 dB better than one working with hard-decision inputs.
-The usual quantization precision is three bits. More bits provide little
-additional improvement.
-<p>The selection of the quantizing levels is an important design decision
-because it can have a significant effect on the performance of the link.
-The following is a very brief explanation of one way to set those levels.
-Let's assume our received signal levels in the absence of noise are -1V
-= 1, +1V = 0. With noise, our received signal has mean +/- 1 and standard
-deviation <img SRC="figs/eqn05.gif" ALT="equation for AWGN st dev given SNR" height=28 width=139 align=ABSCENTER>.
-Let's use a uniform, three-bit quantizer having the input/output relationship
-shown in the figure below, where D is a decision level that we will calculate
-shortly:
-<center>
-<p><img SRC="figs/quantize.gif" ALT="8-level quantizer function plot" height=342 width=384></center>
-
-<p>The decision level, D, can be calculated according to the formula <img SRC="figs/eqn06.gif" ALT="equation for quantizer decision level" height=28 width=228 align=ABSCENTER>,
-where E<sub>s</sub>/N<sub>0</sub> is the energy per symbol to noise density
-ratio<i>. (The above figure was redrawn from Figure 2 of Advanced Hardware
-Architecture's ANRS07-0795, "Soft Decision Thresholds and Effects on Viterbi
-Performance". See the </i><a href="fecbiblio.html">bibliography</a><i>
-for a link to their web pages.)</i>
-<p>Click <a href="algrthms2.html">here</a> to proceed to the description
-of the Viterbi decoding algorithm itself...
-<p>Or click on one of the links below to go to the beginning of that section:
-<p> <a href="tutorial.html">Introduction</a>
-<br> <a href="algrthms2.html">Description of the Algorithms
-(Part 2)</a>
-<br> <a href="examples.html">Simulation Source Code Examples</a>
-<br> <a href="simrslts.html">Example Simulation Results</a>
-<br> <a href="fecbiblio.html">Bibliography</a>
-<br> <a href="tutorial.html#specapps">About Spectrum Applications...</a>
-<br>
-<br>
-<br>
-<br>
-<center>
-<p><img SRC="figs/stripe.gif" height=6 width=600></center>
-
-</body>
-</html>
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+ <meta name="Author" content="Chip Fleming">
+ <meta name="GENERATOR" content="Mozilla/4.7 [en] (Win95; U) [Netscape]">
+ <title>Tutorial on Convolutional Coding with Viterbi Decoding--Description of the Data Generation, Convolutional Encoding, Channel Mapping and AWGN, and Quantizing Algorithms</title>
+</head>
+<body>
+<a NAME="algorithms"></a><b><font face="Arial"><font size=+1>Description
+of the Algorithms (Part 1)</font></font></b>
+<p> The steps involved in simulating a communication channel using
+convolutional encoding and Viterbi decoding are as follows:
+<ul>
+<li>
+<a href="#genalgorithm">Generate the data</a> to be transmitted through
+the channel-result is binary data bits</li>
+
+<li>
+<a href="#conalgorithm">Convolutionally encode</a> the data-result is channel
+symbols</li>
+
+<li>
+<a href="#mapping">Map the one/zero channel symbols</a> onto an antipodal
+baseband signal, producing transmitted channel symbols</li>
+
+<li>
+<a href="#addnoise">Add noise</a> to the transmitted channel symbols-result
+is received channel symbols</li>
+
+<li>
+<a href="#quantizing">Quantize</a> the received channel levels-one bit
+quantization is called hard-decision, and two to n bit quantization is
+called soft-decision (n is usually three or four)</li>
+
+<li>
+<a href="algrthms2.html">Perform Viterbi decoding</a> on the quantized
+received channel symbols-result is again binary data bits</li>
+
+<li>
+Compare the decoded data bits to the transmitted data bits and count the
+number of errors.</li>
+</ul>
+<i>Many of you will notice that I left out the steps of modulating the
+channel symbols onto a transmitted carrier, and then demodulating the received
+carrier to recover the channel symbols. You're right, but we can accurately
+model the effects of AWGN even though we bypass those steps.</i>
+<p><a NAME="genalgorithm"></a><b><i><font face="Arial">Generating the Data</font></i></b>
+<p>Generating the data to be transmitted through the channel can be accomplished
+quite simply by using a random number generator. One that produces a uniform
+distribution of numbers on the interval 0 to a maximum value is provided
+in C: <tt>rand ()</tt>. Using this function, we can say that any value
+less than half of the maximum value is a zero; any value greater than or
+equal to half of the maximum value is a one.
+<p><a NAME="conalgorithm"></a><b><i><font face="Arial">Convolutionally
+Encoding the Data</font></i></b>
+<p>Convolutionally encoding the data is accomplished using a shift register
+and associated combinatorial logic that performs modulo-two addition. (A
+shift register is merely a chain of flip-flops wherein the output of the
+nth flip-flop is tied to the input of the (n+1)th flip-flop. Every time
+the active edge of the clock occurs, the input to the flip-flop is clocked
+through to the output, and thus the data are shifted over one stage.) The
+combinatorial logic is often in the form of cascaded exclusive-or gates.
+As a reminder, exclusive-or gates are two-input, one-output gates often
+represented by the logic symbol shown below,
+<center>
+<p><img SRC="figs/xor_gate.gif" ALT="exclusive-or gate symbol" height=64 width=93></center>
+
+<p>that implement the following truth-table:
+<br>
+<br>
+<center><table BORDER CELLPADDING=7 WIDTH="218" >
+<tr>
+<td VALIGN=TOP WIDTH="28%">
+<center><b><tt>Input A</tt></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="27%">
+<center><b><tt>Input B</tt></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="45%">
+<center><b><tt>Output</tt></b>
+<p><b><tt>(A xor B)</tt></b></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="28%">
+<center><tt>0</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="27%">
+<center><tt>0</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="45%">
+<center><tt>0</tt></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="28%">
+<center><tt>0</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="27%">
+<center><tt>1</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="45%">
+<center><tt>1</tt></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="28%">
+<center><tt>1</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="27%">
+<center><tt>0</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="45%">
+<center><tt>1</tt></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="28%">
+<center><tt>1</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="27%">
+<center><tt>1</tt></center>
+</td>
+
+<td VALIGN=TOP WIDTH="45%">
+<center><tt>0</tt></center>
+</td>
+</tr>
+</table></center>
+
+<p>The exclusive-or gate performs modulo-two addition of its inputs. When
+you cascade q two-input exclusive-or gates, with the output of the first
+one feeding one of the inputs of the second one, the output of the second
+one feeding one of the inputs of the third one, etc., the output of the
+last one in the chain is the modulo-two sum of the q + 1 inputs.
+<p>Another way to illustrate the modulo-two adder, and the way that is
+most commonly used in textbooks, is as a circle with a + symbol inside,
+thus:
+<center>
+<p><img SRC="figs/ringsum.gif" ALT="modulo-two adder symbol" height=48 width=48></center>
+
+<p>Now that we have the two basic components of the convolutional encoder
+(flip-flops comprising the shift register and exclusive-or gates comprising
+the associated modulo-two adders) defined, let's look at a picture of a
+convolutional encoder for a rate 1/2, K = 3, m = 2 code:
+<br>
+<br>
+<br>
+<center>
+<p><img SRC="figs/ce_7_5_a.gif" ALT="rate 1/2 K = 3 (7, 5) convolutional encoder" height=232 width=600></center>
+
+<p>In this encoder, data bits are provided at a rate of k bits per second.
+Channel symbols are output at a rate of n = 2k symbols per second. The
+input bit is stable during the encoder cycle. The encoder cycle starts
+when an input clock edge occurs. When the input clock edge occurs, the
+output of the left-hand flip-flop is clocked into the right-hand flip-flop,
+the previous input bit is clocked into the left-hand flip-flop, and a new
+input bit becomes available. Then the outputs of the upper and lower modulo-two
+adders become stable. The output selector (SEL A/B block) cycles through
+two states-in the first state, it selects and outputs the output of the
+upper modulo-two adder; in the second state, it selects and outputs the
+output of the lower modulo-two adder.
+<p>The encoder shown above encodes the K = 3, (7, 5) convolutional code.
+The octal numbers 7 and 5 represent the code generator polynomials, which
+when read in binary (111<sub>2</sub> and 101<sub>2</sub>) correspond to
+the shift register connections to the upper and lower modulo-two adders,
+respectively. This code has been determined to be the "best" code for rate
+1/2, K = 3. It is the code I will use for the remaining discussion and
+examples, for reasons that will become readily apparent when we get into
+the Viterbi decoder algorithm.
+<p>Let's look at an example input data stream, and the corresponding output
+data stream:
+<p>Let the input sequence be 010111001010001<sub>2</sub>.
+<p>Assume that the outputs of both of the flip-flops in the shift register
+are initially cleared, i.e. their outputs are zeroes. The first clock cycle
+makes the first input bit, a zero, available to the encoder. The flip-flop
+outputs are both zeroes. The inputs to the modulo-two adders are all zeroes,
+so the output of the encoder is 00<sub>2</sub>.
+<p>The second clock cycle makes the second input bit available to the encoder.
+The left-hand flip-flop clocks in the previous bit, which was a zero, and
+the right-hand flip-flop clocks in the zero output by the left-hand flip-flop.
+The inputs to the top modulo-two adder are 100<sub>2</sub>, so the output
+is a one. The inputs to the bottom modulo-two adder are 10<sub>2</sub>,
+so the output is also a one. So the encoder outputs 11<sub>2</sub> for
+the channel symbols.
+<p>The third clock cycle makes the third input bit, a zero, available to
+the encoder. The left-hand flip-flop clocks in the previous bit, which
+was a one, and the right-hand flip-flop clocks in the zero from two bit-times
+ago. The inputs to the top modulo-two adder are 010<sub>2</sub>, so the
+output is a one. The inputs to the bottom modulo-two adder are 00<sub>2</sub>,
+so the output is zero. So the encoder outputs 10<sub>2</sub> for the channel
+symbols.
+<p>And so on. The timing diagram shown below illustrates the process:
+<br>
+<br>
+<br>
+<center>
+<p><img SRC="figs/ce_td.gif" ALT="timing diagram for rate 1/2 convolutional encoder" height=322 width=600></center>
+
+<p><br>
+<br>
+<br>
+<p>After all of the inputs have been presented to the encoder, the output
+sequence will be:
+<p>00 11 10 00 01 10 01 11 11 10 00 10 11 00 11<sub>2</sub>.
+<p>Notice that I have paired the encoder outputs-the first bit in each
+pair is the output of the upper modulo-two adder; the second bit in each
+pair is the output of the lower modulo-two adder.
+<p>You can see from the structure of the rate 1/2 K = 3 convolutional encoder
+and from the example given above that each input bit has an effect on three
+successive pairs of output symbols. That is an extremely important point
+and that is what gives the convolutional code its error-correcting power.
+The reason why will become evident when we get into the Viterbi decoder
+algorithm.
+<p>Now if we are only going to send the 15 data bits given above, in order
+for the last bit to affect three pairs of output symbols, we need to output
+two more pairs of symbols. This is accomplished in our example encoder
+by clocking the convolutional encoder flip-flops two ( = m) more times,
+while holding the input at zero. This is called "flushing" the encoder,
+and results in two more pairs of output symbols. The final binary output
+of the encoder is thus 00 11 10 00 01 10 01 11 11 10 00 10 11 00 11 10
+11<sub>2</sub>. If we don't perform the flushing operation, the last m
+bits of the message have less error-correction capability than the first
+through (m - 1)th bits had. This is a pretty important thing to remember
+if you're going to use this FEC technique in a burst-mode environment.
+So's the step of clearing the shift register at the beginning of each burst.
+The encoder must start in a known state and end in a known state for the
+decoder to be able to reconstruct the input data sequence properly.
+<p>Now, let's look at the encoder from another perspective. You can think
+of the encoder as a simple state machine. The example encoder has two bits
+of memory, so there are four possible states. Let's give the left-hand
+flip-flop a binary weight of 2<sup>1</sup>, and the right-hand flip-flop
+a binary weight of 2<sup>0</sup>. Initially, the encoder is in the all-zeroes
+state. If the first input bit is a zero, the encoder stays in the all zeroes
+state at the next clock edge. But if the input bit is a one, the encoder
+transitions to the 10<sub>2</sub> state at the next clock edge. Then, if
+the next input bit is zero, the encoder transitions to the 01<sub>2</sub>
+state, otherwise, it transitions to the 11<sub>2</sub> state. The following
+table gives the next state given the current state and the input, with
+the states given in binary:
+<br>
+<br>
+<center><table BORDER CELLSPACING=2 CELLPADDING=7 WIDTH="282" >
+<tr>
+<td VALIGN=TOP WIDTH="33%"><font face="Arial"><font size=-1> </font></font></td>
+
+<td VALIGN=TOP COLSPAN="2" WIDTH="67%">
+<center><a NAME="statetable"></a><b><font face="Arial"><font size=-1>Next
+State, if </font></font></b></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Current State</font></font></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Input = 0:</font></font></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Input = 1:</font></font></b></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+</tr>
+</table></center>
+
+<br>
+<p>The above table is often called a state transition table. We'll refer
+to it as the <tt>next state</tt> table.<tt> </tt>Now let us look at a table
+that lists the channel output symbols, given the current state and the
+input data, which we'll refer to as the <tt>output</tt> table:
+<br>
+<br>
+<center><table BORDER CELLSPACING=2 CELLPADDING=7 WIDTH="282" >
+<tr>
+<td VALIGN=TOP WIDTH="33%"></td>
+
+<td VALIGN=TOP COLSPAN="2" WIDTH="67%">
+<center><a NAME="outputtable"></a><b><font face="Arial"><font size=-1>Output
+Symbols, if</font></font></b></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Current State</font></font></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Input = 0:</font></font></b></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><b><font face="Arial"><font size=-1>Input = 1:</font></font></b></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>00</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+</tr>
+
+<tr>
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>11</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>01</font></font></center>
+</td>
+
+<td VALIGN=TOP WIDTH="33%">
+<center><font face="Arial"><font size=-1>10</font></font></center>
+</td>
+</tr>
+</table></center>
+
+<br>
+<p>You should now see that with these two tables, you can completely describe
+the behavior of the example rate 1/2, K = 3 convolutional encoder. Note
+that both of these tables have 2<sup>(K - 1)</sup> rows, and 2<sup>k</sup>
+columns, where K is the constraint length and k is the number of bits input
+to the encoder for each cycle. These two tables will come in handy when
+we start discussing the Viterbi decoder algorithm.
+<p><a NAME="mapping"></a><b><i><font face="Arial">Mapping the Channel Symbols
+to Signal Levels</font></i></b>
+<p>Mapping the one/zero output of the convolutional encoder onto an antipodal
+baseband signaling scheme is simply a matter of translating zeroes to +1s
+and ones to -1s. This can be accomplished by performing the operation y
+= 1 - 2x on each convolutional encoder output symbol.
+<p><a NAME="addnoise"></a><b><i><font face="Arial">Adding Noise to the
+Transmitted Symbols</font></i></b>
+<p>Adding noise to the transmitted channel symbols produced by the convolutional
+encoder involves generating Gaussian random numbers, scaling the numbers
+according to the desired energy per symbol to noise density ratio, E<sub>s</sub>/N<sub>0</sub>,
+and adding the scaled Gaussian random numbers to the channel symbol values.
+<p>For the uncoded channel, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>,
+since there is one channel symbol per bit. However, for the coded
+channel, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub> + 10log<sub>10</sub>(k/n).
+For example, for rate 1/2 coding, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>
++ 10log<sub>10</sub>(1/2) = E<sub>b</sub>/N<sub>0</sub> - 3.01 dB.
+Similarly, for rate 2/3 coding, E<sub>s</sub>/N<sub>0 </sub>= E<sub>b</sub>/N<sub>0</sub>
++ 10log<sub>10</sub>(2/3) = E<sub>b</sub>/N<sub>0</sub> - 1.76 dB.
+<p>The Gaussian random number generator is the only interesting part of
+this task. C only provides a uniform random number generator, <tt>rand()</tt>.
+In order to obtain Gaussian random numbers, we take advantage of relationships
+between uniform, Rayleigh, and Gaussian distributions:
+<p>Given a uniform random variable U, a Rayleigh random variable R can
+be obtained by:
+<p><img SRC="figs/eqn01.gif" ALT="equation for Rayleigh random deviate given uniform random deviate" height=30 width=297 align=ABSCENTER>
+<p>where <img SRC="figs/eqn02.gif" height=24 width=24 align=ABSCENTER>is
+the variance of the Rayleigh random variable, and given R and a second
+uniform random variable V, two Gaussian random variables G and H can be
+obtained by
+<p><i>G</i> = <i>R</i> cos <i>U</i> and <i>H</i> = <i>R</i> sin <i>V</i>.
+<p>In the AWGN channel, the signal is corrupted by additive noise, n(t),
+which has the power spectrum <i>No</i>/2 watts/Hz. The variance <img SRC="figs/eqn02.gif" ALT="variance" height=24 width=24 align=ABSBOTTOM>of
+this noise is equal to <img SRC="figs/eqn03.gif" ALT="noise density div by two" height=22 width=38 align=TEXTTOP>.
+If we set the energy per symbol <i>E<sub>s</sub></i> equal to 1, then <img SRC="figs/eqn04.gif" ALT="equation relating variance to SNR" height=28 width=110 align=ABSBOTTOM>.
+So <img SRC="figs/eqn05.gif" ALT="equation for AWGN st dev given SNR" height=28 width=139 align=ABSCENTER>.
+<p><a NAME="quantizing"></a><b><i><font face="Arial">Quantizing the Received
+Channel Symbols</font></i></b>
+<p>An ideal Viterbi decoder would work with infinite precision, or at least
+with floating-point numbers. In practical systems, we quantize the received
+channel symbols with one or a few bits of precision in order to reduce
+the complexity of the Viterbi decoder, not to mention the circuits that
+precede it. If the received channel symbols are quantized to one-bit precision
+(< 0V = 1, <u>></u> 0V = 0), the result is called hard-decision data.
+If the received channel symbols are quantized with more than one bit of
+precision, the result is called soft-decision data. A Viterbi decoder with
+soft decision data inputs quantized to three or four bits of precision
+can perform about 2 dB better than one working with hard-decision inputs.
+The usual quantization precision is three bits. More bits provide little
+additional improvement.
+<p>The selection of the quantizing levels is an important design decision
+because it can have a significant effect on the performance of the link.
+The following is a very brief explanation of one way to set those levels.
+Let's assume our received signal levels in the absence of noise are -1V
+= 1, +1V = 0. With noise, our received signal has mean +/- 1 and standard
+deviation <img SRC="figs/eqn05.gif" ALT="equation for AWGN st dev given SNR" height=28 width=139 align=ABSCENTER>.
+Let's use a uniform, three-bit quantizer having the input/output relationship
+shown in the figure below, where D is a decision level that we will calculate
+shortly:
+<center>
+<p><img SRC="figs/quantize.gif" ALT="8-level quantizer function plot" height=342 width=384></center>
+
+<p>The decision level, D, can be calculated according to the formula <img SRC="figs/eqn06.gif" ALT="equation for quantizer decision level" height=28 width=228 align=ABSCENTER>,
+where E<sub>s</sub>/N<sub>0</sub> is the energy per symbol to noise density
+ratio<i>. (The above figure was redrawn from Figure 2 of Advanced Hardware
+Architecture's ANRS07-0795, "Soft Decision Thresholds and Effects on Viterbi
+Performance". See the </i><a href="fecbiblio.html">bibliography</a><i>
+for a link to their web pages.)</i>
+<p>Click <a href="algrthms2.html">here</a> to proceed to the description
+of the Viterbi decoding algorithm itself...
+<p>Or click on one of the links below to go to the beginning of that section:
+<p> <a href="tutorial.html">Introduction</a>
+<br> <a href="algrthms2.html">Description of the Algorithms
+(Part 2)</a>
+<br> <a href="examples.html">Simulation Source Code Examples</a>
+<br> <a href="simrslts.html">Example Simulation Results</a>
+<br> <a href="fecbiblio.html">Bibliography</a>
+<br> <a href="tutorial.html#specapps">About Spectrum Applications...</a>
+<br>
+<br>
+<br>
+<br>
+<center>
+<p><img SRC="figs/stripe.gif" height=6 width=600></center>
+
+</body>
+</html>