{\rtf1\ansi
{\fonttbl
{\f0\fswiss Helvetica;}
{\f1\fmodern Courier;}
{\f2\froman Times;}
{\f3\froman Symbol;}
}
{\info{\comment Translated from SGML to RTF w/ Linuxdoc-SGML}}

\page{\pard\plain\keepn\f0\fs36\b\tx576{1 About CVS}}
{}#{\footnote TOC_0}

${\footnote About_CVS}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote About CVS}


{\pard\sb200\plain\f0\fs24\b\tx576{1.1 Where to find CVS ?}}
{}#{\footnote TOC_1}
{}K{\footnote Where to find CVS ?}

\par\pard\plain
\li500{}
\sb200\fi0
The official web site for CVS is www.cyclic.com.
\par\pard\plain
\li500{}
\sb200\fi0
Cyclic Software provides source code, informations and support for CVS.
\par\pard\plain
\li500{}
\sb200\fi0
Before reading this document, you should be familiar with CVS.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.2 What is CvsGui ?}}
{}#{\footnote TOC_2}
{}K{\footnote What is CvsGui ?}

\par\pard\plain
\li500{}
\sb200\fi0
{\b CvsGui} is a set of little applications with a {\b user interface} for several platforms 
(right now only Mac and Windows 32). It is developped and used mostly in 
Strata Inc. by several developers.
\par\pard\plain
\li500{}
\sb200\fi0
The user interface is {\b not 
designed to replace} the command lines of cvs, but is provided in order to help people 
to {\b get started with cvs} and to take {\b advantages} of platforms capabilities 
(move to trash, multi-files picker, improved interface...).
\par\pard\plain
\li500{}
\sb200\fi0
While developping GuiCvs, we concentrate on {\b speed and reliability}.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.3 Why Cvs and CvsGui ?}}
{}#{\footnote TOC_3}
{}K{\footnote Why Cvs and CvsGui ?}

\par\pard\plain
\li500{}
\sb200\fi0
The main reason is because we had a very bad time by using a commercial product named 
...$ :-\<.
\par\pard\plain
\li500{}
\sb200\fi0
The second reason is {\b due to cvs itself} : cvs is incredibly powerfull, 
fast, well documented and has a great support with 
Cyclic Software.
\par\pard\plain
\li500{}
\sb200\fi0
MacCvs was the first version of CvsGui : we finished the port of cvs on 
Macintosh by {\b fixing bugs} and {\b adding features}.
\par\pard\plain
\li500{}
\sb200\fi0
Then we did the WinCvs port so the Windows developper can have the same 
features than the Mac developpers.
\par\pard\plain
\li500{}
\sb200\fi0
Finnally why not in the future a kdecvs, qtcvs, wtcvs, gtkcvs ? You will 
find a {\uldb hacking}{\v hacking} section explaining the common architecture of CvsGui and 
why it's so easy to make new ports by using the CvsGui architecture.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.4 Which are the features inside cvs that are not available in CvsGui ?}}
{}#{\footnote TOC_4}
{}K{\footnote Which are the features inside cvs that are not available in CvsGui ?}

\par\pard\plain
\li500{}
\sb200\fi0
None. That's because CvsGui uses the cvs code and inherits of all 
the features of cvs.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.5 Which are the features inside CvsGui that are not available in cvs ?}}
{}#{\footnote TOC_5}
{}K{\footnote Which are the features inside CvsGui that are not available in cvs ?}

\par\pard\plain
\li500{}
\sb200\fi0
CvsGui is designed to add on the top of cvs some cool stuff that people 
wants. You'll find an ISO8559 encoding support, MacBinary support, 
extras features and more. But we still try to keep the cvs feeling.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.6 What is the relationship with the "official" maintainers of cvs ?}}
{}#{\footnote TOC_6}
{}K{\footnote What is the relationship with the "official" maintainers of cvs ?}

\par\pard\plain
\li500{}
\sb200\fi0
We try to keep in touch with them and look for the next version they'll 
provide. We think we'll be able before the announcement of the next version 
of cvs to provide some patches useful for all the platforms.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.7 What are the differences with jcvs, MacCvsClient, MacCvsPro ?}}
{}#{\footnote TOC_7}
{}K{\footnote What are the differences with jcvs, MacCvsClient, MacCvsPro ?}

\par\pard\plain
\li500{}
\sb200\fi0
{\b jcvs} is a cvs client implemented in Java which has his own format. jcvs is not 
compatible with MacCVS.
\par\pard\plain
\li500{}
\sb200\fi0
{\b MacCvsClient} and {\b MacCvsPro} are two cvs client implemented in C++ using PowerPlant 
with a very nice user interface. Like jcvs, 
MacCvsClient and MacCvsPro have their own format and are not compatibles with MacCvs.
\par\pard\plain
\li500{}
\sb200\fi0
MacCvs uses directly the cvs code (C code) : so it inherits all the capabilities 
of cvs. jcvs, MacCvsClient and MacCvsPro use a private code so you can't expect some features 
to be implemented in thses clients, unless the author implements it 
(the Mac resources support, the patch support, the compression support, the 
kerberos support and so on). But you may find in MacCVS some ideas stolen 
from all of these excellents programs.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{1.8 What about Rhapsody ?}}
{}#{\footnote TOC_8}
{}K{\footnote What about Rhapsody ?}

\par\pard\plain
\li500{}
\sb200\fi0
Hey, good news : Apple works on a version of cvs for Rhapsody. Should be nice 
to have a MacCVS for it, isn't it ;-> ?
\par\pard\plain
\li500{}
\sb200\fi0
Note: We are using currently MacCVS on Rhapsody without any kind of problem using 
the Blue Box.
\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{2 The MacCVS Client}}
{}#{\footnote TOC_9}

${\footnote The_MacCVS_Client}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote The MacCVS Client}


{\pard\sb200\plain\f0\fs24\b\tx576{2.1 Introduction}}
{}#{\footnote TOC_10}
{}K{\footnote Introduction}

\par\pard\plain
\li500{}
\sb200\fi0
The first port on Macintosh was made by Mike Ladwig using CodeWarrior 9, GUSI 1.7.2 and cvs 1.84. It allowed 
to use MacCVS as a {\b console} program or as a {\b MacPerl} command.
\par\pard\plain
\li500{}
\sb200\fi0
A second port was made by Matthias Neeracher. He implemented cvs as a {\b MPW tool} and used 
the cvs 1.9 distribution, dmake and CodeWarrior 9. This version works nicely but was never 
included into the official release of cvs.
\par\pard\plain
\li500{}
\sb200\fi0
Both use the excellent Matthias Neeracher's GUSI Library 
(for Grand Unified Sockets Library) which allows to port easily Unix code on Macintosh.
\par\pard\plain
\li500{}
\sb200\fi0
Despite of this ports, the cvs implementation for Macintosh is still 
experimental and only the {\b client} side is available.
\par\pard\plain
\li500{}
\sb200\fi0
This current port uses {\b CodeWarrior Pro 3}, the {\b MSL} library, {\b cvs 1.10}, 
{\b GUSI 1.8.4}, {\b Waste 1.3}, {\b TCL 8.1} 
and optionnaly the KClient library 
(Kerberos authentication, a contribution of Miro Jurisic)
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{2.2 What is inside}}
{}#{\footnote TOC_11}
{}K{\footnote What is inside}

\par\pard\plain
\li500{}
\sb200\fi0
This is my second tentative to port CVS for Macintosh.
\par\pard\plain
\li500{}
\sb200\fi0
The first time I used the port of Mike Ladwig and added a little UI 
to remember the CVSROOT and provide menu access.
\par\pard\plain
\li500{}
\sb200\fi0
Now using the Matthias Neeracher port, I've added again a little UI and 
also enhanced or added some capabilities to the MacCVS client to :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} deal with Macintosh files with a {\b resource fork} (using a HQX encoding or 
a MacBinary encoding).
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} be {\b scriptable} by Apple Events.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} allow to {\b import} initial modules directly from the macintosh (see the problems 
relative to the {\uldb import}{\v import} command).
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b control} when adding files : that's because many user make mistakes 
when adding files and forget to add "as binary" when the file is binary.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} use {\b Internet Config} to restore Mac signatures.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} provide a work around for files which {\b auto-modify} each time you open it (such as 
CW Pro 2 projects) : this behaviour is not compatible with CVS which checks for the 
modification date on your disk. We refer to this kind of files as {\uldb dirty files}{\v dirtyfiles}
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} rewrite the architecture of MacCVS so it uses cvs as a {\b shared library} (this 
has several advantages I discuss in {\uldb Hacking CVS}{\v hacking}).
\par\pard\plain
\li500{}
\sb200\fi0
For more informations, look at the {\uldb Hacking CVS}{\v hacking} section.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{2.3 Binary and Text files}}
{}#{\footnote TOC_12}
{}K{\footnote Binary and Text files}

{}#{\footnote textandbinary}
{}K{\footnote textandbinary}


\par\pard\plain
\li500{}
\sb200\fi0
For the macintosh cvs client :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} a {\b plain binary} file is a file with a signature different of "TEXT" (for example 
a Word document .doc) and no resource fork.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} a {\b mac binary file} is a file with a signature different of "TEXT" 
and a resource fork (for example a ResEdit file and most of the mac files).
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} a {\b text file} is a file with a signature of "TEXT".
\par\pard\plain
\li500{}
\sb200\fi0
MacCVS now supply some {\b controls when adding files} : that's because many user make mistakes 
when adding files and forget to add "as binary" when the file is binary. It will warn 
you if you are about to make a mistake.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Important} : You can force a binary file to be handled as {\b plain binary} when you 
add or import files : that's because 
sometimes you can accidentaly have a resource fork (like a {\i CKID} resource) onto 
a plain binary file (for example on a CW project, a GIF file...). If you want to add files types 
to be handled as plain binary, go to the preferences and add a new type.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Note} : The resource fork on a text file is {\b ignored}. If you want to keep the resource 
fork of a text file, force to add the file as binary : but you won't be able to use this file on others platforms.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{2.4 The "import" problem}}
{}#{\footnote TOC_13}
{}K{\footnote The "import" problem}

{}#{\footnote import}
{}K{\footnote import}


\par\pard\plain
\li500{}
\sb200\fi0
The import command in cvs should be seen as inconsistent since it imports initially 
all the files as text files (so it makes a line feed conversion between the client 
and the server).
\par\pard\plain
\li500{}
\sb200\fi0
When the initial import is done and all the binary files have the binary attribute, 
the server and the client agree to not convert this files and everything is working finely.
\par\pard\plain
\li500{}
\sb200\fi0
So the problem appears ONLY during the first import, and cvs user know that the 
initial import is THE main difficulty with cvs.
\par\pard\plain
\li500{}
\sb200\fi0
Happy-fully, there are some turn-around :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Make the initial import directly from the cvs server machine 
(for now on Unix or Windows platforms). But be careful with the line feeds 
automatic translation when you copy files from and to !
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the cvs {\b wrappers} file to mark extensions as binary. But you'll still not be 
able to import from the client since all the files are initially transfered as text 
to the server.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the {\b -W} option of cvs import : the problem is that you have to figure 
yourself all the extensions to map to a binary format (the -W option works this way : 
you can tell cvs that an extension, .gif for example, represents a set of binary file). 
My experience shows you can make a lot of errors this way.
\par\pard\plain
\li500{}
\sb200\fi0
That's why the MacCVS port was implemented for :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Using the {\b import} command of the MacCVS client, you'll be able to have a 
dialog which tells you the current binary mapping and let you modify it. It detects 
also a lot of common errors and sometimes warn you about something you may care about.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} When you hit continue, MacCVS will prepare automatically the line command 
to cvs with the {\b binary wrappers} you want to use.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Finally you can import safely. Both the client and the server will know exactly 
which files are binary and which one are text.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Very important note} : You still have to set the binary preferences in order to force MacCVS 
to send the files as plain-binary to the server.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Very important note 2} : When you use plain binary files, be sure to have Internet Config 
well-configured for these files : if not, you may loose your plain binary representation and won't 
be able to open these files on others platforms (since they would be mac-encoded).
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{2.5 Getting started}}
{}#{\footnote TOC_14}
{}K{\footnote Getting started}

\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Be sure to be familiar with the {\uldb import}{\v import} problem.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} While you use CVS, make sure your Internet Config is always up-to-date 
when using plain-binary files or if you set the Internet Config option for text.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Set in the preferences the {\b CVSROOT} and the kind of {\b authentication}.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} If you create a {\b new module} using the import command, use first 
carefully the report and fix all the errors or conflicts.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the {\b online-help} available on most of the menu entries or dialogs by activating 
"Show ballons" in the help menu (unavailable on MacCVS 3.1).
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{2.6 Hacking MacCvs}}
{}#{\footnote TOC_15}
{}K{\footnote Hacking MacCvs}

{}#{\footnote hacking}
{}K{\footnote hacking}


\par\pard\plain
\li500{}
\sb200\fi0
The MacCvs port consists in :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A shared library with a MixedMode interface which contains the cvs code 
and mimic the cvs command line. This architecture allows to re-initialize the 
globals of cvs as well to separate really the implementation of the client and cvs.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} An application which implements a UI, Apple Events, a console and call 
the shared library to make the stuff.
\par\pard\plain
\li500{}
\sb200\fi0
What I've done after is to change a little bit client.c to oblige the client 
to convert the file whenever it sends it to the server. This allows to encode/decode 
the files in HQX format and also the disable/enable the line feed conversion when the 
file is flat (no resource fork) and is not a text file.
\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{3 The WinCVS Client and Local}}
{}#{\footnote TOC_16}

${\footnote The_WinCVS_Client_and_Local}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote The WinCVS Client and Local}


{\pard\sb200\plain\f0\fs24\b\tx576{3.1 Introduction}}
{}#{\footnote TOC_17}
{}K{\footnote Introduction}

\par\pard\plain
\li500{}
\sb200\fi0
The first port on cvs on Windows was done by Cyclic Software and is excellent. Why ? 
Because they ported also the {\b server and local capability} and made a great work to deal 
with the {\b non-case sensitive} Windows file system.
\par\pard\plain
\li500{}
\sb200\fi0
Except some hacks inside the cvs code to take advantages of the cvs features, 
WinCvs does not change the cvs source code : all it does it is to compile 
cvs as a {\b dll} (Dynamic Linked Library).
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{3.2 What is inside}}
{}#{\footnote TOC_18}
{}K{\footnote What is inside}

\par\pard\plain
\li500{}
\sb200\fi0
You will find inside WinCvs a set of commands (all have a on-line help entry) 
that you can use to manage source repositories.
\par\pard\plain
\li500{}
\sb200\fi0
WinCvs looks like that :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} An {\b ouput console} : you see all the messages of WinCvs, cvs client 
and cvs server so you can control that everything is going fine.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A {\b preferences dialog} : the CVSROOT, authentication...
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A set of {\b common menu commands} (Copy, Save, Paste...).
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A set of {\b cvs menu commands}.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A {\b line commands} dialog provided when the menu command is not available.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{3.3 Binary and Text files}}
{}#{\footnote TOC_19}
{}K{\footnote Binary and Text files}

\par\pard\plain
\li500{}
\sb200\fi0
You have to be very carefull about the usage of {\b binary} files : read the 
cvs documentation carefully.
\par\pard\plain
\li500{}
\sb200\fi0
WinCvs provides two ways to {\b add files} to a repository :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Add files...
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Add binary files...
\par\pard\plain
\li500{}
\sb200\fi0
WinCVS now supply some {\b controls when adding files} : that's because many user make mistakes 
when adding files and forget to add "as binary" when the file is binary. It will warn 
you if you are about to make a mistake.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{3.4 The "import" problem}}
{}#{\footnote TOC_20}
{}K{\footnote The "import" problem}

{}#{\footnote winimport}
{}K{\footnote winimport}


\par\pard\plain
\li500{}
\sb200\fi0
The import command in cvs should be seen as inconsistent since it imports initially 
all the files as text files (so it makes a line feed conversion between the client 
and the server).
\par\pard\plain
\li500{}
\sb200\fi0
When the initial import is done and all the binary files have the binary attribute, 
the server and the client agree to not convert this files and everything is working finely.
\par\pard\plain
\li500{}
\sb200\fi0
So the problem appears ONLY during the first import, and cvs user know that the 
initial import is THE main difficulty with cvs.
\par\pard\plain
\li500{}
\sb200\fi0
Happy-fully, there are some turn-around :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Make the initial import directly from the cvs server machine 
(for now on Unix or Windows platforms). But be careful with the line feeds 
automatic translation when you copy files from and to !
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the cvs {\b wrappers} file to mark extensions as binary. But you'll still not be 
able to import from the client since all the files are initially transfered as text 
to the server.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the {\b -W} option of cvs import : the problem is that you have to figure 
yourself all the extensions to map to a binary format (the -W option works this way : 
you can tell cvs that an extension, .gif for example, represents a set of binary files). 
My experience shows you can make a lot of errors this way.
\par\pard\plain
\li500{}
\sb200\fi0
That's why the WinCVS port was implemented for :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Using the {\b import} command of the WinCVS client, you'll be able to have a 
dialog which tells you the current binary mapping and let you modify it. It detects 
also a lot of common errors and sometimes warn you about something you may care about.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} When you hit continue, WinCVS will prepare automatically the line command 
to cvs with the {\b binary wrappers} you want to use.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Finally you can import safely. Both the client and the server will know exactly 
which files are binary and which one are text.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{3.5 Getting started}}
{}#{\footnote TOC_21}
{}K{\footnote Getting started}

\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Be sure to be familiar with the {\uldb import}{\v winimport} problem.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Set in the preferences the {\b CVSROOT} and the kind of {\b authentication}.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Use the {\b online-help} available on most of the menu entries or dialogs by 
clicking on the arrow located on the right of the toolbar which enables 
a sensitive help.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{3.6 Hacking WinCvs}}
{}#{\footnote TOC_22}
{}K{\footnote Hacking WinCvs}

{}#{\footnote winhacking}
{}K{\footnote winhacking}


\par\pard\plain
\li500{}
\sb200\fi0
The WinCvs port consists in :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A dll which contains the cvs code 
and mimic the cvs command line. This architecture allows to re-initialize the 
globals of cvs as well to separate really the implementation of the client and cvs.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} A MFC application which implements a UI, a console and call 
the dll to make the stuff.
\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{4 Summary of CvsGui commands}}
{}#{\footnote TOC_23}

${\footnote Summary_of_CvsGui_commands}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote Summary of CvsGui commands}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{4.1 {\b Cvs Main} menu}}
{}#{\footnote TOC_24}
{}K{\footnote {\b Cvs Main} menu}

\par\pard\plain
\li500{}
\sb200\fi0
Main cvs commands : Most of the time you will use only the update and commit commands.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_UPDATE}
{}K{\footnote HID_APP_UPDATE}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Update folder...}}
{}K{\footnote Update folder...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Merge recursively on your disk your changes with the cvs repository. Use "Commit folder..." 
to commit your changes INTO the cvs repository.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDD_COMMIT_MAIN}
{}K{\footnote HIDD_COMMIT_MAIN}

 
{}#{\footnote HID_APP_COMMIT}
{}K{\footnote HID_APP_COMMIT}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Commit folder...}}
{}K{\footnote Commit folder...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Commit your changes INTO the cvs repository. You may use "Update folder..." first to merge 
locally on your disk your changes with the cvs repository.
\par\pard\plain
\li500{}
\sb200\fi0
The {\b no recursive} option let you commit a folder without the sub-folders.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_PREFERENCES}
{}K{\footnote HID_APP_PREFERENCES}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Preferences...}}
{}K{\footnote Preferences...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Use this option to change settings like the CVSROOT, the read-only option, 
the TCP/IP compression and many other things...
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDD_CMDLINE_MAIN}
{}K{\footnote HIDD_CMDLINE_MAIN}

 
{}#{\footnote HID_APP_CMDLINE}
{}K{\footnote HID_APP_CMDLINE}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Command line...}}
{}K{\footnote Command line...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Allows to enter a cvs command line (like "cvs rtags -b -r arev arevbranch") when 
ever the cvs command is not available thru the menus.
\par\pard\plain
\li500{}
\sb200\fi0
Note that you don't have necessary to specify a local directory. That's because 
some commands (like rtags) execute only on the server. For the most of the 
others commands, you need to specify {\b where} the command is executed.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDD_CHECKOUT_MAIN}
{}K{\footnote HIDD_CHECKOUT_MAIN}

 
{}#{\footnote HID_APP_CHECKOUT}
{}K{\footnote HID_APP_CHECKOUT}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Checkout module...}}
{}K{\footnote Checkout module...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Use this option to checkout from scratch a new module on your disk. You need 
to give the complete path of the module on the server : for example : 
"myprog/mysubfolder1/mysubfolder2"
\par\pard\plain
\li500{}
\sb200\fi0
The {\b no recursive} option let you commit a folder without the sub-folders.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDD_IMPORT_MAIN}
{}K{\footnote HIDD_IMPORT_MAIN}

 
{}#{\footnote HIDD_IMPORT_TAGS}
{}K{\footnote HIDD_IMPORT_TAGS}

 
{}#{\footnote HID_APP_IMPORT}
{}K{\footnote HID_APP_IMPORT}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Import module...}}
{}K{\footnote Import module...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Use this option to create a new module into the cvs repository located on the 
cvs server machine. After importing, you should use the "Checkout module..." 
command to start using this new module.
\par\pard\plain
\li500{}
\sb200\fi0
You need to give the complete path of the module on the server : for example : 
"myprog/mysubfolder1/finalPlaceForTheModule"
\par\pard\plain
\li500{}
\sb200\fi0
Refer to the explanation of the import problem ({\uldb Mac import}{\v import} or 
{\uldb Windows import}{\v winimport}).
\par\pard\plain
\li500{}
\sb200\fi0
The {\b vendor} and {\b release} tags are usefull whenever you'll want to get 
back to the initial version or create a branch. Refer to the cvs documentation 
for more details.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_LOGIN}
{}K{\footnote HID_APP_LOGIN}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Login...}}
{}K{\footnote Login...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Use this option when you want to login for the first time to a cvs server machine. 
You should need to login ONLY if the kind of authentication in the preferences 
is "pserver" (password authenticate).
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{4.2 {\b Cvs Files} menu}}
{}#{\footnote TOC_25}
{}K{\footnote {\b Cvs Files} menu}

\par\pard\plain
\li500{}
\sb200\fi0
Menu with cvs commands which apply on files.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_UPDATEF}
{}K{\footnote HID_APP_UPDATEF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Update files...}}
{}K{\footnote Update files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Merge locally on your disk your changes and the changes of the cvs repository so 
you can use the "Commit files..." command to commit your change on the cvs server 
repository.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_COMMITF}
{}K{\footnote HID_APP_COMMITF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Commit files...}}
{}K{\footnote Commit files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Commit your changes into the cvs server repository. You may need first to 
"Update files..." in order to merge your changes with the cvs server before 
you can commit them.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_DIFF}
{}K{\footnote HID_APP_DIFF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Diff files...}}
{}K{\footnote Diff files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Show the difference between your files and the files located on the cvs 
server repository : this way you can check the changes with the remote server.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_LOG}
{}K{\footnote HID_APP_LOG}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Log files...}}
{}K{\footnote Log files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Ask the server to tell the history of the files (comments, revision number, 
tags and so on...)
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_ADDF}
{}K{\footnote HID_APP_ADDF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Add files...}}
{}K{\footnote Add files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Mark the files to be added to the master repository located on the server. 
These files will be really added AFTER you did commit them. In order to 
add files enclosed into a new folder, use the "Add folder..." option first 
on the folder.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_ADDB}
{}K{\footnote HID_APP_ADDB}

 (Windows only)
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Add binary files...}}
{}K{\footnote Add binary files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Same as the previous but add binary files.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_REMOVEF}
{}K{\footnote HID_APP_REMOVEF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Remove files...}}
{}K{\footnote Remove files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Mark the files to be removed from the master repository located on the 
server. These files will be really removed AFTER you did commit the folder 
where these files were located.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_STATUS}
{}K{\footnote HID_APP_STATUS}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Status files...}}
{}K{\footnote Status files...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Ask the cvs server to tell the status of the files (changed locally, 
unchanged, current status, locks, and so on...).
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_CANCELC}
{}K{\footnote HID_APP_CANCELC}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Cancel changes...}}
{}K{\footnote Cancel changes...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
It is not a real cvs command but it's provided for convenience. 
This option will send to trash the files in the trash (you can 
on Macintosh use the "Put Away" option of the Finder to recover them) then 
will ask the cvs server to update these files.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{4.3 {\b Cvs Folder} menu}}
{}#{\footnote TOC_26}
{}K{\footnote {\b Cvs Folder} menu}

\par\pard\plain
\li500{}
\sb200\fi0
The cvs commands which apply on a folder.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_ADD}
{}K{\footnote HID_APP_ADD}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Add a folder...}}
{}K{\footnote Add a folder...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Whenever you add files to the repository, you need first to add the folders.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HID_APP_DIFFF}
{}K{\footnote HID_APP_DIFFF}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Diff a folder...}}
{}K{\footnote Diff a folder...}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Print the differences recursively with the cvs remote repository for all the 
files enclosed in the folder.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDD_PREFS_CVSROOT}
{}K{\footnote HIDD_PREFS_CVSROOT}

 
{}#{\footnote HIDD_PREFS_GLOBALS}
{}K{\footnote HIDD_PREFS_GLOBALS}

 
{}#{\footnote HIDD_PREFS_PORTS}
{}K{\footnote HIDD_PREFS_PORTS}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{4.4 {\b Preferences} dialog}}
{}#{\footnote TOC_27}
{}K{\footnote {\b Preferences} dialog}

\par\pard\plain
\li500{}
\sb200\fi0
The cvs commands which apply on a folder.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_CVSROOT}
{}K{\footnote HIDC_CVSROOT}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{The CVSROOT field}}
{}K{\footnote The CVSROOT field}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
It should be something like alexp@cvs.strata3d.com:/cvsroot. 
Never enter the ":pserver:" or ":kserver:" directly, use the 
radio buttons instead.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_CHECKOUTRO}
{}K{\footnote HIDC_CHECKOUTRO}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Checkout read-only}}
{}K{\footnote Checkout read-only}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Turn-on if you want the files created by MacCVS to appear 
locked in the finder.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_PRUNE}
{}K{\footnote HIDC_PRUNE}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Prune empty directories}}
{}K{\footnote Prune empty directories}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If On, this option will automatically remove empty folders 
when you update a module.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_TCPIP}
{}K{\footnote HIDC_TCPIP}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{TCP/IP compression}}
{}K{\footnote TCP/IP compression}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
When this option is on, the server and MacCVS compress informations 
so they use less bandwidth : use only if you have a slow (modem) 
connection with the server because it causes the server to work 
much more.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_QUIET}
{}K{\footnote HIDC_QUIET}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Quiet mode}}
{}K{\footnote Quiet mode}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If on, cause the command to be somewhat quiet; informational messages, 
such as reports of recursion through subdirectories, are 
suppressed.
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_CTNLADD}
{}K{\footnote HIDC_CTNLADD}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Control when adding files}}
{}K{\footnote Control when adding files}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Most of the errors using cvs are related to binary files. Since the client and the server usually {\b convert} the line feeds, it's important when you add a file to specify if you add a binary file {\b or} a text file. This option will help you to not make errors by parsing the file you add and check if it's a binary file, if the file has the good line feed for the machine and so on...
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_RHOSTS}
{}K{\footnote HIDC_RHOSTS}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{".rhosts" authentication}}
{}K{\footnote ".rhosts" authentication}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If On, the cvs server will authenticate MacCVS regarding the IP number 
of the machine running MacCVS : you should have a proper ".rhosts" file 
on the server account with an access 0600 which contains something like 
"192.10.10.37 alexp" or "alexpmac.strata3d.com alexp".
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_PSERVER}
{}K{\footnote HIDC_PSERVER}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{":pserver:" authentication}}
{}K{\footnote ":pserver:" authentication}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If On, the cvs server will authenticate MacCVS regarding a password 
located in the cvs administration file "passwd" on the server : 
you should have a proper entry for you in this file, something like  
"alexp:X5gFtdhaDke93j".
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote HIDC_KSERVER}
{}K{\footnote HIDC_KSERVER}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{":kserver:" authentication}}
{}K{\footnote ":kserver:" authentication}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If On, the cvs server will authenticate MacCVS regarding a Kerberos 
authentication session. Refer to your adminstrator to know how to use 
Kerberos.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Modify the server ports & name}}
{}K{\footnote Modify the server ports & name}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Regarding the authentication you use (pserver, kserver...) you can change 
the default TCP {\b ports and name} cvs uses to reach the server. Refer to the cvs 
documentation for more details.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{ISO8559 translation on text files (Mac only)}}
{}K{\footnote ISO8559 translation on text files (Mac only)}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
If on, MacCvs will translate (only on text files) the mac characters encoding 
into a standard ISO8559_xxx encoding when it sends the file {\b to} the server. It 
will obviously translate back ISO8559_xxx characters encoding into the Mac encoding 
when getting a file {\b from} the server. This option is usefull if you use 
accentuations in text files because the accents will remain readable on 
others systems (Windows, Unix). Only ISO8559_1 Latin 1 (Western Europe) is 
implemented right now. Thanks to Jim Matthews to provide the ISO8559_1 table 
in the {\b Fetch} program.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Use Internet Config for text files (Mac only)}}
{}K{\footnote Use Internet Config for text files (Mac only)}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
MacCvs usually asks {\b Internet Config}, whenever it creates a {\b binary} file, 
the default {\b type and creator} signature for the file. So by using 
Internet Config, you can tell MacCvs that, for example, all the files 
ending by the extension .mcp have the file type/creator set to MMPr/CWIE. 
By using this option, you can extend this behaviour to the {\b text} files so you 
can for example map a type/creator for the .c, .h, .html...
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote dirtyfiles}
{}K{\footnote dirtyfiles}

\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{5 Note on dirty files}}
{}#{\footnote TOC_28}

${\footnote Note_on_dirty_files}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote Note on dirty files}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{5.1 A little bit of history first }}
{}#{\footnote TOC_29}
{}K{\footnote A little bit of history first }

\par\pard\plain
\li500{}
\sb200\fi0
We started using cvs in our company when 
we turned to Code Warrior Pro 2. We realized Code Warrior had a very annoying 
bug and we were unable to find a work around with Source Safe. When you 
lock the projects, and if you have a very deep and complex set of projects, 
the projects behave badly and recompile each time, plus, they take a long-long 
time to open...
\par\pard\plain
\li500{}
\sb200\fi0
So we thought : "OK, let's unlock them". Then the horror : the project 
were auto-modifying themselves when unlocked. The problem appeared 
when everybody tried to check-in the first time : all the projects 
were modified each time, resulting in corrupting and 
increasing fastly the size of the repository.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{5.2 Advantage of "Open Code Software"}}
{}#{\footnote TOC_30}
{}K{\footnote Advantage of "Open Code Software"}

\par\pard\plain
\li500{}
\sb200\fi0
Then I suggested we tried cvs so we could hack cvs by making it behave 
the way we expect.
\par\pard\plain
\li500{}
\sb200\fi0
We came up with this solution :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 1. The file with the extension {\b .mcp} will be a dirty file. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 2. The file will be ignored by cvs, like .cvsignore does, {\b unless} 
the user asks to {\b explicitely} to something with this file : 
the method to tell cvs to commit a dirty file is to ask to commit 
{\b this} files and {\b only} this file (a recursive commit 
will ignore the dirty file). 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 3. The only way to add, remove, commit, merge a dirty file is 
to explicitly invoke cvs with this operation and with only this file. 
\par\pard\plain
\li500{}
\sb200\fi0
No need to tell you we'll be happy when finally Metrowerks will have 
fixed this bug :<...
\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote goodies}
{}K{\footnote goodies}

\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{6 Goodies with MacCvs/WinCvs}}
{}#{\footnote TOC_31}

${\footnote Goodies_with_MacCvs_WinCvs}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote Goodies with MacCvs/WinCvs}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{6.1 CWCVS : a cvs plug-in for Metrowerks (Mac only)}}
{}#{\footnote TOC_32}
{}K{\footnote CWCVS : a cvs plug-in for Metrowerks (Mac only)}

\par\pard\plain
\li500{}
\sb200\fi0
We use it all the time and it's nice !
\par\pard\plain
\li500{}
\sb200\fi0
Since Richard Wesley, the author, is American, you'd better go directly to  
http://www.electricfish.com/hawkfish/CWCVS/CWCVS.html for 
a good explanation in plain English...
\par\pard\plain
\li500{}
\sb200\fi0
Only the Mac side is provided right now and it is a shareware.
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{6.2 MPW tools (Mac only)}}
{}#{\footnote TOC_33}
{}K{\footnote MPW tools (Mac only)}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Description}}
{}K{\footnote Description}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Right now, two MPW tools are provided with MacCVS with complete 
source code :
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b cvs} : the same exact code which uses MacCvs. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b cvslog} : invokes "cvs log" but filters the ouput 
for a more convenient use. Basically it allows to retrieve 
a set of files by date/user/branch/revision/tags. 
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\plain\f0\sb200\fs24\b\tx576{Getting started with MPW cvs tools}}
{}K{\footnote Getting started with MPW cvs tools}\par\pard\plain\li500\sb200\fi0

\par\pard\plain
\li500{}
\sb200\fi0
Place these tools into the tools folder of MPW.
\par\pard\plain
\li500{}
\sb200\fi0
To get the usage of these tools, simply type the 
command + enter.
\par\pard\plain
\li500{}
\sb200\fi0
All you need after is to read how to set-up {\uldb environment variables}{\v envariable} 
for cvs, then you can use it straight. Most of the time 
you don't even need to set any variable because cvs 
keeps track on your disk about the informations it needs.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Important note} : these tools require to find the 
shared library provided with MacCVS. So you can place 
the shared library in the system folder or create two 
aliases of thse libraries at the same directory level than 
the mpw tools.
\par\pard\plain
\li500{}
\sb200\fi0

\page{\pard\plain\keepn\f0\fs36\b\tx576{7 Annex}}
{}#{\footnote TOC_34}

${\footnote Annex}
+{\footnote browse}
\par\pard\plain\li500\sb200\fi0
{}K{\footnote Annex}

\par\pard\plain
\li500{}
\sb200\fi0
{}#{\footnote envariable}
{}K{\footnote envariable}

\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{7.1 Environment variables used by MacCVS/WinCVS}}
{}#{\footnote TOC_35}
{}K{\footnote Environment variables used by MacCVS/WinCVS}

\par\pard\plain
\li500{}
\sb200\fi0
Most the communication of MacCVS & WinCVS with cvs is done 
thru {\b environment variables}.
\par\pard\plain
\li500{}
\sb200\fi0
The cvs documentation will tell you about these variables. We'll refer 
here only to the most used ones or to the one only used by WinCVS/MacCVS.
\par\pard\plain
\li500{}
\sb200\fi0
The reason you may want to be aware of this variables is because 
you want to use the AppleEvent capability of MacCVS or the MPW 
tools.
\par\pard\plain
\li500{}
\sb200\fi0
{\b Mac Note} : Some of the variables are noted as "globals" : it means that if you do not 
define it, the MPW tool or MacCVS by AppleEvent will get these 
values directly from the MacCVS preferences. So you don't need to define 
them, unless you want to overide these values.
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVSROOT} : your CVSROOT, something 
like {\b alexp@cvs.strata3d.com:}path/to/repository/. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVSREAD} : if set to "yes" or "1" or any non-null 
value, means you want to check-out read-only. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b USER} (Mac only) : the user account you use on the 
remote server. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b LOGNAME} : overides the result of getlogin(). Set it 
on Windows when your cvs account is different from your login account 
(for example "administrator"). 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVS_GETPASS} (MacCVS/WinCVS only) : used by CvsGui to prompt 
a password for the pserver authentication. You have only to define 
it the first time you login to the cvs server (see cvs login). 
After don't define it, that's not safe to define a clear password. 
cvs stores the password in a scrambled file named ".cvspass". 
You might prefer to login in MacCVS/WinCVS before so you 
don't have to use it. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b HOME (global)} : used by cvs to get globals settings files like 
the .cvspass, .cvsrc... You need it most of the time so it's usefull to define 
it to your preference folder on Mac and somewhere else for Windows. 
{\b Mac only} : the '@@@' trick have been removed and you should give now 
a regular Mac path instead (e.g. System:System Folder:Preferences:). 
The default is automatically set to your preference folder. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b IC_ON_TXT (global)} (Mac only) : Use Internet Config services 
also on text files when set to "1". 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b ISO8859 (global)} : use ISO-Latin-1 encoding on text files 
when set to "1". 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVS_PSERVER_PORT (global)} : default to null. Overides 
the default port for pserver authentication (usually 2401). 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVS_RCMD_PORT (global)} : default to null. Overides 
the default port for rcmd authentication (usually 514). 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b CVS_SERVER (global)} : default to null. Overides 
the default cvs server's name (usually "cvs"). 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b MAC_DEFAULT_RESOURCE_ENCODING (global)} : the value can be either 
"HQX" or "AppleSingle". 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b MAC_BINARY_TYPES_PLAIN (global)} : the value is a semi-colon separated 
set of Mac signatures that you want to be turned into plain binary  
on the server (ex: "MMPr;JPEG"). This option will force to ignore the resource 
fork. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b MAC_BINARY_TYPES_HQX (global)} : the value is a semi-colon separated 
set of Mac signatures that you want to be turned into hqx format on the server. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} {\b MAC_BINARY_TYPES_SINGLE (global)} : the value is a semi-colon separated 
set of Mac signatures that you want to be turned into AppleSingle format on the server. 
\par\pard\plain
\li500{}
\sb200\fi0

{\pard\sb200\plain\f0\fs24\b\tx576{7.2 A discussion about MacCVS architecture and the CR/LF problem}}
{}#{\footnote TOC_36}
{}K{\footnote A discussion about MacCVS architecture and the CR/LF problem}

\par\pard\plain
\li500{}
\sb200\fi0
email of Miro Jurisic 
to Alexandre Parenteau
\par\pard\plain
\li500{}
\sb200\fi0
I think it's very important that you know what was going on, so I'll write 
a hopefully clear description here... if you have any questions please ask 
:)
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 1. How MSL writes to a file: When MSL writes to a disk file, every \r 
will be replaced with \n, and 
every \n will be replaced with \r, if the file was _not_ opened in the 
binary mode. If the file was opened in binary mode, this replacement does 
not occur. The exact place where this replacement occurs is in 
__flush_buffer (buffer_io.c). This routine is called from fclose to write 
the data out before a file is closed. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 2. How MSL writes to console: When MSL writes to a console, it treats 
it as an ASCII file. This means 
that when __flush_buffer is called for the console, \n\r conversion occurs, 
and then WriteCharsToConsole is written. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} 3. What 'Map newlines to CR' does: If this is turned on in language 
settings, compilers will switch \n and \r when compiling your code
\par\pard\plain
\li500{}
\sb200\fi0
Now that we got those clearly written, let's see what the cvsLib glue does:
\par\pard\plain
\li500{}
\sb200\fi0
cvsLib has its own WriteCharsToConsole which calls into MacCVS. This is 
setup when the library is loaded (in function loadCVS). Specifically, 
cvsLib's WriteCharsToConsole calls MacCVS' consoleout. consoleout does one 
of two things: if MacCVS is being run via AppleEvents, it writes output to 
the reply event. Otherwise, if calls fwrite on stdout to write the data to 
the console.
\par\pard\plain
\li500{}
\sb200\fi0
Okay, so the way that the 3.0b3 code works is like this:
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 1: MacCVS writing to the console : 
MacCVS calls printf (or fprintf/write on stdout/stderr). Since MacCVS is 
compiled with 'Map newlines to CR' off, there is exactl one conversion 
going on, and that is MSL converting \r\n when flushing the console buffer. 
That works fine. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 2: cvsLib writing to an ASCII file (the broken case) : 
cvsLib calls fwrite/fprintf. Since cvsLib is compiled with 'Map newlines to 
CR', \r\n conversion occurs _twice_: first, at compile time, becaue of the 
settings; second, at the time __flush_buffer is called, because we are 
writing to an ASCII file. This causes files written by cvsLib to have the 
wrong linebreaks. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 3: cvsLib writing to the console (the tricky case) : 
cvsLib calls fwrite/fprintf/printf on stdout/stderr. First \n\r conversion 
occured at compile time. When it is the time to flush the console buffer, 
__flush_bufer is called. It performs a \n\r conversion and then calls 
WriteCharsToConsole. This is the glue WriteCharsToConsole, which calls 
consoleout. consoleout calls fwrite, which eventually calls __flush_buffer 
again. __flush_buffer performs another conversion, and then calls the real 
WriteCharsToConsole. Since there were 3 conversions happening, the overall 
effect is that \n is converted to \r and vice versa.
\par\pard\plain
\li500{}
\sb200\fi0
Hopefully, now you see where the problem is (this is where I was late 
Monday afternoon).
\par\pard\plain
\li500{}
\sb200\fi0
I decided that it was not necessary to go through the process of loading 
and unloading cvsLib all the time (I was not aware of the problems that 
would cause), so I rearranged the libraries between fragments. I fixed the 
\n\r problem, but I introduced a new problem: cvs was crashing reproducibly 
the _second_ time a cvs command was invoked. This is where I went to bed on 
Monday.
\par\pard\plain
\li500{}
\sb200\fi0
On Tuesday, I woke up and started stepping through the code to determine 
why the garbage collector is blowing up. I traced the problem to some 
globals being freed twice. What was going on? Since I changed the linkage 
so that cvsLib was only loaded once, its globals were initialized when 
MacCVS was started up. The first time cvsLib was called, it allocated space 
for some strings and set some globals to point to them. Before returning it 
freed those globals - but it didn't set them to NULL after freeing them. 
The second time cvsLib was invoked, some of those globals were freed again 
(because they weren't NULL), which was wrong.
\par\pard\plain
\li500{}
\sb200\fi0
At that point I realized that the library must be loaded and unloaded 
repeatedly; I also got your email in which you said that GUSI should be 
loaded and unloaded repeatedly because it contains those static destructors 
that clean up MacTCP state.
\par\pard\plain
\li500{}
\sb200\fi0
After reading that I stepped away from my computer, went to the drawing 
board, and concluded that it is impossible to do anything but to have a 
closer look at the cvsLib glue, and see whether the hidden conversion can 
be eliminated. This turned out to be far simpler that I could hope for: 
instead of calling fwrite from consoleout, I called directly 
WriteCharsToConsole, thereby avoiding the extra conversing that was the 
problem. Of course, I also had to turn 'Map newline to CR' in the settings, 
to even everything out. The result is that:
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 1: MacCVS writing to the console : Nothing changed 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 2: cvsLib writing to an ASCII file (the fixed case) : 
Since there is only one \r\n conversion going on (in __flush_buffer), the 
files are written correctly. 
\par\pard\plain
\li1000{}
\sb200\fi0
\li1000{}\fi-200{\f3\'B7} Case 3: cvsLIb writing to console (the less tricky case) : 
Two conversion were removed: the compile-time conversion, and the hidden 
conversion in the cvsLib glue. Therefore, nothing changed - the console 
still works perfectly.
\par\pard\plain
\li500{}
\sb200\fi0
Whew!
\par\pard\plain
\li500{}
\sb200\fi0
Please let me know if you are unclear on this... now I have a good view of 
the problem and how I fixed it, and some really great insight on how pieces 
of MacCVS fit together.
\par\pard\plain
\li500{}
\sb200\fi0
...
\par\pard\plain
\li500{}
\sb200\fi0
cheers,
\par\pard\plain
\li500{}
\sb200\fi0
meeroh
\par\pard\plain
\li500{}
\sb200\fi0
}