Changes in / [077810d:9d944b2]


Ignore:
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/common.tex

    r077810d r9d944b2  
    4242\newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
    4343\newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
    44 \newcommand{\CCtwenty}{\rm C\kern-.1em\hbox{+\kern-.25em+}20} % C++20 symbolic name
    4544\newcommand{\Celeven}{C11\xspace}               % C11 symbolic name
    4645\newcommand{\Csharp}{C\raisebox{0.4ex}{\#}\xspace}      % C# symbolic name
    … …  
    201200\newcommand{\opt}{$_{opt}$\ }
    202201
    203 \usepackage{varioref}                 % extended references
    204202% adjust varioref package with default "section" and "page" titles, and optional title with faraway page numbers
    205203% \VRef{label} => Section 2.7, \VPageref{label} => page 17
    … …  
    253251                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
    254252                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert,
    255                 _Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t},
     253                _Thread_local,throw,throwResume,trait,try,typeof,__typeof,__typeof__,zero_t},
    256254}%
    257255

  • doc/generic_types/generic_types.tex

    r077810d r9d944b2  
    148148\label{sec:poly-fns}
    149149
    150 \CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name):
     150\CFA{}'s polymorphism was originally formalized by \citet{Ditchfield92}, and first implemented by \citet{Bilson03}. The signature feature of \CFA{} is parametric-polymorphic functions; such functions are written using a @forall@ clause (which gives the language its name): 
    151151\begin{lstlisting}
    152152forall(otype T)
    … …  
    174174forall(otype S | { S ?+?(S, S); })
    175175S twice(S x) { return x + x; }  // (2)
    176 \end{lstlisting}
    177 This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@.
     176\end{lstlisting} 
     177This version of @twice@ works for any type @S@ that has an addition operator defined for it, and it could have been used to satisfy the type assertion on @four_times@. 
    178178The translator accomplishes this polymorphism by creating a wrapper function calling @twice // (2)@ with @S@ bound to @double@, then providing this wrapper function to @four_times@\footnote{\lstinline@twice // (2)@ could also have had a type parameter named \lstinline@T@; \CFA{} specifies renaming of the type parameters, which would avoid the name conflict with the type variable \lstinline@T@ of \lstinline@four_times@.}.
    179179
    … …  
    196196forall(otype M | has_magnitude(M))
    197197M max_magnitude( M a, M b ) {
    198     return abs(a) < abs(b) ? b : a;
     198    return abs(a) < abs(b) ? b : a; 
    199199}
    200200\end{lstlisting}
    … …  
    213213Given the information provided for an @otype@, variables of polymorphic type can be treated as if they were a complete struct type -- they can be stack-allocated using the @alloca@ compiler builtin, default or copy-initialized, assigned, and deleted. As an example, the @abs@ function above produces generated code something like the following (simplified for clarity and brevity):
    214214\begin{lstlisting}
    215 void abs( size_t _sizeof_M, size_t _alignof_M,
    216                 void (*_ctor_M)(void*), void (*_copy_M)(void*, void*),
    217                 void (*_assign_M)(void*, void*), void (*_dtor_M)(void*),
    218                 bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*),
    219         void (*_ctor_M_zero)(void*, int),
     215void abs( size_t _sizeof_M, size_t _alignof_M, 
     216                void (*_ctor_M)(void*), void (*_copy_M)(void*, void*), 
     217                void (*_assign_M)(void*, void*), void (*_dtor_M)(void*), 
     218                bool (*_lt_M)(void*, void*), void (*_neg_M)(void*, void*), 
     219        void (*_ctor_M_zero)(void*, int), 
    220220                void* m, void* _rtn ) {  // polymorphic parameter and return passed as void*
    221221        // M zero = { 0 };
    … …  
    223223        _ctor_M_zero(zero, 0);  // initialize using zero_t constructor
    224224        // return m < zero ? -m : m;
    225         void *_tmp = alloca(_sizeof_M);
     225        void *_tmp = alloca(_sizeof_M)
    226226        _copy_M( _rtn,  // copy-initialize return value
    227227                _lt_M( m, zero ) ?  // check condition
    … …  
    323323In some cases the offset arrays cannot be statically generated. For instance, modularity is generally provided in C by including an opaque forward-declaration of a struct and associated accessor and mutator routines in a header file, with the actual implementations in a separately-compiled \texttt{.c} file. \CFA{} supports this pattern for generic types, and in this instance the caller does not know the actual layout or size of the dynamic generic type, and only holds it by pointer. The \CFA{} translator automatically generates \emph{layout functions} for cases where the size, alignment, and offset array of a generic struct cannot be passed in to a function from that function's caller. These layout functions take as arguments pointers to size and alignment variables and a caller-allocated array of member offsets, as well as the size and alignment of all @sized@ parameters to the generic struct (un-@sized@ parameters are forbidden from the language from being used in a context that affects layout). Results of these layout functions are cached so that they are only computed once per type per function.%, as in the example below for @pair@.
    324324% \begin{lstlisting}
    325 % static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair,
     325% static inline void _layoutof_pair(size_t* _szeof_pair, size_t* _alignof_pair, size_t* _offsetof_pair, 
    326326%               size_t _szeof_R, size_t _alignof_R, size_t _szeof_S, size_t _alignof_S) {
    327327%     *_szeof_pair = 0; // default values
    … …  
    332332%     *_szeof_pair += _szeof_R;
    333333%     if ( *_alignof_pair < _alignof_R ) *_alignof_pair = _alignof_R;
    334 
     334       
    335335%       // padding, offset, size, and alignment of second field
    336336%     if ( *_szeof_pair & (_alignof_S - 1) )
    … …  
    754754f(x.field_0, (_tuple2){ x.field_1, 'z' });
    755755\end{lstlisting}
    756 Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
     756Note that due to flattening, @x@ used in the argument position is converted into the list of its fields. In the call to @f@, a the second and third argument components are structured into a tuple argument. Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
    757757
    758758Expressions that may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion. Each unique expression is assigned an identifier and is guaranteed to be executed exactly once:
    … …  
    774774);
    775775\end{lstlisting}
    776 Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity.
     776Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order. The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true. Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression. Tuple member expressions also take advantage of unique expressions in the case of possible impurity.
    777777
    778778Currently, the \CFA{} translator has a very broad, imprecise definition of impurity, where any function call is assumed to be impure. This notion could be made more precise for certain intrinsic, auto-generated, and builtin functions, and could analyze function bodies when they are available to recursively detect impurity, to eliminate some unique expressions.

  • doc/rob_thesis/ctordtor.tex

    r077810d r9d944b2  
    135135%   at the global scope (which is likely the most common case)
    136136% * [9]
     137
     138% Move semantics
     139% * <ongoing discussion about this. this will be filled in
     140%    once we come to a consensus>
    137141
    138142% Changes to polymorphic type classes

  • doc/rob_thesis/tuples.tex

    r077810d r9d944b2  
    615615\end{cfacode}
    616616Note that due to flattening, @x@ used in the argument position is converted into the list of its fields.
    617 In the call to @f@, the second and third argument components are structured into a tuple argument.
     617In the call to @f@, a the second and third argument components are structured into a tuple argument.
    618618
    619619Expressions which may contain side effects are made into \emph{unique expressions} before being expanded by the flattening conversion.
    … …  
    643643\end{cfacode}
    644644Since argument evaluation order is not specified by the C programming language, this scheme is built to work regardless of evaluation order.
    645 The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is set to true.
     645The first time a unique expression is executed, the actual expression is evaluated and the accompanying boolean is true to true.
    646646Every subsequent evaluation of the unique expression then results in an access to the stored result of the actual expression.
    647647
    … …  
    12991299Thunks 0 through 3 provide wrappers for the @otype@ parameters for @const char *@, while @_thunk4@ translates a call to @print([int, const char *])@ into a call to @print_variadic(int, [const char *])@.
    13001300This all builds to a call to @print_variadic@, with the appropriate copy construction of the tuple argument.
    1301 
    1302 \section{Future Work}

  • src/CodeGen/CodeGenerator.cc

    r077810d r9d944b2  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:38:01 2017
    13 // Update Count     : 482
     12// Last Modified On : Fri Mar 17 09:06:01 2017
     13// Update Count     : 481
    1414//
    1515
    … …  
    674674
    675675        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
    676                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    677                 output << "(" << genType( compLitExpr->get_result(), "", pretty ) << ")";
     676                assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
     677                output << "(" << genType( compLitExpr->get_type(), "", pretty ) << ")";
    678678                compLitExpr->get_initializer()->accept( *this );
    679679        }

  • src/InitTweak/FixInit.cc

    r077810d r9d944b2  
    738738                                                stmtsToAddAfter.push_back( ifStmt );
    739739
    740                                                 Statement * dtor = ctorInit->get_dtor();
    741                                                 objDecl->set_init( NULL );
    742                                                 ctorInit->set_ctor( NULL );
    743                                                 ctorInit->set_dtor( nullptr );
    744                                                 if ( dtor ) {
     740                                                if ( ctorInit->get_dtor() ) {
    745741                                                        // if the object has a non-trivial destructor, have to
    746742                                                        // hoist it and the object into the global space and
    747743                                                        // call the destructor function with atexit.
    748744
    749                                                         Statement * dtorStmt = dtor->clone();
     745                                                        Statement * dtorStmt = ctorInit->get_dtor()->clone();
    750746
    751747                                                        // void __objName_dtor_atexitN(...) {...}
    … …  
    776772                                                        objDecl->set_mangleName( SymTab::Mangler::mangle( objDecl ) );
    777773
     774                                                        objDecl->set_init( NULL );
     775                                                        ctorInit->set_ctor( NULL );
     776                                                        delete ctorInit;
     777
    778778                                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
    779779                                                        // create a new object which is never used
    780780                                                        static UniqueName dummyNamer( "_dummy" );
    781781                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
    782                                                         delete ctorInit;
    783782                                                        return dummy;
    784783                                                }

  • src/InitTweak/GenInit.cc

    r077810d r9d944b2  
    294294                handleDWT( objDecl );
    295295                // hands off if @=, extern, builtin, etc.
    296                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
    297                 if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
     296                // if global but initializer is not constexpr, always try to construct, since this is not legal C
     297                if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
    298298                        // constructed objects cannot be designated
    299                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
     299                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl );
    300300                        // constructed objects should not have initializers nested too deeply
    301301                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );

  • src/Parser/ExpressionNode.cc

    r077810d r9d944b2  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 17:02:46 2017
    13 // Update Count     : 515
     12// Last Modified On : Sat Mar  4 06:58:47 2017
     13// Update Count     : 509
    1414//
    1515
    … …  
    356356        // these types do not have associated type information
    357357        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
    358                 if ( newDeclStructDecl->has_body() ) {
    359                         return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
    360                 } else {
    361                         return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    362                 } // if
     358                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    363359        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
    364                 if ( newDeclUnionDecl->has_body() ) {
    365                         return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
    366                 } else {
    367                         return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    368                 } // if
     360                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    369361        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
    370                 if ( newDeclEnumDecl->has_body() ) {
    371                         return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
    372                 } else {
    373                         return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    374                 } // if
     362                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
    375363        } else {
    376364                assert( false );

  • src/Parser/parser.yy

    r077810d r9d944b2  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 15:42:32 2017
    13 // Update Count     : 2318
     12// Last Modified On : Fri Mar 17 15:42:22 2017
     13// Update Count     : 2317
    1414//
    1515
    … …  
    423423        | postfix_expression DECR
    424424                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    425         | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
     425        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    426426                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
    427427        | postfix_expression '{' argument_expression_list '}' // CFA

  • src/SymTab/Indexer.cc

    r077810d r9d944b2  
    1010// Created On       : Sun May 17 21:37:33 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:38:47 2017
    13 // Update Count     : 19
     12// Last Modified On : Tue Mar 14 08:07:34 2017
     13// Update Count     : 17
    1414//
    1515
    … …  
    483483        void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
    484484                acceptNewScope( compLitExpr->get_result(), *this );
     485                maybeAccept( compLitExpr->get_type(), *this );
    485486                maybeAccept( compLitExpr->get_initializer(), *this );
    486487        }

  • src/SymTab/Validate.cc

    r077810d r9d944b2  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:50:13 2017
    13 // Update Count     : 357
     12// Last Modified On : Thu Mar 16 16:39:15 2017
     13// Update Count     : 353
    1414//
    1515
    … …  
    222222                CompoundLiteral compoundliteral;
    223223
     224                EliminateTypedef::eliminateTypedef( translationUnit );
    224225                HoistStruct::hoistStruct( translationUnit );
    225                 EliminateTypedef::eliminateTypedef( translationUnit );
    226226                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
    227227                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
    … …  
    824824                static UniqueName indexName( "_compLit" );
    825825
    826                 ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
    827                 compLitExpr->set_result( 0 );
     826                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
     827                compLitExpr->set_type( 0 );
    828828                compLitExpr->set_initializer( 0 );
    829829                delete compLitExpr;

  • src/SynTree/Expression.cc

    r077810d r9d944b2  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:41:13 2017
    13 // Update Count     : 52
     12// Last Modified On : Fri Mar 17 09:42:04 2017
     13// Update Count     : 51
    1414//
    1515
    … …  
    571571
    572572
    573 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
     573CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
    574574        assert( type && initializer );
    575         set_result( type );
    576 }
    577 
    578 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
     575        set_result( type->clone() );
     576}
     577
     578CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
    579579
    580580CompoundLiteralExpr::~CompoundLiteralExpr() {
    581581        delete initializer;
     582        delete type;
    582583}
    583584
    … …  
    585586        os << "Compound Literal Expression: " << std::endl;
    586587        os << std::string( indent+2, ' ' );
    587         get_result()->print( os, indent + 2 );
     588        type->print( os, indent + 2 );
    588589        os << std::string( indent+2, ' ' );
    589590        initializer->print( os, indent + 2 );

  • src/SynTree/Expression.h

    r077810d r9d944b2  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:44:00 2017
    13 // Update Count     : 41
     12// Last Modified On : Sat Jan 14 14:37:54 2017
     13// Update Count     : 37
    1414//
    1515
    … …  
    3535
    3636        Type *& get_result() { return result; }
    37         const Type * get_result() const { return result; }
    3837        void set_result( Type * newValue ) { result = newValue; }
    3938        bool has_result() const { return result != nullptr; }
    … …  
    587586        virtual ~CompoundLiteralExpr();
    588587
     588        Type * get_type() const { return type; }
     589        void set_type( Type * t ) { type = t; }
     590
    589591        Initializer * get_initializer() const { return initializer; }
    590592        void set_initializer( Initializer * i ) { initializer = i; }
    … …  
    595597        virtual void print( std::ostream & os, int indent = 0 ) const;
    596598  private:
     599        Type * type;
    597600        Initializer * initializer;
    598601};

  • src/SynTree/Mutator.cc

    r077810d r9d944b2  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:45:19 2017
    13 // Update Count     : 22
     12// Last Modified On : Thu Feb 16 15:02:23 2017
     13// Update Count     : 21
    1414//
    1515
    … …  
    369369        compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) );
    370370        compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
     371        compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
    371372        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    372373        return compLitExpr;

  • src/SynTree/Visitor.cc

    r077810d r9d944b2  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 30 16:45:25 2017
    13 // Update Count     : 24
     12// Last Modified On : Thu Feb 16 15:01:25 2017
     13// Update Count     : 23
    1414//
    1515
    … …  
    292292void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
    293293        maybeAccept( compLitExpr->get_result(), *this );
     294        maybeAccept( compLitExpr->get_type(), *this );
    294295        maybeAccept( compLitExpr->get_initializer(), *this );
    295296}

  • src/libcfa/iostream.c

    r077810d r9d944b2  
    154154ostype * ?|?( ostype * os, const char * cp ) {
    155155        enum { Open = 1, Close, OpenClose };
    156         static const unsigned char mask[256] @= {
     156        static const unsigned char mask[256] = {
    157157                // opening delimiters, no space after
    158158                ['('] : Open, ['['] : Open, ['{'] : Open,
Note: See TracChangeset for help on using the changeset viewer.