[gogc] 12 new revisions pushed by bytbox on 2010-08-18 01:23 GMT

[go...@googlecode.com]

12 new revisions:

Revision: 17831c8db5
Author: Michael Lippautz <michael....@gmail.com>
Date: Sun Jul 4 09:02:30 2010
Log: documentation: Added cond. expr. (jmp,labels), if/else, for
http://code.google.com/p/gogc/source/detail?r=17831c8db5

Revision: 8a0c472dd1
Author: Michael Lippautz <michael....@gmail.com>
Date: Tue Jul 13 07:09:51 2010
Log: Documentation: Slightly changed layout to be more like a techrep.
and ...
http://code.google.com/p/gogc/source/detail?r=8a0c472dd1

Revision: 2c6eb76ecd
Author: Andreas Unterweger <and...@gmx.at>
Date: Wed Jul 14 07:49:31 2010
Log: doc: Minor corrections
http://code.google.com/p/gogc/source/detail?r=2c6eb76ecd

Revision: 9313c480fa
Author: Michael Lippautz <michael....@gmail.com>
Date: Thu Jul 15 08:23:17 2010
Log: documentation: Minor additions
http://code.google.com/p/gogc/source/detail?r=9313c480fa

Revision: 42b36d885e
Author: Michael Lippautz <michael....@gmail.com>
Date: Fri Jul 16 00:37:31 2010
Log: documentation: min change
http://code.google.com/p/gogc/source/detail?r=42b36d885e

Revision: b0cd5a37e5
Author: Michael Lippautz <michael....@gmail.com>
Date: Fri Jul 16 03:09:38 2010
Log: doc: ..
http://code.google.com/p/gogc/source/detail?r=b0cd5a37e5

Revision: 0d24750908
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 15:43:36 2010
Log: fixed author information
http://code.google.com/p/gogc/source/detail?r=0d24750908

Revision: cfc2a79ba1
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:07:26 2010
Log: got rid of go-env file
http://code.google.com/p/gogc/source/detail?r=cfc2a79ba1

Revision: e67f8da46f
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:12:55 2010
Log: fixed so that it compiles with current version of go (new multiline
st...
http://code.google.com/p/gogc/source/detail?r=e67f8da46f

Revision: 7e1d327a7e
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:13:58 2010
Log: .hgignore file to ignore .6, .a, and the executable
http://code.google.com/p/gogc/source/detail?r=7e1d327a7e

Revision: 7950421fae
Author: Scott Lawrence <byt...@gmail.com>
Date: Tue Aug 17 09:58:38 2010
Log: changed branding from GoGo to GoGC
http://code.google.com/p/gogc/source/detail?r=7950421fae

Revision: 9750f6ff3e
Author: Scott Lawrence <byt...@gmail.com>
Date: Tue Aug 17 14:33:41 2010
Log: TODO list (of ideas)
http://code.google.com/p/gogc/source/detail?r=9750f6ff3e

==============================================================================
Revision: 17831c8db5
Author: Michael Lippautz <michael....@gmail.com>
Date: Sun Jul 4 09:02:30 2010
Log: documentation: Added cond. expr. (jmp,labels), if/else, for
http://code.google.com/p/gogc/source/detail?r=17831c8db5

Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /docs/latex/gogo.pdf Sat Jul 3 02:04:37 2010
+++ /docs/latex/gogo.pdf Sun Jul 4 09:02:30 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Sat Jul 3 02:04:37 2010
+++ /docs/latex/gogo.tex Sun Jul 4 09:02:30 2010
@@ -312,11 +312,131 @@

String assignments are handled separately as they require 16 bytes
to be assigned. As one register can only hold 8 bytes, a second register
needs to be allocated in order to perform the assignment. Although this may
not be necessary in trivial cases where one string variable is assigned to
another, strings in structures which require offset calculations force the
use of a register when performing the offset calculation and therefore
require a second register to dereference the value of the other 8 bytes. In
order to be able to do this, the \texttt{C} field of the \texttt{Item}
structure is being used as it is not needed for other purposes outside
conditionals.

- \section{The generation of conditional expressions}
- Lorem ipsum dolor sit amet...
-
- \section{The generation of loops}
- Lorem ipsum dolor sit amet...
+ \section{Generation of conditional expressions and control structures}
+ In order to achieve condional jumps, GoGo (and thus Go) provides
expressions
+ that allow comparisons (\texttt{==}, \texttt{!=}, \texttt{$>$},
\texttt{$<$},
+ \texttt{$\ge$}, \texttt{$\le$}) and relative operators
(\texttt{\&\&},
+ \texttt{$||$}). The approach how code is generated differs from
\cite{wir96}.
+ Since our output language is text-based Plan9 assembly, there exists
no way
+ to create a fixup chain that could be used to fix conditional jumps
after
+ generating the code. As a result GoGo creates labels that are then
+ translated into adresses by the Plan9 assembly tools. \\
+
+ Since jumps are always generation after comparisons the code
generation
+ for conditional jumps just needs two instructions. A \texttt{CMP}
instruction
+ for the actual comparisons (this instruction is not bound to the
comparison
+ operator) and the conditional jump that takes the evaluates the
registers
+ of the comparison. The jumps that are needed can be seen in table
\ref{tbl:jumps}.
+
+ \begin{table}[htb]
+ \centering
+ \begin{tabular}{ll}
+ \toprule
+ \textbf{Comparisons} & \textbf{Positive Jump} \\
+ \midrule
+ Equal \texttt{==} & \texttt{JE}\\
+ Not equal \texttt{!=} & \texttt{JNE}\\
+ Greater than \texttt{$>$} & \texttt{JG}\\
+ Less than \texttt{$<$} & \texttt{JL}\\
+ Less than or equal \texttt{$\le$} & \texttt{JLE}\\
+ Greater than or equal \texttt{$\ge$} & \texttt{JGE}\\
+ \bottomrule
+ \end{tabular}
+ \caption{Conditional jumps used}
+ \label{tbl:jumps}
+ \end{table}
+
+ The label generation (and thus the resulting labels) can be
summarized as
+ follows:
+ \begin{itemize}
+ \item Each label has a suffix indicating whether it is used by an
+ \texttt{if/else} or \texttt{for} statement.
+ \item Per convinience (Go forces this) programs compiled with GoGo
+ are only allowed to have one statement (or control structure) per
+ line. A side-effect of this limitation is that the addition of
line
+ and column number of the expression into the label guarantees
global
+ uniqueness.
+ \item Furthermore a expression local counter, representing a
\texttt{true}
+ or \texttt{false} branch is included.
+ \item A simple prefix (used for debugging readability) makes a GoGo
+ label complete.
+ \end{itemize}
+
+ In order to provide common programming constructs that involve
pointer
+ comparisons (see listing \ref{lst:pointer}) GoGo uses
lazy-evaluation.
+
+ \begin{lstlisting}[label=lst:pointer,caption=Pointer comparison]
+if object != nil && object.field ... {
+ \end{lstlisting}
+
+ Lazy-evaluation is provided over multiple levels of expressions using
+ label merging to minimize the overhead. Each top level expression
gets
+ its own stacks for \texttt{true} and \texttt{false} branching.
Further
+ sub-expressions labels (in fact, just their local counters) are then
just
+ pushed and poped into the coresponding stacks. An example
illustrating
+ this need is stated in \ref{lst:lazy}.
+ \begin{lstlisting}[caption=Lazy-evaluation over multiple expression
levels, label=lst:lazy]
+if (done!=1) && (((a<1) && (b<2)) || ((c<3) && (d<4))) { ...
+ \end{lstlisting}
+ While the first \texttt{false} branch has to be generated for the
term
+ $(done!=1)$, further ones are needed for $(a<1)$ and $(c<3)$.
Although these are
+ \texttt{false} branches, they have different levels and result in
different
+ merging points.
+
+ \subsection{Conditional Jumps}
+ GoGo provides one control structure that can be used for conditional
jumps,
+ namely \texttt{if}/\texttt{else}. While elseif and case statements
could
+ have provided further programming experience, the compiler itself
uses only
+ \texttt{if}. The \texttt{if}/\texttt{else} construct uses the
condional
+ expressions explained above and results in a structure as follows:
+ \begin{table}[hbt]
+ \centering
+ \begin{tabular}{l}
+ \toprule
+ Code generated for expression\\
+ \texttt{If} prolog including possible \texttt{else} jump\\
+ \hspace{0.5cm} \texttt{True} body\\
+ \texttt{Else} header\\
+ \hspace{0.5cm} \texttt{False} body\\
+ Epilog catching \texttt{true} body exit\\
+ \bottomrule
+ \end{tabular}
+ \end{table}
+
+ \subsection{Loops}
+ GoGo supports only \texttt{for} structures to construct loops,
because
+ Go doesn't offer anything other itself. In order to provide a more
+ lightweight loop variant, one may skip parts of the \texttt{for}
construct.
+ The language construct is defined as follows:
+ \begin{lstlisting}
+for <initial-assignment> ; <expression> ; <loop-assignment> { ...
+ \end{lstlisting}
+
+ While usually one might use the initial-assignment and the
loop-assignment
+ to control the flow, they can be skipped. In fact, each part may be
skipped
+ to generate a very lightweight \texttt{while(true)} loop. The code
that is
+ usually (using all three clauses) generated has the structure:
+
+ \begin{table}[hbt]
+ \centering
+ \begin{tabular}{l}
+ \toprule
+ \textbf{Code structure}\\
+ \midrule
+ Initial-assignment\\
+ Expression label\\
+ Expression evaluation\\
+ (Jump to body if first iteration)\\
+ Conditional jump to epilog depending on the expression\\
+ Loop-assignment label\\
+ \hspace{0.5cm} Loop-assignment\\
+ Loop body label\\
+ \hspace{0.5cm} Loop body\\
+ Epilog catching exits\\
+ \bottomrule
+ \end{tabular}
+ \end{table}
+

\section{The generation of functions calls} \label{The generation of
functions}
Consider the following example with the current function having 3
local variables -- 2 of type \texttt{uint64} and one of type
\texttt{string} -- calling the function \texttt{foo} which has the
following prototype:

==============================================================================
Revision: 8a0c472dd1
Author: Michael Lippautz <michael....@gmail.com>
Date: Tue Jul 13 07:09:51 2010
Log: Documentation: Slightly changed layout to be more like a techrep. and
added
the rest of the content.
http://code.google.com/p/gogc/source/detail?r=8a0c472dd1

Added:
/docs/latex/files/building.pdf
Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /dev/null
+++ /docs/latex/files/building.pdf Tue Jul 13 07:09:51 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.pdf Sun Jul 4 09:02:30 2010
+++ /docs/latex/gogo.pdf Tue Jul 13 07:09:51 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Sun Jul 4 09:02:30 2010
+++ /docs/latex/gogo.tex Tue Jul 13 07:09:51 2010
@@ -1,12 +1,23 @@
-\documentclass[a4paper]{scrreprt}
+\documentclass[a4paper]{scrartcl}
+
+\let\chapter\section
+\let\section\subsection
+\let\subsection\subsubsection
+\let\subsubsection\paragraph
+\let\paragraph\subparagraph
+\let\subparagraph\undefined

\usepackage{booktabs}
\usepackage[usenames,dvipsnames]{color}
\usepackage[latin1]{inputenc}
\usepackage{listings}
\usepackage[english]{babel}
-\usepackage[pdftex,plainpages=false,pdfpagelabels,hyperfootnotes=false]{hyperref}
-\hypersetup{pdftitle={GoGo -- A Go compiler written in
Go},pdfauthor={Michael Lippautz, Andreas
Unterweger},pdfsubject={GoGo},pdfkeywords={Go,Compiler,GoGo}}
+\usepackage[pdftex,plainpages=false,pdfpagelabels,
+ hyperfootnotes=false]{hyperref}
+\hypersetup{pdftitle={GoGo -- A Go compiler written in Go},
+ pdfauthor={Michael Lippautz, Andreas Unterweger},
+ pdfsubject={GoGo},pdfkeywords={Go,Compiler,GoGo}}
+\usepackage{graphicx}

\definecolor{lightgray}{RGB}{250,250,250}

@@ -30,27 +41,38 @@
\tableofcontents

\chapter{Introduction}
- GoGo is a self-compiling Go compiler written in Go which implements
scanning, parsing and code generation for a subset of the Go
language\cite{goo10}. It is mostly compatible with the Go compiler
available in \cite{goo10} and outputs valid Plan9 assembly code which can
be assembled by the latter as well as the Plan9 assembly tools \texttt{6a}
and \texttt{6l}\cite{pik00}.\\
- Lorem ipsum dolor sit amet...
+ GoGo is a self-compiling (see section \ref{chpt:building}) Go compiler
+ written in Go which implements scanning, parsing and code generation
for a
+ subset of the Go language \cite{goo10}. It is mostly compatible with
the Go
+ compiler available at \cite{goo10} and outputs valid Plan9 assembly
code
+ which can be assembled by the latter as well as the Plan9 assembly
tools
+ \texttt{6a} and \texttt{6l}\cite{pik00}.\\
+

\chapter{Input Language}
Go is a programming language developed by Google, based on a C like
syntax and fully specified in \cite{goo10}. The input language follows the
one defined by Go. This results in programs being able to be compiled by
the official Go compilers and GoGo.

- \section{Differences to Go}
+ \section{Some differences to Go}
\begin{enumerate}
- \item GoGo only provides only a \textbf{very} basic featureset.
Expect every advanced and interesting feature to be missing.
- \item GoGo forces the usage of semicolons at the end of
statements. This restriction was made to make parsing easier.
+ \item GoGo only provides only a \textbf{very} basic featureset.
Expect
+ every advanced and interesting feature to be missing.
+ \item GoGo forces the usage of semicolons at the end of statements,
+ while in actual Go these token is optional. This restriction was
made
+ to make parsing easier.
\item Go is fully Unicode compatible, while GoGo uses ASCII
characters only.
\item Simplified expressions, following Wirth's \cite{wir96}
defintions.
\end{enumerate}

\section{EBNF}
\label{sec:ebnf}
- Lorem ipsum dolor sit amet...
+ The following section deals with the input language specification in
+ EBNF form. Additionally to the specification below, GoGo also allows
+ source code comments following the C++ multiline
style(\texttt{/* ... */})
+ and the C inline style (\texttt{//}).

\subsection*{Atoms}
- The following listing described the basic atoms that are possible
in GoGo programs.
-
+ The following listing describes the basic atoms that are possible
in
+ GoGo programs.
\begin{lstlisting}[caption=Atoms]
single_char = CHR(32)|...|CHR(127).
char = "'" single_char "'".
@@ -189,7 +211,8 @@
as LL1 like in \cite{wir96}, with one minor difference. In order to be
compatible with Go it was necesarry to include one namespace hierachy
that
is represented by packages. Since this namescope is prefixed
- using \texttt{package.} the parser needs a lookup of three in this
case.
+ using \texttt{package.} the parser needs a lookup of three (LL3)in this
+ case.

\chapter{Symbol table}
In order to be able to lookup local and global variable names as well
as function names, a symbol table is required. Based on \cite{wir96},
object and type descriptors were used, each containing the information
required for lookup and code generation. Object descriptors are used to
store information about variables and parameters whereas type descriptors
are used to store information about types and functions.\\
@@ -531,14 +554,104 @@
The current approach to fetch parameters requires the activation of
the \texttt{proc} file system in the Linux kernel which is enabled by
default in most Linux distributions\cite{var06}. The \texttt{proc} file
system allows (among other information) to access parameters of all
processes running in the system, including the current process. The
latter's parameters can be through the virtual file
\texttt{/proc/self/cmdline} where \texttt{self} refers to the current
process. The virtual file contains all parameters, separated by zero bytes
and terminated by a sequence of two zero bytes. When parsed, this allows to
access the program's parameters without having to access the stack.

\chapter{Building / Self-compilation}
- This section deals with the building process of GoGo and how
self-compilation is achieved.
+ \label{chpt:building}
+ This section deals with the building process of GoGo and how
self-compilation
+ is achieved.
+
+ \section{Go language tools}
+ Before introducing the compilation procedure it is important to know
how
+ the Go language tools (which are actually Plan9 tools) are organized.
+
+ Each CPU architecture gets a number that is prefixed before a tool.
In
+ GoGo's case this would be \texttt{6}, indicating an amd64
architecture.
+ The toolsuite is then organized into various compilers/linkers:
+ \begin{itemize}
+ \item \texttt{6a} - Assembler for amd64 arch (creating \texttt{*.6}
+ object files)
+ \item \texttt{6g} - Go compiler for amd64 arch (creating
\texttt{*.6}
+ object files)
+ \item \texttt{6l} - Linker creating and amd64 ELF binary out of
object
+ files
+ \end{itemize}
+ Again, the fileendings of the object format indicate the used CPU
+ architecture.
+
+ \section{Bootstrapping}
+ To create the first compiler, that is then used for furter subsequent
+ compilations, the Go language tools are used. Go uses
\texttt{Makefile}s
+ for defining the appropriate compilation procedure. Basically, three
steps
+ are needed to create the GoGo binary:
+ \begin{enumerate}
+ \item Library compilation - The \texttt{6g} and \texttt{6a} tools
are
+ used to create a single object file containing the library code.
+ \item Compiler compilation - Compile the compiler using texttt{6g}.
+ \item Link - Link the compiler object file and the library object
file
+ into an ELF binary using \texttt{6l}.
+ \end{enumerate}
+ At the end of this procedure an architecture dependent (amd64) GoGo
+ compiler has been created.
+
+ \section{Self-compilation}
+ \label{sec:sc}
+ After creating a first bootstrapped version of the compiler, this
one may
+ be used for self-compilation. GoGo is written in the same language it
+ is able to compile to assembly level and therefore no further
additions
+ or changes have to be made to the source code.
+ The procedure to achieve self-compilation until assembly level is
shown
+ in figure \ref{fig:sc}.
+
+ \begin{figure}
+ \centering
+ \includegraphics[scale=0.4,angle=-90,clip=true,trim=0cm 0cm 3cm
0cm]{files/building}
+ \label{fig:sc}
+ \caption{Self-compilation approach}
+ \end{figure}
+
+ Although GoGo is capable of doing some very basic linking (i.e. copy
+ functions from different files and adjust symbol table), it is not
+ possible to use separate compilation during self-compilation. Altough
+ function linking would work, GoGo is not able to handle global
variables
+ , that are spread over multiple packages, correctly in the linking
process.
+ Thus the approach is straight-forward and can be summarized by the
following:
+ \begin{enumerate}
+ \item All sources, this includes library, as well as compiler
sources,
+ are compiled in one step. The bootstrapped compiler is used in
compile
+ mode for this step.
+ File ordering does not matter as long as there are no global
+ variables involved (where a type has to be known). While
\texttt{*.go}
+ files are compiled, \texttt{*.s} files are treated as assembly
and
+ directly copied into the output.
+ \item The compiled source file (\_gogo\_.sog) is then again
processed by
+ the bootstrapped compiler in the linker mode. This mode is used
to fix
+ certain offset addresses in the parameter handling of functions.
+ \item The received file (\_final\_.sog) then contains the compiled
+ compiler in assembly language.
+ \item Finally, this file is used as input for
\texttt{6a}/\texttt{6l} to
+ create a platform-dependent ELF binary. This is not part of the
self-compilation,
+ but necessary to get an executable file.
+ \end{enumerate}
+
+ In order to do a fixpoint-test this procedure is then used to
generate
+ another copy using the previously compiled GoGo compiler. The
+ fixpoint-test passes and there are no differences in subsequent
compilations.

\chapter{Testing}
- In order to test the compiler, a test suite has been constructed that
may be used to verify results against an already existing result set. \\ \\
+ In order to test the compiler, a test suite (using \texttt{bash}) has
been
+ constructed that may be used to verify results against an already
existing
+ result set. \\ \\
The test suite offers the following functions:
\begin{itemize}
- \item \textbf{newvalids/ackvalids/fullclean} -- These commands are
used to create a new result set as reference for further tests. While
\texttt{fullclean} deletes the old set, \texttt{newvalids} is used to
create a new one. After verifying that the compiled output is correct (by
manually checking it), the command \texttt{ackvalids} can be used to
acknowledge the set (resulting in a checksum file).
- \item \textbf{test/clean} -- \texttt{test} is used to perform a
compilation and compare the results against the last valid result set. In
order to do so, checksums of the tests are compared. If they are not equal,
a \texttt{diff} is printed to the user.
+ \item \textbf{newvalids/ackvalids/fullclean} -- These commands are
used to
+ create a new result set as reference for further tests. While
+ \texttt{fullclean} deletes the old set, \texttt{newvalids} is used
to
+ create a new one. After verifying that the compiled output is
correct
+ (by manually checking it), the command \texttt{ackvalids} can be
used to
+ acknowledge the set (resulting in a checksum file).
+ \item \textbf{test/clean} -- \texttt{test} is used to perform a
+ compilation and compare the results against the last valid result
set.
+ In order to do so, checksums of the tests are compared. If they
are not
+ equal, a \texttt{diff} is printed to the user. \texttt{Clean}
deletes
+ all temporary files.
\end{itemize}

\bibliographystyle{alpha}

==============================================================================
Revision: 2c6eb76ecd
Author: Andreas Unterweger <and...@gmx.at>
Date: Wed Jul 14 07:49:31 2010
Log: doc: Minor corrections
http://code.google.com/p/gogc/source/detail?r=2c6eb76ecd

Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /docs/latex/gogo.pdf Tue Jul 13 07:09:51 2010
+++ /docs/latex/gogo.pdf Wed Jul 14 07:49:31 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Tue Jul 13 07:09:51 2010
+++ /docs/latex/gogo.tex Wed Jul 14 07:49:31 2010
@@ -57,10 +57,10 @@
\item GoGo only provides only a \textbf{very} basic featureset.
Expect
every advanced and interesting feature to be missing.
\item GoGo forces the usage of semicolons at the end of statements,
- while in actual Go these token is optional. This restriction was
made
+ while in actual Go this token is optional. This restriction was
made
to make parsing easier.
\item Go is fully Unicode compatible, while GoGo uses ASCII
characters only.
- \item Simplified expressions, following Wirth's \cite{wir96}
defintions.
+ \item Simplified expressions, following Wirth's
defintions\cite{wir96}.
\end{enumerate}

\section{EBNF}
@@ -176,12 +176,12 @@

\chapter{Scanner / Parser}
The scanner is basically the provider of tokens that are used by the
parser
- to interpret the code. In order to generate these tokens the scanner
reads
+ to process the code. In order to generate these tokens, the scanner
reads
the file character by character. If a sequence is known, it converts
this
sequence of characters into the corresponding token. Tokens generated
this
way are called simple tokens, as they can be generated right away. For
- instance, a sequence \textit{'A'} can be directly converted into a
token
- representing a byte value. \\
+ instance, the sequence \textit{'A'} can be directly converted into a
token
+ representing the byte value 65. \\
Before providing a token to the parser, the scanner may convert such
simple tokens one more time. These complex tokens are generated from
simple
ones that represent \texttt{identifiers}. \texttt{Identifiers} are
compared to a
@@ -204,14 +204,14 @@
The scanner also implements a very simple escaping mechanism that
allows
sequences like \textit{'\textbackslash n'} to be used in strings. \\
Comments can be written as \textit{/* ... */} blocks or
- \textit{\textbackslash \textbackslash} till line ending, like in C/C++.
+ \textit{\textbackslash \textbackslash} until the line ending, like in
C/C++.
\\ \\
The parser then takes these tokens and represents the language defined
by
the EBNF from section \ref{sec:ebnf}. The parser is basically
implemented
as LL1 like in \cite{wir96}, with one minor difference. In order to be
compatible with Go it was necesarry to include one namespace hierachy
that
- is represented by packages. Since this namescope is prefixed
- using \texttt{package.} the parser needs a lookup of three (LL3)in this
+ is represented by packages. Since this name scope is prefixed
+ using \texttt{package.}, the parser needs a lookup of three (LL3)in
this
case.

\chapter{Symbol table}
@@ -255,10 +255,10 @@
\label{tbl:typedesc}
\end{table}

- For Both symbol tables the build-up and lookup is integrated into the
parser. Whenever sufficient information (variable name, function name, type
name; optionally preceeded by a package name) is encountered, a lookup in
the symbol table is issued. Declarations issue new symbol table entries
with the corresponding descriptor properties as described above.\\
+ For both global and function-local symbol tables the build-up and
lookup is integrated into the parser. Whenever sufficient information
(variable name, function name, type name; optionally preceeded by a package
name) is encountered, a lookup in the symbol table is issued. Declarations
issue new symbol table entries with the corresponding descriptor properties
as described above.\\
Forward declarations are currently only supported for type pointers
(as pointers are always 64 bits in size) and functions (as the affected
offsets can be fixed by the linker if necessary). Whenever supported
forward declarations are encountered, a new symbol table entry is created
with \texttt{ForwardDecl} set to 1. Forward declared function can then be
called, although forward declared type pointers cannot be dereferred until
the size of the type they are pointing to is known (\texttt{ForwardDecl} is
0). When forward declared functions are implemented, the corresponding
symbol table entry is modified (\texttt{ForwardDecl} is set to 0) instead
of creating a new one.

- \section{Supported data type}
+ \section{Supported data types}
GoGo supports 4 built-in value types and the declaration of new
struct and array types as well as pointers to value, struct and array
types. The 4 built-in data types are based on the data types supported by
the Go compiler and form a minimal subset of them in order to perform basic
integer and string operations. The following table \ref{tbl:types} lists
the built-in value types, together with their purpose and size.

\begin{table}[htb]
@@ -273,7 +273,7 @@
\texttt{bool} & 8 bytes (64 bits) & Internal type used for
comparisions and jumps\\
\bottomrule
\end{tabular}
- \caption{Built in types}
+ \caption{Built-in types}
\label{tbl:types}
\end{table}

@@ -281,7 +281,7 @@
In order to be able to distinguish between parameters, local and
global variables, a global and a local symbol table as well the function's
parameters as third, virtual symbol table are used. Local variables hide
global variables of the same name by performing the symbol table lookup for
local variables and parameters first and returning the first match if there
is any.\\
The memory layout for local and global variables as well as
parameters is equal: the object's offset address contains the first 64 bits
of the object, the next highest address (offset address plus 64 bits)
contains the next 64 bits etc. All local and global variable offset
addresses are 64 bit aligned. The offset of an object can be calculated by
summing the aligned sizes of its predecessors in the corresponding variable
list. Doing this, it has to be taken into consideration that pointers
always occupy 8 bytes (64 bits), regardless of the type they are actually
pointing to.\\
Global variables start at offset 0 of the data segment, referred to
as \texttt{data+0} in the output. Subsequent global variables use ascending
offsets as described above (p.e. referred to as \texttt{data+8} for offset
8). Local variables and parameters are addressed relative to the stack
pointer \texttt{SP}, starting at offset \texttt{SP+8} for parameters with
ascending offsets as described for global variables (\texttt{SP} is
reserved for the saved instruction pointer \texttt{IP}, see \ref{The
generation of functions}). Local variables start at offset \texttt{SP-8} in
descending order (\texttt{SP-16} for the second 64 bit variable,
\texttt{SP-24} for the third etc., see table below) in descending order.
Ignoring the sign, the offset relative to SP is still in ascending order,
so the offset calculation method as used for global variables and
parameters can be used.\\ \\
- \begin{table}
+ \begin{table}[h]
\begin{tabular}{llp{2cm}l}
\cmidrule{1-2}
\textbf{Address} & \textbf{Content} & & \textbf{Source code}\\
@@ -342,12 +342,12 @@
\texttt{$||$}). The approach how code is generated differs from
\cite{wir96}.
Since our output language is text-based Plan9 assembly, there exists
no way
to create a fixup chain that could be used to fix conditional jumps
after
- generating the code. As a result GoGo creates labels that are then
+ generating the code. As a result, GoGo creates labels that are then
translated into adresses by the Plan9 assembly tools. \\

Since jumps are always generation after comparisons the code
generation
for conditional jumps just needs two instructions. A \texttt{CMP}
instruction
- for the actual comparisons (this instruction is not bound to the
comparison
+ for the actual comparison (this instruction is not bound to the
comparison
operator) and the conditional jump that takes the evaluates the
registers
of the comparison. The jumps that are needed can be seen in table
\ref{tbl:jumps}.

@@ -379,14 +379,14 @@
line. A side-effect of this limitation is that the addition of
line
and column number of the expression into the label guarantees
global
uniqueness.
- \item Furthermore a expression local counter, representing a
\texttt{true}
+ \item Furthermore, an expression local counter, representing a
\texttt{true}
or \texttt{false} branch is included.
\item A simple prefix (used for debugging readability) makes a GoGo
label complete.
\end{itemize}

In order to provide common programming constructs that involve
pointer
- comparisons (see listing \ref{lst:pointer}) GoGo uses
lazy-evaluation.
+ comparisons (see listing \ref{lst:pointer}), GoGo uses
lazy-evaluation.

\begin{lstlisting}[label=lst:pointer,caption=Pointer comparison]
if object != nil && object.field ... {
@@ -395,8 +395,8 @@
Lazy-evaluation is provided over multiple levels of expressions using
label merging to minimize the overhead. Each top level expression
gets
its own stacks for \texttt{true} and \texttt{false} branching.
Further
- sub-expressions labels (in fact, just their local counters) are then
just
- pushed and poped into the coresponding stacks. An example
illustrating
+ sub-expressions labels (in fact, just their local counters) are then
+ pushed and poped to/from the coresponding stacks. An example
illustrating
this need is stated in \ref{lst:lazy}.
\begin{lstlisting}[caption=Lazy-evaluation over multiple expression
levels, label=lst:lazy]
if (done!=1) && (((a<1) && (b<2)) || ((c<3) && (d<4))) { ...
@@ -406,7 +406,7 @@
\texttt{false} branches, they have different levels and result in
different
merging points.

- \subsection{Conditional Jumps}
+ \subsection*{Conditional Jumps}
GoGo provides one control structure that can be used for conditional
jumps,
namely \texttt{if}/\texttt{else}. While elseif and case statements
could
have provided further programming experience, the compiler itself
uses only
@@ -426,9 +426,9 @@
\end{tabular}
\end{table}

- \subsection{Loops}
+ \subsection*{Loops}
GoGo supports only \texttt{for} structures to construct loops,
because
- Go doesn't offer anything other itself. In order to provide a more
+ Go doesn't offer any other form of loops itself. In order to provide
a more
lightweight loop variant, one may skip parts of the \texttt{for}
construct.
The language construct is defined as follows:
\begin{lstlisting}
@@ -563,39 +563,38 @@
the Go language tools (which are actually Plan9 tools) are organized.

Each CPU architecture gets a number that is prefixed before a tool.
In
- GoGo's case this would be \texttt{6}, indicating an amd64
architecture.
- The toolsuite is then organized into various compilers/linkers:
+ GoGo's case this would be \texttt{6}, indicating an AMD64
architecture.
+ The tool suite is then organized into various compilers/linkers:
\begin{itemize}
- \item \texttt{6a} - Assembler for amd64 arch (creating \texttt{*.6}
+ \item \texttt{6a} - Assembler for AMD64 architecture (creating
\texttt{*.6}
object files)
- \item \texttt{6g} - Go compiler for amd64 arch (creating
\texttt{*.6}
+ \item \texttt{6g} - Go compiler for AMD64 architecture (creating
\texttt{*.6}
object files)
- \item \texttt{6l} - Linker creating and amd64 ELF binary out of
object
- files
+ \item \texttt{6l} - Linker creating an AMD64 ELF binary out of
object files
\end{itemize}
- Again, the fileendings of the object format indicate the used CPU
- architecture.
-
- \section{Bootstrapping}
- To create the first compiler, that is then used for furter subsequent
+ Again, the file extensions of the object format indicate the CPU
+ architecture used.
+
+ \section{Boot-strapping}
+ To create the initial compiler that is then used for subsequent
compilations, the Go language tools are used. Go uses
\texttt{Makefile}s
for defining the appropriate compilation procedure. Basically, three
steps
are needed to create the GoGo binary:
\begin{enumerate}
\item Library compilation - The \texttt{6g} and \texttt{6a} tools
are
used to create a single object file containing the library code.
- \item Compiler compilation - Compile the compiler using texttt{6g}.
+ \item Compiler compilation - Compile the compiler using
\texttt{6g}.
\item Link - Link the compiler object file and the library object
file
into an ELF binary using \texttt{6l}.
\end{enumerate}
- At the end of this procedure an architecture dependent (amd64) GoGo
+ At the end of this procedure, an architecture-dependent (AMD64) GoGo
compiler has been created.

\section{Self-compilation}
\label{sec:sc}
After creating a first bootstrapped version of the compiler, this
one may
be used for self-compilation. GoGo is written in the same language it
- is able to compile to assembly level and therefore no further
additions
+ is able to compile to assembly level. Therefore, no further additions
or changes have to be made to the source code.
The procedure to achieve self-compilation until assembly level is
shown
in figure \ref{fig:sc}.
@@ -608,22 +607,22 @@
\end{figure}

Although GoGo is capable of doing some very basic linking (i.e. copy
- functions from different files and adjust symbol table), it is not
+ functions from different files and adjust the symbol table), it is
not
possible to use separate compilation during self-compilation. Altough
function linking would work, GoGo is not able to handle global
variables
- , that are spread over multiple packages, correctly in the linking
process.
- Thus the approach is straight-forward and can be summarized by the
following:
+ that are spread over multiple packages correctly in the linking
process.
+ Thus, the approach is straight-forward and can be summarized by the
following:
\begin{enumerate}
\item All sources, this includes library, as well as compiler
sources,
are compiled in one step. The bootstrapped compiler is used in
compile
mode for this step.
- File ordering does not matter as long as there are no global
+ File ordering does not matter as long as there are no forward
declared global
variables involved (where a type has to be known). While
\texttt{*.go}
files are compiled, \texttt{*.s} files are treated as assembly
and
directly copied into the output.
\item The compiled source file (\_gogo\_.sog) is then again
processed by
the bootstrapped compiler in the linker mode. This mode is used
to fix
- certain offset addresses in the parameter handling of functions.
+ offset addresses in the parameter handling of previously forward
declared functions.
\item The received file (\_final\_.sog) then contains the compiled
compiler in assembly language.
\item Finally, this file is used as input for
\texttt{6a}/\texttt{6l} to
@@ -631,8 +630,8 @@
but necessary to get an executable file.
\end{enumerate}

- In order to do a fixpoint-test this procedure is then used to
generate
- another copy using the previously compiled GoGo compiler. The
+ In order to perform a fixpoint-test, this procedure is used to
generate
+ another instance using the previously compiled GoGo compiler. The
fixpoint-test passes and there are no differences in subsequent
compilations.

\chapter{Testing}

==============================================================================
Revision: 9313c480fa
Author: Michael Lippautz <michael....@gmail.com>
Date: Thu Jul 15 08:23:17 2010
Log: documentation: Minor additions
http://code.google.com/p/gogc/source/detail?r=9313c480fa

Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /docs/latex/gogo.pdf Wed Jul 14 07:49:31 2010
+++ /docs/latex/gogo.pdf Thu Jul 15 08:23:17 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Wed Jul 14 07:49:31 2010
+++ /docs/latex/gogo.tex Thu Jul 15 08:23:17 2010
@@ -49,7 +49,7 @@
\texttt{6a} and \texttt{6l}\cite{pik00}.\\


- \chapter{Input Language}
+ \chapter{Input language}
Go is a programming language developed by Google, based on a C like
syntax and fully specified in \cite{goo10}. The input language follows the
one defined by Go. This results in programs being able to be compiled by
the official Go compilers and GoGo.

\section{Some differences to Go}
@@ -167,7 +167,7 @@
\end{lstlisting}


- \chapter{Output Language}
+ \chapter{Output language}
The output language is Plan-9 assembler \cite{pik00}. It is a modified
version of 64 bit assembly for Intel x86 processors with AT\&T syntax that
has been created by Bell Labs to be used in their compiler and assembler
collection.

\section{Assembly output}
@@ -182,6 +182,8 @@
way are called simple tokens, as they can be generated right away. For
instance, the sequence \textit{'A'} can be directly converted into a
token
representing the byte value 65. \\
+
+
Before providing a token to the parser, the scanner may convert such
simple tokens one more time. These complex tokens are generated from
simple
ones that represent \texttt{identifiers}. \texttt{Identifiers} are
compared to a
@@ -305,13 +307,13 @@
The target architecture provides 8 general purpose registers
(\texttt{R8}-\texttt{R15}) as well as the registers \texttt{RAX},
\texttt{RBX}, \texttt{RCX} and \texttt{RDX}\cite{int09}. The latter are not
being used by GoGo to store variables as their values may change when
performing arithmetical operations (p.e. \texttt{RAX} and \texttt{RDX} are
always used as the destination registers for multiplications), thus
possibly overwriting values previously stored there.\\
GoGo stores a list for every one of the 8 registers currently
free, returning the first free register if required by the code generator.
Whenever a register is no longer required (freed), it will be reinserted
into the "free" list in order to make it available for future use. Due to
the limited amout of registers, the list described is implemented in form
of a bit array in the compiler.

- \section{The generation of arithmetical expressions}
+ \section{Generation of arithmetical expressions}
As described in \cite{wir96}, code generation for arithmetical
expressions basically relies on an operand stack and delayed code
generation based on \texttt{Items}. For constant operands, constant folding
is applied; variable operands are loaded into a free register in order to
perform arithmetical operations on them.\\
GoGo makes use of the capabilities of the target architecture by not
loading constants into registers, thus reducing the number of registers
required. Consider the expression \texttt{a + b} where both \texttt{a} and
\texttt{b} are variables of type \texttt{uint64} with negative offsets 8
and 16 relative to the stack pointer. As the target architecture is able to
perform an operation like \texttt{ADDQ R8, -16(SP)} (add the value at
address \texttt{SP-16} to the register \texttt{R8}), only \texttt{a} needs
to be loaded into a register, whereas \texttt{b} can be directly
incorporated into the instruction itself.\\
Multiplication and division on the target architecture both require
special treatment: The multiplication instruction only takes the second
operand and requires the first operand to be in the register
\texttt{RAX}\cite{int09}. Therefore, the first operand has to be loaded
into \texttt{RAX} prior multiplication. The multiplication result is stored
as 128 bit value in \texttt{RDX} (upper 64 bits) and \texttt{RAX} (lower 64
bits). As GoGo does not support data types other than \texttt{byte} and
\texttt{uint64}, the upper 64 bits in \texttt{RDX} are ignored, and the
lower 64 bits are moved to one of the 8 registers to save the result before
another multiplication is being performed. Similarly, division allows for
an 128 bit operand (also in \texttt{RDX} and \texttt{RAX}). As GoGo does
not support 128 bit size data types, \texttt{RDX} is always being zeroed
prior division.\\
The addition, substraction and multiplication operations are also
used for offset calculations. Thus, an additional distinction per
\texttt{Item} is required in order to be able to distinguish between
addresses and values stored in registers. As arithmetical operations on
\texttt{byte} and \texttt{uint64} types always operate on a value, the
actual value to be calculated with has to be loaded prior calculation. As
offset calculations always require the address to be loaded into the
register instead of the value, it has to be made sure that the address is
loaded, not the value. In order to distinguish between addresses and values
in registers, the \texttt{A} field of the \texttt{Item} structure is used.
Additionally, the code generation routines for addition and subtraction
have an additional parameter specifying whether to calculate with addresses
or values, issuing the necessary dereferencing operations if required.

- \section{The generation of assignments}
+ \section{Generation of assignments}
As pointer types are supported, type checks in assignments as well
as the assignments themselves get harder to implement as additional cases
have to be dealt with. Additionally, the possible occurrence of the address
operator (\texttt{\&}) on the right hand side of an assignment doubles the
number of cases. The following table \ref{tbl:assigntypes} illustrates the
distinctions made and the code generated for some of the cases allowed by
the EBNF (* denotes pointer types, LHS and RHS are the \texttt{Items} on
the left and right hand side, respectively). For the sake of clearity, only
the cases with a non-pointer type variable \texttt{Item} on the left hand
side and no address operator on the right hand side using \texttt{uint64}
types are shown. The compiler is also able to assign \texttt{byte} values
to one another as well as to \texttt{uint64} types.

\begin{table}[htb]
@@ -461,7 +463,7 @@
\end{table}


- \section{The generation of functions calls} \label{The generation of
functions}
+ \section{Generation of functions calls} \label{The generation of
functions}
Consider the following example with the current function having 3
local variables -- 2 of type \texttt{uint64} and one of type
\texttt{string} -- calling the function \texttt{foo} which has the
following prototype:
\begin{lstlisting}
func foo(param1 uint64, param2 uint64, param3 string) uint64;
@@ -540,7 +542,7 @@
\label{tbl:syscalls}
\end{table}

- \section{The memory manager}
+ \section{Memory-Manager}
Libgogo provides a very simple memory manager using a bump pointer
which can allocate, but not free memory. By using the
\texttt{sys\_brk}\cite{var97} function, the memory manager expands the data
segment of the running program in steps of 10 KB if necessary in order to
deal with subsequent allocations.\\
As the Go compiler used for boot strapping uses a custom memory
manager in its run time environment, the libgogo memory manager and the
GoGo compiler take measures to avoid conflicts with the former. First and
foremost, all implicit and explicit memory allocations in the GoGo compiler
rely on the libgogo memory manager in order to keep the amount of memory
allocated by the Go run time constant. Additionally, the memory manager
does not allocate any memory in the original data segment to not overwrite
any string constants or other information stored there by the Go run time.
This is achieved by directly expanding the data segment during the
initialization of the libgogo memory manager which also allows to store the
first address allocated, thus being able to distinguish between memory
allocated by the libgogo memory manager and memory allocated by the Go run
time.

@@ -652,7 +654,29 @@
equal, a \texttt{diff} is printed to the user. \texttt{Clean}
deletes
all temporary files.
\end{itemize}
-
+ Listing \ref{lst:test} shows the usage and an example output of the
testsuite.
+\lstset{
+language=bash
+}
+ \begin{lstlisting}[caption=Testsuite example,label=lst:test]
+$ ./testsuite test
+
+>>> Performing internal checks
+
+Checking for sha256sum tool... ok
+Checking for gogo compiler... ok
+Checking for tests... ok
+
+>>> Checking whether an acknowledged resultset exists
+
+>>> Generating tests
+
+Checking for tmp... creating it
+
+>>> Performing quick check
+
+* Checksums matched. Everything seems fine
+ \end{lstlisting}
\bibliographystyle{alpha}
\bibliography{gogo}


==============================================================================
Revision: 42b36d885e
Author: Michael Lippautz <michael....@gmail.com>
Date: Fri Jul 16 00:37:31 2010
Log: documentation: min change
http://code.google.com/p/gogc/source/detail?r=42b36d885e

Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /docs/latex/gogo.pdf Thu Jul 15 08:23:17 2010
+++ /docs/latex/gogo.pdf Fri Jul 16 00:37:31 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Thu Jul 15 08:23:17 2010
+++ /docs/latex/gogo.tex Fri Jul 16 00:37:31 2010
@@ -542,7 +542,7 @@
\label{tbl:syscalls}
\end{table}

- \section{Memory-Manager}
+ \section{Memory manager}
Libgogo provides a very simple memory manager using a bump pointer
which can allocate, but not free memory. By using the
\texttt{sys\_brk}\cite{var97} function, the memory manager expands the data
segment of the running program in steps of 10 KB if necessary in order to
deal with subsequent allocations.\\
As the Go compiler used for boot strapping uses a custom memory
manager in its run time environment, the libgogo memory manager and the
GoGo compiler take measures to avoid conflicts with the former. First and
foremost, all implicit and explicit memory allocations in the GoGo compiler
rely on the libgogo memory manager in order to keep the amount of memory
allocated by the Go run time constant. Additionally, the memory manager
does not allocate any memory in the original data segment to not overwrite
any string constants or other information stored there by the Go run time.
This is achieved by directly expanding the data segment during the
initialization of the libgogo memory manager which also allows to store the
first address allocated, thus being able to distinguish between memory
allocated by the libgogo memory manager and memory allocated by the Go run
time.


==============================================================================
Revision: b0cd5a37e5
Author: Michael Lippautz <michael....@gmail.com>
Date: Fri Jul 16 03:09:38 2010
Log: doc: ..
http://code.google.com/p/gogc/source/detail?r=b0cd5a37e5

Modified:
/docs/latex/gogo.pdf
/docs/latex/gogo.tex

=======================================
--- /docs/latex/gogo.pdf Fri Jul 16 00:37:31 2010
+++ /docs/latex/gogo.pdf Fri Jul 16 03:09:38 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Fri Jul 16 00:37:31 2010
+++ /docs/latex/gogo.tex Fri Jul 16 03:09:38 2010
@@ -184,6 +184,7 @@
representing the byte value 65. \\


+
Before providing a token to the parser, the scanner may convert such
simple tokens one more time. These complex tokens are generated from
simple
ones that represent \texttt{identifiers}. \texttt{Identifiers} are
compared to a
@@ -670,11 +671,9 @@
>>> Checking whether an acknowledged resultset exists

>>> Generating tests
-
Checking for tmp... creating it

>>> Performing quick check
-
* Checksums matched. Everything seems fine
\end{lstlisting}
\bibliographystyle{alpha}

==============================================================================
Revision: 0d24750908
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 15:43:36 2010
Log: fixed author information
http://code.google.com/p/gogc/source/detail?r=0d24750908

Modified:
/AUTHORS
/LICENSE

=======================================
--- /AUTHORS Tue May 18 00:38:21 2010
+++ /AUTHORS Sun Aug 15 15:43:36 2010
@@ -1,3 +1,3 @@
+Scott Lawrence <byt...@gmail.com>
Michael Lippautz <michael....@sbg.ac.at>
Andreas Unterweger <andreas.u...@sbg.ac.at>
-
=======================================
--- /LICENSE Tue Mar 9 13:02:23 2010
+++ /LICENSE Sun Aug 15 15:43:36 2010
@@ -1,4 +1,5 @@
Copyright (c) 2010 Michael Lippautz, Andreas Unterweger
+Copyright (c) 2010 The GoGo Authors

Permission is hereby granted, free of charge, to any person obtaining a
copy
of this software and associated documentation files (the "Software"), to
deal

==============================================================================
Revision: cfc2a79ba1
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:07:26 2010
Log: got rid of go-env file
http://code.google.com/p/gogc/source/detail?r=cfc2a79ba1

Deleted:
/go-env
Modified:
/README

=======================================
--- /go-env Wed Mar 10 11:18:58 2010
+++ /dev/null
@@ -1,5 +0,0 @@
-export GOROOT=$HOME/go
-export GOARCH=amd64
-export GOOS=linux
-
-export PATH=$PATH:$HOME/bin
=======================================
--- /README Wed Mar 10 11:20:59 2010
+++ /README Sun Aug 15 16:07:26 2010
@@ -4,7 +4,6 @@
Building
--------

-1) source go-env
2) cd src/
3) make


==============================================================================
Revision: e67f8da46f
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:12:55 2010
Log: fixed so that it compiles with current version of go (new multiline
string syntax)
http://code.google.com/p/gogc/source/detail?r=e67f8da46f

Modified:
/src/asm_out.go
/src/inspector.go

=======================================
--- /src/asm_out.go Mon Jun 21 13:22:56 2010
+++ /src/asm_out.go Sun Aug 15 16:12:55 2010
@@ -39,20 +39,20 @@
// Reseting the code before a new compile round starts
//
func ResetCode() {
- Header = "\
-//\n\
-// --------------------\n\
-// GoGo compiler output\n\
-// --------------------\n\
-//\n\
-";
+ Header = `
+//\n
+// --------------------\n
+// GoGo compiler output\n
+// --------------------\n
+//\n
+`;
libgogo.StringAppend(&Header, fileInfo[curFileIndex].filename);
- libgogo.StringAppend(&Header,"\n\
-// Syntax: Plan-9 assembler\n\
-//\n\
-// This code is automatically generated. DO NOT EDIT IT!\n\
-//\n\
-");
+ libgogo.StringAppend(&Header,`\n
+// Syntax: Plan-9 assembler\n
+//\n
+// This code is automatically generated. DO NOT EDIT IT!\n
+//\n
+`);
InspectorGadget();
InitCodeSegment = "TEXT main·init(SB),0,$0-0\n";

=======================================
--- /src/inspector.go Fri May 28 09:23:32 2010
+++ /src/inspector.go Sun Aug 15 16:12:55 2010
@@ -7,72 +7,72 @@
import "./libgogo/_obj/libgogo"

func InspectorGadget() {
- libgogo.StringAppend(&Header,"\
-// .........................,,,,,,,,,,,,,,,,,,,,,,,..,..........................\n\
-// ..................,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,..,.....................\n\
-// .............,,,,,,,,,,,,,,,,,,,,,,,,,:,,,..=,..,:,,,,,,,,,,.................\n\
-// ...........,,,,,,,,,,,,,,,,,,,,,::,:::,,D$?IMIIZ.,:,,,,,,,,,,................\n\
-// .......,,,,,,,,,,,,:,::::::::::::::::,.8III?OIIIOM.,,,,,,,,,,,,,,............\n\
-// ......,,...,,,,,,,,,,,:::::::::::::::.MMDZ?+II?IZZM.:,,,,,,,,,,,,,,..........\n\
-// ...,,,,,MNN,,:,::::::::::::::::::::,,8~~~=::INDDZ$8.::,,,,,,,,,,,,,,,........\n\
-// ,,,,,,,,ZMMM.::,:::::::::::::~:~:,,8MM87::~~::~7?7M,::::::,,,,,,,,,,,,,......\n\
-// ,,,,,,,,.ZNM.,:::::::::::::::~:MI?IIIII7???ZM=,7IIM::::::::::,,,,,,,,,,,,....\n\
-// ,,,,,,::,.MN$:::::::::~~:~,~~~~?M??777??7?I7II?8MID::::::::::::,,,,,,,,,,,,,.\n\
-// ,,,,,,:::.MNM::::::::~~~,7M8??7MMMMMM.M$MM7?7I?OZOM::::::::::::::::,,,,,,,,,.\n\
-// ,,,::::::,MMMD$.~~~:~~~~MMMMMMMMMMMM.+::,M..:MNIZOD,:~~:::::::::::::,,,,,,,,,\n\
-// ,:::::::,,MNNZ8M=:::~~~=+MMMMMMMMMMZ~D:::=.Z:..8+MZD,~::~~::::::::::::,,,,,,,\n\
-// :::::::,.+OO8NMDOM:=~~~~::MMMMMNOMM,,~:~::M..MD:?MMMM+,,=~:~:::::::::::,,,,,,\n\
-// ::::::::MN888NDO8M~===~=~+MMMMZ.Z:M,M~:::::~:~::NMMMMMMZ:~~:~~~:::::::::,,,,,\n\
-// :::::::,M8O88DNMN=~===~===~MMM7:~=,N,~::::::~::?8++MMMMM$,~~~~~~~::::::::,,,,\n\
-// :::::~:~ZM8NDONOO$=~======+:NMM::Z.~:~:::::~:~::+N?MMMMZ7~~~~~~~~:::::::::,,,\n\
-// ::::~~~~NDNONDD88Z=~=======+==:MIDM:::~::::::~~::D+MMMMD~=~~~~~~~~~:::::::,,,\n\
-// ::~~~~~~=MO888OD8=====++=++=+=+?::Z:~:~~~~:::~::+OMMMMM:===~~~~~~~~~~:::::::,\n\
-// :::::~~~,78888ONM:====++++++++++D,7:~~:~:~~:~:~INMM=~:~====~~~~~~~~~~::::::::\n\
-// :~~~~~~~=MN888NMM=+=+++++++++++=M~~N8ZM~:::~~:~~+=+++==+=====~~~~~~~~~:::::::\n\
-// :~~~~~~:ON888DMM:+===+++++++++?+D:~::,:~:::~~,M++++==++======~~~~~~~~~:::::::\n\
-//
~~~:=:M,MMM7++=MIM=+=++?++?++?+=Z~::::~::::~:N:++==+=+==========~~~~~~~~:::::\n\
-//
~~~~~,~8.ODNM8O?IM=+++++++?????=+:~,7.+I.7,:7I??DM~++++++========~~~~~~~:::::\n\
-//
~~~=,M,N~~~~~~+IIO+++??+???????N+:::,?MMMM:,DM?II?7++++===========~~~~~~~~:::\n\
-//
~~~=:.:$:~=~~~~ID~++??+????OM?=+?~~~:,MMMM,++D$II?IN+~++++=+=======~~~~~~~:::\n\
-//
~~~~:N$=.~:~~~~I=?+?++~N8OM~?M7:N:~::,MM,Z:M=?N=~Z?I?7M=+=++=======~~~~~~~:::\n\
-//
~~~=~N,N~~~~~~~?==?+=M~8~:::=+:=$,~:~,M$7N,88.MI=~III77D=:~+=======~~~~~~~~::\n\
-//
~~~~=:7~~~~~~~~?$N??M:~:NZNM:~~=~N:~,ZMM,:,.I=:~~~=II7?~8..D+========~~~~~~::\n\
-//
~=~~=,?~~~~~=~:?Z:+:~~~:~~8:~~~~~,:::,::~~+7~~~~~~~7N,~~:?I+:$==~==~=~~~~~~::\n\
-//
~===~~~~~~~~~~~?7:$~~~~~:O:~~~~~~,:~::~::?==~=~~~~:?::~$OI,~:MMMMI~==~~~~~~~~\n\
-//
~====Z:~~~~~=~I8,+:~~~~=D,:~~~=~~~M,,:ON+,~~~~~:=:Z~~~~~~$:~~~~:I?=~=~~~~~~~:\n\
-//
~~==~M~~~~~~:?IO~M:~~~~:M8NM8I::~~~D?,.N:=~~~~~:~N:~~~~~=:~==~==?IZ~==~~~~~~:\n\
-//
~~=~=:~~~~~~:MD~:~~~~~:O:=~:~D=~~~~::.O:=::::7DD::~~~~~~~~~~~~=:IMIDM:~~~~~~:\n\
-//
~==~M~~~~~~~7ID~~~~~~=+:~~~?~==~~~::=?~~~~~8Z,~~~=~~~~~~~~~~~~~=IDI7?D,~:~~~~\n\
-//
~==NI~~~~~~~~~=:~~~~~:M~~~$.~:~~~~~N==~~==:~~,:M~~~~~~~~~~~~~:~?IIIIII7==:~~:\n\
-//
~~~Z$~~~~~~~~~~~~~~::=$+N::,:?M+~:8:~~:,$NN?~::,:~~=:~=~~~~~~~~~~?7IIII?D,~~:\n\
-//
~~~:=+=~~~~=~~~~=I7IIIM=O8,~7=~:+I~::D=:M8:=~=~~~~~~~8~~~~~~~~~~~~=:=7II?D,~~\n\
-//
~~===?O~::~?ZMMN8DMMN?D,7MO??7D=D::MI~~=,=$N~~~~~~~=~M~~~~~~~~~~~~~=~~7III,~~\n\
-//
~~=========+++++++????D:+~~:~~,I:8~~~~~~+Z$+O=,ONNMMMM:~:~:=~~~~~~~~~~~I?N:~~\n\
-//
~~~=======+++++++++??II:~~~=~=NN,=,~:~~:Z.?::$I=::~+78O+,:~~~~~~~~~~~~+7M~:::\n\
-//
~~~~~=======+++++++???7,Z~~~:M8~M.M+~~~=~=:~:~:~~~~7?D~+D$:~~~~~~~~~~:7M~:~::\n\
-//
~~~~~=======++++++++?+M:~=~~+:=~~:=~=~:+8~M:=~~~~~~7?M=+=~M,:,,,::~:~7N,~~:::\n\
-//
~~~~~========+++++++++8~~~~~D:~8M,.:~~:~DZZ~~:~~~~~IIM=++=M~~+?$$NN:=I7~:~:::\n\
-//
~~~~~========++++++++$O8DNO:D??8~7DI=?I7ZMO:=~,~~=:7IN=+~O:~~=~:D$,7I$:::~:::\n\
-//
~~~~~=~~=======+=++++MIII?I,OI7~ZIM~~8IIII?+,OI?IM+7IIM~N~~~=:=I:77M$~~~~~:::\n\
-//
~~~~~~~~=========+++=MIIII?,II?=M7$N:I??III~N?I7I?7?NMNNMD:~~M:~M.?D$~~~:::::\n\
-// :~~~~~~~=~=======+++=N7DMDI:D7?IMMMD?:,~:+8,M7I?IIIZM888N=+M::O~?DO,:~~~:::::\n\
-// :~~~~~~~~~===========M~~~,=,+O?.O:~~~~~Z..M~~::::88DN8OD8N=?IZ:,N8~:=~:::::::\n\
-// :~~~~~~~~~~~========~I~~~:~::+N?7:~=~~~IO78~:~~~~??8NZD88DDNNMMM:::=:::::::::\n\
-// :::~~~~~~~~~~=======~MI~~::~~~~~~~~~~~~~~:~~~~~~~~I$M8N88NNNN8:==~:~::::::::,\n\
-// ::::~~~~~~~~~~~=====~N~~~,,~~~~~~~~~~~~~~~~~~~~~~:IZMDOD8DNMNN.:~~~::::::::,,\n\
-// ::::::~~~~~~~~~~~===:Z=~~,,~~~~~~~~~~~~~~~~~~~~~~~7$N8888DNMMNM$:::::::::,,,,\n\
-// :::::::~~~~~~~~~~~=~,=~~~,,~~~~~~~~~~~~~~~~~~~~~~~7IN888ODNNNMO,::::::::,,,,,\n\
-// ::::::::~~~~~~~~~~~~::~~:+,~~~~~~~~~~~~~~~~~~~~~~:II?N888NNMO,~,::::::::,,,,,\n\
-// ,::::::::::~~~~~~~~:$:~~:8:~~~~~~~~~~~~~~~~~~~~~~:77IM:O8Z,:~:~~::::::,,,,,,,\n\
-// ,,:::::::::::::::~~:M~~~=N~~~~~~~~~~~~~~~~~~~~~~~~IIIM~~~:::::::::::::,,,,,,,\n\
-// ,,,:::::::::::::::~=M~~~8I~~~~~~~~~~~~~~~~~~~~~~~~?IIM:~~::::::::::::,,,,,,,,\n\
-// ,,,,,,:::::::::::::D?~~~N:~~~~~~~~~~~~~~~~~~~~~~~~=IIN,:::::::::,:,,,,,,,,,..\n\
-// ,,,,,,,,,::::::::::M:~~:O:~~~~~~~~~~~~~~~~~~~~~~~~~IIN,::::::::,,,,,,,,,,,,..\n\
-// ,,,,,,,,,:::::::::,8,~~:?:~~~~~~~~~~~~~~~~~~~~~~~~~II8.::::::::,,,,,,,,,.....\n\
-// ,,,,,,,,,,,,::::,:.$:~~,:~~~~~~~~~~~~~~~~~~~~~~~~~:IIZ,::::,,,,,,,,,,,,,.....\n\
-// .,,,,,,,,,,,,,,,::.7:~~:,~~~~~~~~~~~~~~~~~~~~~~~~~:II?.:,,,,,,,,,,,,,........\n\
-// ......,,,,,,,,,,,:.?~~~::~~~~~~~~~~~~~~~~~~~~~~~~~:I7??:,,,,,,,,,,...........\n\
-// ........,,,,,,,,,,.:~~~::~~~~~~~~~~~~~~~~~~~~~~~~~:7II7,,,,,,,...............\n\
-// ........,,,,,,,,,,~~~~~+~~~~~~~~~~~~~~~~~~~~~~~~~~~III7,,,,,,,,..............\n\
-");
-}
+ libgogo.StringAppend(&Header,`
+// .........................,,,,,,,,,,,,,,,,,,,,,,,..,..........................\n
+// ..................,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,..,.....................\n
+// .............,,,,,,,,,,,,,,,,,,,,,,,,,:,,,..=,..,:,,,,,,,,,,.................\n
+// ...........,,,,,,,,,,,,,,,,,,,,,::,:::,,D$?IMIIZ.,:,,,,,,,,,,................\n
+// .......,,,,,,,,,,,,:,::::::::::::::::,.8III?OIIIOM.,,,,,,,,,,,,,,............\n
+// ......,,...,,,,,,,,,,,:::::::::::::::.MMDZ?+II?IZZM.:,,,,,,,,,,,,,,..........\n
+// ...,,,,,MNN,,:,::::::::::::::::::::,,8~~~=::INDDZ$8.::,,,,,,,,,,,,,,,........\n
+// ,,,,,,,,ZMMM.::,:::::::::::::~:~:,,8MM87::~~::~7?7M,::::::,,,,,,,,,,,,,......\n
+// ,,,,,,,,.ZNM.,:::::::::::::::~:MI?IIIII7???ZM=,7IIM::::::::::,,,,,,,,,,,,....\n
+// ,,,,,,::,.MN$:::::::::~~:~,~~~~?M??777??7?I7II?8MID::::::::::::,,,,,,,,,,,,,.\n
+// ,,,,,,:::.MNM::::::::~~~,7M8??7MMMMMM.M$MM7?7I?OZOM::::::::::::::::,,,,,,,,,.\n
+// ,,,::::::,MMMD$.~~~:~~~~MMMMMMMMMMMM.+::,M..:MNIZOD,:~~:::::::::::::,,,,,,,,,\n
+// ,:::::::,,MNNZ8M=:::~~~=+MMMMMMMMMMZ~D:::=.Z:..8+MZD,~::~~::::::::::::,,,,,,,\n
+// :::::::,.+OO8NMDOM:=~~~~::MMMMMNOMM,,~:~::M..MD:?MMMM+,,=~:~:::::::::::,,,,,,\n
+// ::::::::MN888NDO8M~===~=~+MMMMZ.Z:M,M~:::::~:~::NMMMMMMZ:~~:~~~:::::::::,,,,,\n
+// :::::::,M8O88DNMN=~===~===~MMM7:~=,N,~::::::~::?8++MMMMM$,~~~~~~~::::::::,,,,\n
+// :::::~:~ZM8NDONOO$=~======+:NMM::Z.~:~:::::~:~::+N?MMMMZ7~~~~~~~~:::::::::,,,\n
+// ::::~~~~NDNONDD88Z=~=======+==:MIDM:::~::::::~~::D+MMMMD~=~~~~~~~~~:::::::,,,\n
+// ::~~~~~~=MO888OD8=====++=++=+=+?::Z:~:~~~~:::~::+OMMMMM:===~~~~~~~~~~:::::::,\n
+// :::::~~~,78888ONM:====++++++++++D,7:~~:~:~~:~:~INMM=~:~====~~~~~~~~~~::::::::\n
+// :~~~~~~~=MN888NMM=+=+++++++++++=M~~N8ZM~:::~~:~~+=+++==+=====~~~~~~~~~:::::::\n
+// :~~~~~~:ON888DMM:+===+++++++++?+D:~::,:~:::~~,M++++==++======~~~~~~~~~:::::::\n
+//
~~~:=:M,MMM7++=MIM=+=++?++?++?+=Z~::::~::::~:N:++==+=+==========~~~~~~~~:::::\n
+//
~~~~~,~8.ODNM8O?IM=+++++++?????=+:~,7.+I.7,:7I??DM~++++++========~~~~~~~:::::\n
+//
~~~=,M,N~~~~~~+IIO+++??+???????N+:::,?MMMM:,DM?II?7++++===========~~~~~~~~:::\n
+//
~~~=:.:$:~=~~~~ID~++??+????OM?=+?~~~:,MMMM,++D$II?IN+~++++=+=======~~~~~~~:::\n
+//
~~~~:N$=.~:~~~~I=?+?++~N8OM~?M7:N:~::,MM,Z:M=?N=~Z?I?7M=+=++=======~~~~~~~:::\n
+//
~~~=~N,N~~~~~~~?==?+=M~8~:::=+:=$,~:~,M$7N,88.MI=~III77D=:~+=======~~~~~~~~::\n
+//
~~~~=:7~~~~~~~~?$N??M:~:NZNM:~~=~N:~,ZMM,:,.I=:~~~=II7?~8..D+========~~~~~~::\n
+//
~=~~=,?~~~~~=~:?Z:+:~~~:~~8:~~~~~,:::,::~~+7~~~~~~~7N,~~:?I+:$==~==~=~~~~~~::\n
+//
~===~~~~~~~~~~~?7:$~~~~~:O:~~~~~~,:~::~::?==~=~~~~:?::~$OI,~:MMMMI~==~~~~~~~~\n
+//
~====Z:~~~~~=~I8,+:~~~~=D,:~~~=~~~M,,:ON+,~~~~~:=:Z~~~~~~$:~~~~:I?=~=~~~~~~~:\n
+//
~~==~M~~~~~~:?IO~M:~~~~:M8NM8I::~~~D?,.N:=~~~~~:~N:~~~~~=:~==~==?IZ~==~~~~~~:\n
+//
~~=~=:~~~~~~:MD~:~~~~~:O:=~:~D=~~~~::.O:=::::7DD::~~~~~~~~~~~~=:IMIDM:~~~~~~:\n
+//
~==~M~~~~~~~7ID~~~~~~=+:~~~?~==~~~::=?~~~~~8Z,~~~=~~~~~~~~~~~~~=IDI7?D,~:~~~~\n
+//
~==NI~~~~~~~~~=:~~~~~:M~~~$.~:~~~~~N==~~==:~~,:M~~~~~~~~~~~~~:~?IIIIII7==:~~:\n
+//
~~~Z$~~~~~~~~~~~~~~::=$+N::,:?M+~:8:~~:,$NN?~::,:~~=:~=~~~~~~~~~~?7IIII?D,~~:\n
+//
~~~:=+=~~~~=~~~~=I7IIIM=O8,~7=~:+I~::D=:M8:=~=~~~~~~~8~~~~~~~~~~~~=:=7II?D,~~\n
+//
~~===?O~::~?ZMMN8DMMN?D,7MO??7D=D::MI~~=,=$N~~~~~~~=~M~~~~~~~~~~~~~=~~7III,~~\n
+//
~~=========+++++++????D:+~~:~~,I:8~~~~~~+Z$+O=,ONNMMMM:~:~:=~~~~~~~~~~~I?N:~~\n
+//
~~~=======+++++++++??II:~~~=~=NN,=,~:~~:Z.?::$I=::~+78O+,:~~~~~~~~~~~~+7M~:::\n
+//
~~~~~=======+++++++???7,Z~~~:M8~M.M+~~~=~=:~:~:~~~~7?D~+D$:~~~~~~~~~~:7M~:~::\n
+//
~~~~~=======++++++++?+M:~=~~+:=~~:=~=~:+8~M:=~~~~~~7?M=+=~M,:,,,::~:~7N,~~:::\n
+//
~~~~~========+++++++++8~~~~~D:~8M,.:~~:~DZZ~~:~~~~~IIM=++=M~~+?$$NN:=I7~:~:::\n
+//
~~~~~========++++++++$O8DNO:D??8~7DI=?I7ZMO:=~,~~=:7IN=+~O:~~=~:D$,7I$:::~:::\n
+//
~~~~~=~~=======+=++++MIII?I,OI7~ZIM~~8IIII?+,OI?IM+7IIM~N~~~=:=I:77M$~~~~~:::\n
+//
~~~~~~~~=========+++=MIIII?,II?=M7$N:I??III~N?I7I?7?NMNNMD:~~M:~M.?D$~~~:::::\n
+// :~~~~~~~=~=======+++=N7DMDI:D7?IMMMD?:,~:+8,M7I?IIIZM888N=+M::O~?DO,:~~~:::::\n
+// :~~~~~~~~~===========M~~~,=,+O?.O:~~~~~Z..M~~::::88DN8OD8N=?IZ:,N8~:=~:::::::\n
+// :~~~~~~~~~~~========~I~~~:~::+N?7:~=~~~IO78~:~~~~??8NZD88DDNNMMM:::=:::::::::\n
+// :::~~~~~~~~~~=======~MI~~::~~~~~~~~~~~~~~:~~~~~~~~I$M8N88NNNN8:==~:~::::::::,\n
+// ::::~~~~~~~~~~~=====~N~~~,,~~~~~~~~~~~~~~~~~~~~~~:IZMDOD8DNMNN.:~~~::::::::,,\n
+// ::::::~~~~~~~~~~~===:Z=~~,,~~~~~~~~~~~~~~~~~~~~~~~7$N8888DNMMNM$:::::::::,,,,\n
+// :::::::~~~~~~~~~~~=~,=~~~,,~~~~~~~~~~~~~~~~~~~~~~~7IN888ODNNNMO,::::::::,,,,,\n
+// ::::::::~~~~~~~~~~~~::~~:+,~~~~~~~~~~~~~~~~~~~~~~:II?N888NNMO,~,::::::::,,,,,\n
+// ,::::::::::~~~~~~~~:$:~~:8:~~~~~~~~~~~~~~~~~~~~~~:77IM:O8Z,:~:~~::::::,,,,,,,\n
+// ,,:::::::::::::::~~:M~~~=N~~~~~~~~~~~~~~~~~~~~~~~~IIIM~~~:::::::::::::,,,,,,,\n
+// ,,,:::::::::::::::~=M~~~8I~~~~~~~~~~~~~~~~~~~~~~~~?IIM:~~::::::::::::,,,,,,,,\n
+// ,,,,,,:::::::::::::D?~~~N:~~~~~~~~~~~~~~~~~~~~~~~~=IIN,:::::::::,:,,,,,,,,,..\n
+// ,,,,,,,,,::::::::::M:~~:O:~~~~~~~~~~~~~~~~~~~~~~~~~IIN,::::::::,,,,,,,,,,,,..\n
+// ,,,,,,,,,:::::::::,8,~~:?:~~~~~~~~~~~~~~~~~~~~~~~~~II8.::::::::,,,,,,,,,.....\n
+// ,,,,,,,,,,,,::::,:.$:~~,:~~~~~~~~~~~~~~~~~~~~~~~~~:IIZ,::::,,,,,,,,,,,,,.....\n
+// .,,,,,,,,,,,,,,,::.7:~~:,~~~~~~~~~~~~~~~~~~~~~~~~~:II?.:,,,,,,,,,,,,,........\n
+// ......,,,,,,,,,,,:.?~~~::~~~~~~~~~~~~~~~~~~~~~~~~~:I7??:,,,,,,,,,,...........\n
+// ........,,,,,,,,,,.:~~~::~~~~~~~~~~~~~~~~~~~~~~~~~:7II7,,,,,,,...............\n
+// ........,,,,,,,,,,~~~~~+~~~~~~~~~~~~~~~~~~~~~~~~~~~III7,,,,,,,,..............\n
+`);
+}

==============================================================================
Revision: 7e1d327a7e
Author: Scott Lawrence <byt...@gmail.com>
Date: Sun Aug 15 16:13:58 2010
Log: .hgignore file to ignore .6, .a, and the executable
http://code.google.com/p/gogc/source/detail?r=7e1d327a7e

Added:
/.hgignore

=======================================
--- /dev/null
+++ /.hgignore Sun Aug 15 16:13:58 2010
@@ -0,0 +1,4 @@
+syntax:glob
+*.6
+src/gogo
+*.a

==============================================================================
Revision: 7950421fae
Author: Scott Lawrence <byt...@gmail.com>
Date: Tue Aug 17 09:58:38 2010
Log: changed branding from GoGo to GoGC
http://code.google.com/p/gogc/source/detail?r=7950421fae

Modified:
/LICENSE
/README
/docs/latex/gogo.pdf
/docs/latex/gogo.tex
/docs/pres/gogo.tex
/src/Makefile
/src/asm_out.go
/src/codegen.go
/src/gen-arith.go
/src/gen-assign.go
/src/gen-cond.go
/src/gen-const.go
/src/gen-expr.go
/src/gen-fcn.go
/src/gen-for.go
/src/gen-if.go
/src/globals.go
/src/gogo.go
/src/libgogo/Makefile
/src/libgogo/convert.go
/src/libgogo/convert_amd64.s
/src/libgogo/io.go
/src/libgogo/io_amd64.s
/src/libgogo/item.go
/src/libgogo/item_amd64.s
/src/libgogo/libgogo.go
/src/libgogo/libgogo_amd64.s
/src/libgogo/list.go
/src/libgogo/memmgr.go
/src/libgogo/memmgr_amd64.s
/src/libgogo/stack.go
/src/libgogo/string.go
/src/libgogo/string_amd64.s
/src/libgogo/strlist.go
/src/libgogo/symbol.go
/src/libgogo/symbol_amd64.s
/src/libgogo/test/libgogotest.go
/src/linker.go
/src/parse-utils.go
/src/parser.go
/src/sc
/src/scanner.go
/src/symtable.go
/src/token.go
/src/utils.go
/testing/results/_gogo_.sog
/testing/tests/2010-03-21_fail.go
/testing/tests/2010-03-21_gogo_fail.go
/testing/tests/2010-03-21_large_number.go
/testing/tests/2010-03-21_scanner_fail_semicolon.go
/testing/tests/2010-03-21_token.go
/testing/tests/2010-04-11_parse_imports_fail.go
/testing/tests/2010-04-11_struct1.go
/testing/tests/2010-04-11_struct2.go
/testing/tests/2010-04-11_struct3_fail.go
/testing/tests/2010-04-11_struct4_fail.go
/testing/tests/2010-04-11_struct5_fail.go
/testing/tests/2010-04-11_struct6_fail.go
/testing/tests/2010-04-11_struct7.go
/testing/tests/2010-04-11_vardecl1.go
/testing/tests/2010-04-11_vardecl2.go
/testing/tests/2010-05-09_struct8_fail.go
/testing/tests/2010-05-09_struct9.go
/testing/tests/2010-05-09_symtable_fail.go
/testing/testsuite

=======================================
--- /LICENSE Sun Aug 15 15:43:36 2010
+++ /LICENSE Tue Aug 17 09:58:38 2010
@@ -1,5 +1,5 @@
Copyright (c) 2010 Michael Lippautz, Andreas Unterweger
-Copyright (c) 2010 The GoGo Authors
+Copyright (c) 2010 The GoGC Authors

Permission is hereby granted, free of charge, to any person obtaining a
copy
of this software and associated documentation files (the "Software"), to
deal
=======================================
--- /README Sun Aug 15 16:07:26 2010
+++ /README Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-GoGo - A Go compiler written in Go
+GoGC - A Go compiler written in Go
==================================

Building
=======================================
--- /docs/latex/gogo.pdf Fri Jul 16 03:09:38 2010
+++ /docs/latex/gogo.pdf Tue Aug 17 09:58:38 2010
Binary file, no diff available.
=======================================
--- /docs/latex/gogo.tex Fri Jul 16 03:09:38 2010
+++ /docs/latex/gogo.tex Tue Aug 17 09:58:38 2010
@@ -14,9 +14,9 @@
\usepackage[english]{babel}
\usepackage[pdftex,plainpages=false,pdfpagelabels,
hyperfootnotes=false]{hyperref}
-\hypersetup{pdftitle={GoGo -- A Go compiler written in Go},
+\hypersetup{pdftitle={GoGC -- A Go compiler written in Go},
pdfauthor={Michael Lippautz, Andreas Unterweger},
- pdfsubject={GoGo},pdfkeywords={Go,Compiler,GoGo}}
+ pdfsubject={GoGC},pdfkeywords={Go,Compiler,GoGC}}
\usepackage{graphicx}

\definecolor{lightgray}{RGB}{250,250,250}
@@ -27,7 +27,7 @@
backgroundcolor=\color{lightgray}
}

-\title{GoGo\\ \large{A Go compiler written in Go}}
+\title{GoGC\\ \large{A Go compiler written in Go}}
\author{
Michael~Lippautz \\ \normalsize{\texttt{michael....@sbg.ac.at}}
\and
@@ -41,7 +41,7 @@
\tableofcontents

\chapter{Introduction}
- GoGo is a self-compiling (see section \ref{chpt:building}) Go compiler
+ GoGC is a self-compiling (see section \ref{chpt:building}) Go compiler
written in Go which implements scanning, parsing and code generation
for a
subset of the Go language \cite{goo10}. It is mostly compatible with
the Go
compiler available at \cite{goo10} and outputs valid Plan9 assembly
code
@@ -50,29 +50,29 @@


\chapter{Input language}
- Go is a programming language developed by Google, based on a C like
syntax and fully specified in \cite{goo10}. The input language follows the
one defined by Go. This results in programs being able to be compiled by
the official Go compilers and GoGo.
+ Go is a programming language developed by Google, based on a C like
syntax and fully specified in \cite{goo10}. The input language follows the
one defined by Go. This results in programs being able to be compiled by
the official Go compilers and GoGC.

\section{Some differences to Go}
\begin{enumerate}
- \item GoGo only provides only a \textbf{very} basic featureset.
Expect
+ \item GoGC only provides only a \textbf{very} basic featureset.
Expect
every advanced and interesting feature to be missing.
- \item GoGo forces the usage of semicolons at the end of statements,
+ \item GoGC forces the usage of semicolons at the end of statements,
while in actual Go this token is optional. This restriction was
made
to make parsing easier.
- \item Go is fully Unicode compatible, while GoGo uses ASCII
characters only.
+ \item Go is fully Unicode compatible, while GoGC uses ASCII
characters only.
\item Simplified expressions, following Wirth's
defintions\cite{wir96}.
\end{enumerate}

\section{EBNF}
\label{sec:ebnf}
The following section deals with the input language specification in
- EBNF form. Additionally to the specification below, GoGo also allows
+ EBNF form. Additionally to the specification below, GoGC also allows
source code comments following the C++ multiline
style(\texttt{/* ... */})
and the C inline style (\texttt{//}).

\subsection*{Atoms}
The following listing describes the basic atoms that are possible
in
- GoGo programs.
+ GoGC programs.
\begin{lstlisting}[caption=Atoms]
single_char = CHR(32)|...|CHR(127).
char = "'" single_char "'".
@@ -158,10 +158,10 @@
func_decl_list = { func_decl_head (func_decl | func_decl_raw)
\end{lstlisting}

- \subsection*{The GoGo Program}
+ \subsection*{The GoGC Program}
Finally, the main program structure is defined by
\texttt{go\_program}. The sequence of the various program parts has been
forced to the following to make parsing easier.

- \begin{lstlisting}[caption=GoGo Program]
+ \begin{lstlisting}[caption=GoGC Program]
go_program = package_stmt import_stmt_list struct_decl_list
var_decl_list func_decl_list.
\end{lstlisting}
@@ -171,8 +171,8 @@
The output language is Plan-9 assembler \cite{pik00}. It is a modified
version of 64 bit assembly for Intel x86 processors with AT\&T syntax that
has been created by Bell Labs to be used in their compiler and assembler
collection.

\section{Assembly output}
- GoGo creates an output file with assembly instructions and comments
using mnemonics for op codes and operands/registers which means that it
outputs in text form, not in binary form. Thereforce, an assembler is
needed to process the output in order to make it executable. Like the Go
compiler, GoGo relies on \texttt{6a} and \texttt{6l} of the Plan9 tools in
order to acomplish this\cite{pik00}.\\
- The assembly output consists basically of three sections: the data
segment, the initialization segment and the code segment. GoGo's assembly
output framework provides basic output routines which make it possible to
switch between those three segments. Whereas the data segment is used to
reserve space for global variables and strings in the data segment, the
initialization segment and the code segment contain the code for global
variable initialization and the functions from the input, respectively. All
other functions (code generation for arithmetical expressions etc.) rely on
the assembly output framework which is also able to place comments with the
corresponding input file name and line number for debugging purposes in the
output file.
+ GoGC creates an output file with assembly instructions and comments
using mnemonics for op codes and operands/registers which means that it
outputs in text form, not in binary form. Thereforce, an assembler is
needed to process the output in order to make it executable. Like the Go
compiler, GoGC relies on \texttt{6a} and \texttt{6l} of the Plan9 tools in
order to acomplish this\cite{pik00}.\\
+ The assembly output consists basically of three sections: the data
segment, the initialization segment and the code segment. GoGC's assembly
output framework provides basic output routines which make it possible to
switch between those three segments. Whereas the data segment is used to
reserve space for global variables and strings in the data segment, the
initialization segment and the code segment contain the code for global
variable initialization and the functions from the input, respectively. All
other functions (code generation for arithmetical expressions etc.) rely on
the assembly output framework which is also able to place comments with the
corresponding input file name and line number for debugging purposes in the
output file.

\chapter{Scanner / Parser}
The scanner is basically the provider of tokens that are used by the
parser
@@ -262,7 +262,7 @@
Forward declarations are currently only supported for type pointers
(as pointers are always 64 bits in size) and functions (as the affected
offsets can be fixed by the linker if necessary). Whenever supported
forward declarations are encountered, a new symbol table entry is created
with \texttt{ForwardDecl} set to 1. Forward declared function can then be
called, although forward declared type pointers cannot be dereferred until
the size of the type they are pointing to is known (\texttt{ForwardDecl} is
0). When forward declared functions are implemented, the corresponding
symbol table entry is modified (\texttt{ForwardDecl} is set to 0) instead
of creating a new one.

\section{Supported data types}
- GoGo supports 4 built-in value types and the declaration of new
struct and array types as well as pointers to value, struct and array
types. The 4 built-in data types are based on the data types supported by
the Go compiler and form a minimal subset of them in order to perform basic
integer and string operations. The following table \ref{tbl:types} lists
the built-in value types, together with their purpose and size.
+ GoGC supports 4 built-in value types and the declaration of new
struct and array types as well as pointers to value, struct and array
types. The 4 built-in data types are based on the data types supported by
the Go compiler and form a minimal subset of them in order to perform basic
integer and string operations. The following table \ref{tbl:types} lists
the built-in value types, together with their purpose and size.

\begin{table}[htb]
\centering
@@ -302,16 +302,16 @@
Offset calculations within types (p.e. calculating the field offsets
in a struct or an array index) require a slightly different handling.
Global variables as well as parameters can be treated the same way as
explained above as their internal offsets' ascending order corresponds to
their memory layout (ascending addresses). Local variables require a
different calculation as their memory layout (descending addresses)
differs. This is necessary in order to be able to assign global to local
variables and vice verse so that their internal memory layouts correspond
from the programmer's point of view. This is also done by a distinction
based on the item's \texttt{Global} flag as explained above: during code
generation, the internal offset of a local variable has to be calculated by
subtraction instead of addition due to the negative sign of the offset
(also see table above).

\chapter{Code generation}
- GoGo emits assembly code in text form based on the Go input files.
This section briefly explains the main features implemented in the code
generating functions of GoGo.
+ GoGC emits assembly code in text form based on the Go input files.
This section briefly explains the main features implemented in the code
generating functions of GoGC.

\section{Register allocation}
- The target architecture provides 8 general purpose registers
(\texttt{R8}-\texttt{R15}) as well as the registers \texttt{RAX},
\texttt{RBX}, \texttt{RCX} and \texttt{RDX}\cite{int09}. The latter are not
being used by GoGo to store variables as their values may change when
performing arithmetical operations (p.e. \texttt{RAX} and \texttt{RDX} are
always used as the destination registers for multiplications), thus
possibly overwriting values previously stored there.\\
- GoGo stores a list for every one of the 8 registers currently
free, returning the first free register if required by the code generator.
Whenever a register is no longer required (freed), it will be reinserted
into the "free" list in order to make it available for future use. Due to
the limited amout of registers, the list described is implemented in form
of a bit array in the compiler.
+ The target architecture provides 8 general purpose registers
(\texttt{R8}-\texttt{R15}) as well as the registers \texttt{RAX},
\texttt{RBX}, \texttt{RCX} and \texttt{RDX}\cite{int09}. The latter are not
being used by GoGC to store variables as their values may change when
performing arithmetical operations (p.e. \texttt{RAX} and \texttt{RDX} are
always used as the destination registers for multiplications), thus
possibly overwriting values previously stored there.\\
+ GoGC stores a list for every one of the 8 registers currently
free, returning the first free register if required by the code generator.
Whenever a register is no longer required (freed), it will be reinserted
into the "free" list in order to make it available for future use. Due to
the limited amout of registers, the list described is implemented in form
of a bit array in the compiler.

\section{Generation of arithmetical expressions}
As described in \cite{wir96}, code generation for arithmetical
expressions basically relies on an operand stack and delayed code
generation based on \texttt{Items}. For constant operands, constant folding
is applied; variable operands are loaded into a free register in order to
perform arithmetical operations on them.\\
- GoGo makes use of the capabilities of the target architecture by not
loading constants into registers, thus reducing the number of registers
required. Consider the expression \texttt{a + b} where both \texttt{a} and
\texttt{b} are variables of type \texttt{uint64} with negative offsets 8
and 16 relative to the stack pointer. As the target architecture is able to
perform an operation like \texttt{ADDQ R8, -16(SP)} (add the value at
address \texttt{SP-16} to the register \texttt{R8}), only \texttt{a} needs
to be loaded into a register, whereas \texttt{b} can be directly
incorporated into the instruction itself.\\
- Multiplication and division on the target architecture both require
special treatment: The multiplication instruction only takes the second
operand and requires the first operand to be in the register
\texttt{RAX}\cite{int09}. Therefore, the first operand has to be loaded
into \texttt{RAX} prior multiplication. The multiplication result is stored
as 128 bit value in \texttt{RDX} (upper 64 bits) and \texttt{RAX} (lower 64
bits). As GoGo does not support data types other than \texttt{byte} and
\texttt{uint64}, the upper 64 bits in \texttt{RDX} are ignored, and the
lower 64 bits are moved to one of the 8 registers to save the result before
another multiplication is being performed. Similarly, division allows for
an 128 bit operand (also in \texttt{RDX} and \texttt{RAX}). As GoGo does
not support 128 bit size data types, \texttt{RDX} is always being zeroed
prior division.\\
+ GoGC makes use of the capabilities of the target architecture by not
loading constants into registers, thus reducing the number of registers
required. Consider the expression \texttt{a + b} where both \texttt{a} and
\texttt{b} are variables of type \texttt{uint64} with negative offsets 8
and 16 relative to the stack pointer. As the target architecture is able to
perform an operation like \texttt{ADDQ R8, -16(SP)} (add the value at
address \texttt{SP-16} to the register \texttt{R8}), only \texttt{a} needs
to be loaded into a register, whereas \texttt{b} can be directly
incorporated into the instruction itself.\\
+ Multiplication and division on the target architecture both require
special treatment: The multiplication instruction only takes the second
operand and requires the first operand to be in the register
\texttt{RAX}\cite{int09}. Therefore, the first operand has to be loaded
into \texttt{RAX} prior multiplication. The multiplication result is stored
as 128 bit value in \texttt{RDX} (upper 64 bits) and \texttt{RAX} (lower 64
bits). As GoGC does not support data types other than \texttt{byte} and
\texttt{uint64}, the upper 64 bits in \texttt{RDX} are ignored, and the
lower 64 bits are moved to one of the 8 registers to save the result before
another multiplication is being performed. Similarly, division allows for
an 128 bit operand (also in \texttt{RDX} and \texttt{RAX}). As GoGC does
not support 128 bit size data types, \texttt{RDX} is always being zeroed
prior division.\\
The addition, substraction and multiplication operations are also
used for offset calculations. Thus, an additional distinction per
\texttt{Item} is required in order to be able to distinguish between
addresses and values stored in registers. As arithmetical operations on
\texttt{byte} and \texttt{uint64} types always operate on a value, the
actual value to be calculated with has to be loaded prior calculation. As
offset calculations always require the address to be loaded into the
register instead of the value, it has to be made sure that the address is
loaded, not the value. In order to distinguish between addresses and values
in registers, the \texttt{A} field of the \texttt{Item} structure is used.
Additionally, the code generation routines for addition and subtraction
have an additional parameter specifying whether to calculate with addresses
or values, issuing the necessary dereferencing operations if required.

\section{Generation of assignments}
@@ -339,13 +339,13 @@
String assignments are handled separately as they require 16 bytes
to be assigned. As one register can only hold 8 bytes, a second register
needs to be allocated in order to perform the assignment. Although this may
not be necessary in trivial cases where one string variable is assigned to
another, strings in structures which require offset calculations force the
use of a register when performing the offset calculation and therefore
require a second register to dereference the value of the other 8 bytes. In
order to be able to do this, the \texttt{C} field of the \texttt{Item}
structure is being used as it is not needed for other purposes outside
conditionals.

\section{Generation of conditional expressions and control structures}
- In order to achieve condional jumps, GoGo (and thus Go) provides
expressions
+ In order to achieve condional jumps, GoGC (and thus Go) provides
expressions
that allow comparisons (\texttt{==}, \texttt{!=}, \texttt{$>$},
\texttt{$<$},
\texttt{$\ge$}, \texttt{$\le$}) and relative operators
(\texttt{\&\&},
\texttt{$||$}). The approach how code is generated differs from
\cite{wir96}.
Since our output language is text-based Plan9 assembly, there exists
no way
to create a fixup chain that could be used to fix conditional jumps
after
- generating the code. As a result, GoGo creates labels that are then
+ generating the code. As a result, GoGC creates labels that are then
translated into adresses by the Plan9 assembly tools. \\

Since jumps are always generation after comparisons the code
generation
@@ -377,19 +377,19 @@
\begin{itemize}
\item Each label has a suffix indicating whether it is used by an
\texttt{if/else} or \texttt{for} statement.
- \item Per convinience (Go forces this) programs compiled with GoGo
+ \item Per convinience (Go forces this) programs compiled with GoGC
are only allowed to have one statement (or control structure) per
line. A side-effect of this limitation is that the addition of
line
and column number of the expression into the label guarantees
global
uniqueness.
\item Furthermore, an expression local counter, representing a
\texttt{true}
or \texttt{false} branch is included.
- \item A simple prefix (used for debugging readability) makes a GoGo
+ \item A simple prefix (used for debugging readability) makes a GoGC
label complete.
\end{itemize}

In order to provide common programming constructs that involve
pointer
- comparisons (see listing \ref{lst:pointer}), GoGo uses
lazy-evaluation.
+ comparisons (see listing \ref{lst:pointer}), GoGC uses
lazy-evaluation.

\begin{lstlisting}[label=lst:pointer,caption=Pointer comparison]
if object != nil && object.field ... {
@@ -410,7 +410,7 @@
merging points.

\subsection*{Conditional Jumps}
- GoGo provides one control structure that can be used for conditional
jumps,
+ GoGC provides one control structure that can be used for conditional
jumps,
namely \texttt{if}/\texttt{else}. While elseif and case statements
could
have provided further programming experience, the compiler itself
uses only
\texttt{if}. The \texttt{if}/\texttt{else} construct uses the
condional
@@ -430,7 +430,7 @@
\end{table}

\subsection*{Loops}
- GoGo supports only \texttt{for} structures to construct loops,
because
+ GoGC supports only \texttt{for} structures to construct loops,
because
Go doesn't offer any other form of loops itself. In order to provide
a more
lightweight loop variant, one may skip parts of the \texttt{for}
construct.
The language construct is defined as follows:
@@ -506,7 +506,7 @@
\bottomrule
\end{tabular}
\end{table}\\ \\
- As can be seen, the offsets before and after the call differ by
\texttt{72+8=80} as explained above. GoGo does not use base or frame
pointers, but relies only on the stack pointer to perform all offset
calculations. The return value is always located "after" the other
parameters and can be used as the RHS of an assignment with its known
offset as explained with the parameters above. After the function call, 80
is added to the stack pointer in order to restore the previous stack "view"
for the callee. Optionally saved registered are restored considering their
additional offset in reverse order.\\
+ As can be seen, the offsets before and after the call differ by
\texttt{72+8=80} as explained above. GoGC does not use base or frame
pointers, but relies only on the stack pointer to perform all offset
calculations. The return value is always located "after" the other
parameters and can be used as the RHS of an assignment with its known
offset as explained with the parameters above. After the function call, 80
is added to the stack pointer in order to restore the previous stack "view"
for the callee. Optionally saved registered are restored considering their
additional offset in reverse order.\\
Internally, a function is represented by a \texttt{TypeDesc}
(compare table \ref{tbl:typedesc}) where the fields represent the functions
parmaeters, including an optional return value at their end. When a
function is being called without prior declaration, the parameter types
have to be derived from the types of the expressions encountered. As the
total number of parameters is unknown before the end function call in the
input file, a marker is inserted in the output code and comments to
indicate that the final offset has yet to be determined. As the offset due
to local variables is known, it is included. Due to the marker which
includes information about the name of the function called, the linker is
able to adapt the unfinished offsets in order to correct them accordingly.\\
When functions have been called, but not declared, and then called
again, the type check included in the code generation for assignments is
already effective and detects improper assignment types. However, it is
necessary to extend this check as the first call can p.e. be with a
parameter of type \texttt{byte} and the second call with a parameter of
type \texttt{uint64}. This is allowed, as a \texttt{byte} type represents a
subset of the \texttt{uint64} type, requiring a conversion for the former
in order to assure that the 7 additional bytes are zero. This can be done
by simply extending the type check of the assignment. This also applies to
the return value (as it is treated like a parameter), although it has to be
considered that calls of functions without return value assignments do not
necessarily mean that the function called has no return value. Therefore,
additional checks are necessary, including the check of the return value's
existence and type when the actual function declaration is being made.

@@ -519,7 +519,7 @@
Whenever a string constant is found in the input code, a new byte
array with the string's length is declared and initialized with the
string's characters. Next, another 16 bytes are allocated which represent
the actual string. Using the main.init function as described in the
previous section, the string's length and the previously allocated byte
array address are assigned to the according offsets of the string in the
data segment. When assigning the string constant (or using it as a
parameter), an item representing a data segment variable with the string's
address is used, therefore eliminating the need for any further special
treatment.

\chapter{Library and run time}
- In order to be able to perform I/O operations and memory management, a
library called libgogo is implemented which wraps Linux syscalls and
provides an easy to use interface to the GoGo compiler. As GoGo generates
assembly code for 64 bit Linux operating systems and the Go compiler allows
to mix assembly and Go code, the operating system's built-in functions can
be used via syscalls in order to provide the functionality described above.
+ In order to be able to perform I/O operations and memory management, a
library called libgogo is implemented which wraps Linux syscalls and
provides an easy to use interface to the GoGC compiler. As GoGC generates
assembly code for 64 bit Linux operating systems and the Go compiler allows
to mix assembly and Go code, the operating system's built-in functions can
be used via syscalls in order to provide the functionality described above.

\section{I/O syscalls}
Besides read and write operations to files (and the console),
exiting the program as well as opening and closing files requires the use
of syscalls. On Linux 64 bit operating systems with Intel architecture,
these syscalls can be invoked by the assembly mnemonic \texttt{SYSCALL}
where the register \texttt{RAX} contains the syscall number defining the
syscall, and the registers \texttt{RDI}, \texttt{RSI} and \texttt{RDX}
contain the first, second and third parameter respectively\cite{var08}.\\
@@ -545,7 +545,7 @@

\section{Memory manager}
Libgogo provides a very simple memory manager using a bump pointer
which can allocate, but not free memory. By using the
\texttt{sys\_brk}\cite{var97} function, the memory manager expands the data
segment of the running program in steps of 10 KB if necessary in order to
deal with subsequent allocations.\\
- As the Go compiler used for boot strapping uses a custom memory
manager in its run time environment, the libgogo memory manager and the
GoGo compiler take measures to avoid conflicts with the former. First and
foremost, all implicit and explicit memory allocations in the GoGo compiler
rely on the libgogo memory manager in order to keep the amount of memory
allocated by the Go run time constant. Additionally, the memory manager
does not allocate any memory in the original data segment to not overwrite
any string constants or other information stored there by the Go run time.
This is achieved by directly expanding the data segment during the
initialization of the libgogo memory manager which also allows to store the
first address allocated, thus being able to distinguish between memory
allocated by the libgogo memory manager and memory allocated by the Go run
time.
+ As the Go compiler used for boot strapping uses a custom memory
manager in its run time environment, the libgogo memory manager and the
GoGC compiler take measures to avoid conflicts with the former. First and
foremost, all implicit and explicit memory allocations in the GoGC compiler
rely on the libgogo memory manager in order to keep the amount of memory
allocated by the Go run time constant. Additionally, the memory manager
does not allocate any memory in the original data segment to not overwrite
any string constants or other information stored there by the Go run time.
This is achieved by directly expanding the data segment during the
initialization of the libgogo memory manager which also allows to store the
first address allocated, thus being able to distinguish between memory
allocated by the libgogo memory manager and memory allocated by the Go run
time.

\section{String memory management}
Based on the memory manager described above, functions to copy and
append strings are implemented in libgogo. As strings in Go are read-only
once they are created (or appended), subsequent appending operands require
the string to be entirely copied to a new memory location first. In order
to avoid this in most cases, the functions handling string appending in
libgogo allocate more memory than needed for the current operation in order
to be able to reuse this memory in subsequent append operations if the
string appended is short enough to fit in the memory already allocated.\\
@@ -558,7 +558,7 @@

\chapter{Building / Self-compilation}
\label{chpt:building}
- This section deals with the building process of GoGo and how
self-compilation
+ This section deals with the building process of GoGC and how
self-compilation
is achieved.

\section{Go language tools}
@@ -566,7 +566,7 @@
the Go language tools (which are actually Plan9 tools) are organized.

Each CPU architecture gets a number that is prefixed before a tool.
In
- GoGo's case this would be \texttt{6}, indicating an AMD64
architecture.
+ GoGC's case this would be \texttt{6}, indicating an AMD64
architecture.
The tool suite is then organized into various compilers/linkers:
\begin{itemize}
\item \texttt{6a} - Assembler for AMD64 architecture (creating
\texttt{*.6}
@@ -582,7 +582,7 @@
To create the initial compiler that is then used for subsequent
compilations, the Go language tools are used. Go uses
\texttt{Makefile}s
for defining the appropriate compilation procedure. Basically, three
steps
- are needed to create the GoGo binary:
+ are needed to create the GoGC binary:
\begin{enumerate}
\item Library compilation - The \texttt{6g} and \texttt{6a} tools
are
used to create a single object file containing the library code.
@@ -590,13 +590,13 @@
\item Link - Link the compiler object file and the library object
file
into an ELF binary using \texttt{6l}.
\end{enumerate}
- At the end of this procedure, an architecture-dependent (AMD64) GoGo
+ At the end of this procedure, an architecture-dependent (AMD64) GoGC
compiler has been created.

\section{Self-compilation}
\label{sec:sc}
After creating a first bootstrapped version of the compiler, this
one may
- be used for self-compilation. GoGo is written in the same language it
+ be used for self-compilation. GoGC is written in the same language it
is able to compile to assembly level. Therefore, no further additions
or changes have to be made to the source code.
The procedure to achieve self-compilation until assembly level is
shown
@@ -609,10 +609,10 @@
\caption{Self-compilation approach}
\end{figure}

- Although GoGo is capable of doing some very basic linking (i.e. copy
+ Although GoGC is capable of doing some very basic linking (i.e. copy
functions from different files and adjust the symbol table), it is
not
possible to use separate compilation during self-compilation. Altough
- function linking would work, GoGo is not able to handle global
variables
+ function linking would work, GoGC is not able to handle global
variables
that are spread over multiple packages correctly in the linking
process.
Thus, the approach is straight-forward and can be summarized by the
following:
\begin{enumerate}
@@ -634,7 +634,7 @@
\end{enumerate}

In order to perform a fixpoint-test, this procedure is used to
generate
- another instance using the previously compiled GoGo compiler. The
+ another instance using the previously compiled GoGC compiler. The
fixpoint-test passes and there are no differences in subsequent
compilations.

\chapter{Testing}
=======================================
--- /docs/pres/gogo.tex Sat Jun 26 05:42:33 2010
+++ /docs/pres/gogo.tex Tue Aug 17 09:58:38 2010
@@ -15,7 +15,7 @@

\begin{document}

-\title{\hspace{1.8cm}\textbf{GoGo}
\includegraphics[scale=0.3]{files/inspector.jpg}}
+\title{\hspace{1.8cm}\textbf{GoGC}
\includegraphics[scale=0.3]{files/inspector.jpg}}
\subtitle{A Go compiler written in Go \tiny{(... and assembly)}}
\author{Michael~Lippautz \and Andreas~Unterweger}
\date{June 24, 2010}
@@ -38,7 +38,7 @@
\end{center}
}

-\frame{\frametitle{What is GoGo?}
+\frame{\frametitle{What is GoGC?}
\begin{itemize}
\item A self-compiling Go compiler
\item Input language: A subset of the Go language
\footnote{golang.org}\\
@@ -55,7 +55,7 @@
\end{itemize}
}

-\frame[containsverbatim]{\frametitle{What is so special about GoGo? (1/2)}
+\frame[containsverbatim]{\frametitle{What is so special about GoGC? (1/2)}
\begin{itemize}
\item Advanced \textbf{string} management\\
\begin{itemize}
@@ -74,7 +74,7 @@
}

\begin{frame}[containsverbatim]
- \frametitle{What is so special about GoGo? (2/2)}
+ \frametitle{What is so special about GoGC? (2/2)}
\begin{itemize}
\item \textbf{Lazy evaluation} over multiple expression levels\\
\begin{itemize}
=======================================
--- /src/Makefile Sun Jun 20 08:36:58 2010
+++ /src/Makefile Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-# Copyright 2009 The GoGo Authors. All rights reserved.
+# Copyright 2009 The GoGC Authors. All rights reserved.
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file.

=======================================
--- /src/asm_out.go Sun Aug 15 16:12:55 2010
+++ /src/asm_out.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

@@ -42,7 +42,7 @@
Header = `
//\n
// --------------------\n
-// GoGo compiler output\n
+// GoGC compiler output\n
// --------------------\n
//\n
`;
=======================================
--- /src/codegen.go Sun Jun 20 12:27:03 2010
+++ /src/codegen.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-arith.go Tue Jun 15 13:21:07 2010
+++ /src/gen-arith.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-assign.go Sat Jun 19 11:34:23 2010
+++ /src/gen-assign.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-cond.go Mon Jun 21 09:48:13 2010
+++ /src/gen-cond.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-const.go Mon Jun 21 09:48:13 2010
+++ /src/gen-const.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-expr.go Mon Jun 21 10:34:32 2010
+++ /src/gen-expr.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-fcn.go Mon Jun 21 09:48:13 2010
+++ /src/gen-fcn.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-for.go Mon Jun 21 07:35:08 2010
+++ /src/gen-for.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gen-if.go Mon Jun 21 09:33:08 2010
+++ /src/gen-if.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/globals.go Mon Jun 21 06:28:50 2010
+++ /src/globals.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/gogo.go Mon Jun 21 02:00:21 2010
+++ /src/gogo.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

@@ -105,7 +105,7 @@

if strIndicator == 0 {
libgogo.PrintString("Usage: gogo option file1.go
[file2.go ...]\n\n");
- libgogo.PrintString("GoGo - A go compiler\n\n");
+ libgogo.PrintString("GoGC - A go compiler\n\n");
libgogo.PrintString("Options:\n");
libgogo.PrintString("-h, --help show this help message and
exit\n");
libgogo.PrintString("-p, parser mode\n");
=======================================
--- /src/libgogo/Makefile Fri Jun 11 12:42:43 2010
+++ /src/libgogo/Makefile Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-# Copyright 2010 The GoGo Authors. All rights reserved.
+# Copyright 2010 The GoGC Authors. All rights reserved.
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file.

=======================================
--- /src/libgogo/convert.go Mon Jun 21 15:55:57 2010
+++ /src/libgogo/convert.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo conversion functions
+// GoGC conversion functions
//

package libgogo
=======================================
--- /src/libgogo/convert_amd64.s Mon Jun 21 15:55:57 2010
+++ /src/libgogo/convert_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo conversion functions (ASM)
+// GoGC conversion functions (ASM)
//

TEXT ·DerefUint64Ptr(SB),$0-16
=======================================
--- /src/libgogo/io.go Tue May 18 10:33:00 2010
+++ /src/libgogo/io.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo I/O functions
+// GoGC I/O functions
//

package libgogo
=======================================
--- /src/libgogo/io_amd64.s Mon Jun 21 00:30:23 2010
+++ /src/libgogo/io_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo I/O functions (ASM)
+// GoGC I/O functions (ASM)
//

TEXT ·Write(SB),$0-40 //Write: 3 parameters (4), 1 return value
=======================================
--- /src/libgogo/item.go Sat Jun 19 11:34:23 2010
+++ /src/libgogo/item.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/libgogo/item_amd64.s Sat Jun 19 11:34:23 2010
+++ /src/libgogo/item_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/libgogo/libgogo.go Sun Jun 20 11:01:59 2010
+++ /src/libgogo/libgogo.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo library functions
+// GoGC library functions
//

package libgogo
@@ -27,7 +27,7 @@

fd = FileOpen("/proc/self/cmdline", 0); //Open file that contains the
program's arguments
if fd == 0 { //Error check (the system may have been compiled with
proc fs disabled)
- ExitError("Error opening /proc/self/cmdline. Currently GoGo is
only supported on systems with /proc enabled.", 1);
+ ExitError("Error opening /proc/self/cmdline. Currently GoGC is
only supported on systems with /proc enabled.", 1);
}

for singleChar = GetChar(fd);(singleChar != 0) || (lastChar != 0);
singleChar = GetChar(fd) {
=======================================
--- /src/libgogo/libgogo_amd64.s Sat Jun 19 01:30:33 2010
+++ /src/libgogo/libgogo_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo Library functions (ASM)
+// GoGC Library functions (ASM)
//

TEXT ·CopyMem(SB),$0-24 //CopyMem: 3 parameters, no return value
=======================================
--- /src/libgogo/list.go Sat Jun 12 09:49:50 2010
+++ /src/libgogo/list.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo list functions
+// GoGC list functions
//

package libgogo
=======================================
--- /src/libgogo/memmgr.go Sat May 22 07:44:17 2010
+++ /src/libgogo/memmgr.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo memory manager functions
+// GoGC memory manager functions
//

package libgogo
=======================================
--- /src/libgogo/memmgr_amd64.s Sat Jun 19 01:30:33 2010
+++ /src/libgogo/memmgr_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo Memory manager functions (ASM)
+// GoGC Memory manager functions (ASM)
//

TEXT ·Brk(SB),$0-16 //Brk: 1 parameter, 1 return value
=======================================
--- /src/libgogo/stack.go Thu May 13 11:33:55 2010
+++ /src/libgogo/stack.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo stack functions
+// GoGC stack functions
//

package libgogo
=======================================
--- /src/libgogo/string.go Sat Jun 19 12:06:20 2010
+++ /src/libgogo/string.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo string functions
+// GoGC string functions
//

package libgogo
=======================================
--- /src/libgogo/string_amd64.s Mon Jun 21 00:30:23 2010
+++ /src/libgogo/string_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo string functions (ASM)
+// GoGC string functions (ASM)
//

TEXT ·StringLength(SB),$0-24 //StringLength: 1 parameter (2), 1 return
value
=======================================
--- /src/libgogo/strlist.go Sat Jun 12 09:41:10 2010
+++ /src/libgogo/strlist.go Tue Aug 17 09:58:38 2010
@@ -1,9 +1,9 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

//
-// GoGo list functions
+// GoGC list functions
//

package libgogo
=======================================
--- /src/libgogo/symbol.go Wed Jun 16 15:23:00 2010
+++ /src/libgogo/symbol.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/libgogo/symbol_amd64.s Mon Jun 21 00:30:23 2010
+++ /src/libgogo/symbol_amd64.s Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/libgogo/test/libgogotest.go Sat Jun 12 09:41:10 2010
+++ /src/libgogo/test/libgogotest.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/linker.go Tue Jun 22 04:19:10 2010
+++ /src/linker.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/parse-utils.go Sun Jun 20 07:40:54 2010
+++ /src/parse-utils.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/parser.go Mon Jun 21 01:53:07 2010
+++ /src/parser.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/sc Tue Jun 22 11:11:47 2010
+++ /src/sc Tue Aug 17 09:58:38 2010
@@ -1,6 +1,6 @@
#!/bin/sh

-# Copyright 2009 The GoGo Authors. All rights reserved.
+# Copyright 2009 The GoGC Authors. All rights reserved.
# Use of this source code is governed by the MIT
# license that can be found in the LICENSE file.

=======================================
--- /src/scanner.go Mon Jun 21 02:37:45 2010
+++ /src/scanner.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/symtable.go Mon Jun 21 15:55:57 2010
+++ /src/symtable.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/token.go Mon Jun 21 13:00:46 2010
+++ /src/token.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /src/utils.go Mon Jun 21 15:55:57 2010
+++ /src/utils.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /testing/results/_gogo_.sog Sun Jun 20 12:27:03 2010
+++ /testing/results/_gogo_.sog Tue Aug 17 09:58:38 2010
@@ -1,6 +1,6 @@
//
// --------------------
-// GoGo compiler output
+// GoGC compiler output
// --------------------
//

=======================================
--- /testing/tests/2010-03-21_fail.go Sun Mar 21 13:38:26 2010
+++ /testing/tests/2010-03-21_fail.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /testing/tests/2010-03-21_gogo_fail.go Mon Apr 12 08:49:58 2010
+++ /testing/tests/2010-03-21_gogo_fail.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /testing/tests/2010-03-21_large_number.go Sun Mar 21 13:38:26 2010
+++ /testing/tests/2010-03-21_large_number.go Tue Aug 17 09:58:38 2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
--- /testing/tests/2010-03-21_scanner_fail_semicolon.go Mon Apr 12 08:49:58
2010
+++ /testing/tests/2010-03-21_scanner_fail_semicolon.go Tue Aug 17 09:58:38
2010
@@ -1,4 +1,4 @@
-// Copyright 2010 The GoGo Authors. All rights reserved.
+// Copyright 2010 The GoGC Authors. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

=======================================
***Additional files exist in this changeset.***

==============================================================================
Revision: 9750f6ff3e
Author: Scott Lawrence <byt...@gmail.com>
Date: Tue Aug 17 14:33:41 2010
Log: TODO list (of ideas)
http://code.google.com/p/gogc/source/detail?r=9750f6ff3e

Added:
/TODO

=======================================
--- /dev/null
+++ /TODO Tue Aug 17 14:33:41 2010
@@ -0,0 +1,1 @@
+Compile-time asserts