clientloguser.cpp #8

// clientloguser.cpp: implementation of the clientloguser class.
//
//////////////////////////////////////////////////////////////////////

#include <clientapi.h>
#include "changesorter.h"
#include "filehead.h"
#include "filelogcache.h"
#include "clientloguser.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

ClientLogUser::ClientLogUser()
{
	doneone = toomany = false;
}

ClientLogUser::~ClientLogUser()
{

}

/* This is where the magic happens.
 * Lines of filelog output will have a level of '0', '1', or '2'.
 * Level '0' is the file name - we can ignore this.
 * Level '1' is a revision record, looking like this:
 * #2 change 767 edit on 2001/09/25 by samwise@samwise-luey (binary+k) 'description'
 * Level '2' is an integ record, looking like this:
 * branch from //depot/foo/bar#1,#2
 */

void ClientLogUser::OutputInfo(char level, const_char *data)
{
	if (toomany) return; //make sure to only process ONE file.

	/* Get depot path from here in case file arg wasn't in depot syntax. */
	if (level == '0')
	{
		if (doneone) //this is the second file this CLU has seen!
		{
			toomany = true;
			return;
		}
		char* ptr = data;
		working->name.Clear();
		while ( *ptr && *ptr != '\n' ) working->name.Append( ptr++, 1 );
		doneone = true;
	}
	/* If this is a rev record, create a new FileRev object for it. */
	if (level == '1')
	{
		StrBuf rev = StrBuf(); //this will be the rev number
		StrBuf change = StrBuf(); //this will be the change number
		RevType type; //this will be the revision type
		char* ptr = data+1; //skip over '#' - we're now pointing at the rev number
		while (*ptr != ' ') //go until we see the first space
		{
			rev.Append(ptr, 1);
			ptr++;
		} //rev now contains the rev number.
		ptr += 8; //skip over ' change ' - we're now pointing at the change number
		while (*ptr != ' ')
		{
			change.Append(ptr, 1);
			ptr++;
		} //change now contains the change number.
		ptr++; //skip the space - now looking at the rev type.
		switch (*ptr) //We can determine the rev type from the first letter alone unless it's an i.
		{
		default:
		case 'e': type = EDIT; break; // 'edit'
		case 'a': type = ADD; break; // 'add'
		case 'b': type = BRANCH; break; // 'branch'
		case 'd': type = DEL; break; // 'delete'
		case 'i': type = UNKNOWN_TYPE; break;  //indeterminate from first character
		}
		if (type == UNKNOWN_TYPE) //Was it an 'i'?
		{
			ptr++;
			if (*ptr == 'm') type = ADD; // 'import'
			else type = INTEG; // 'integ'
		}
		//note: users and clients can have parens, so we have to skip past them
		while (*ptr != '@') ptr++; //skip up to the "@" before the client
		while (*ptr != ' ') ptr++; //skip to the space before the ftype
		ptr += 2; //skip to the first letter of the ftype
		bool istext = (*ptr == 't' || *(ptr+1) == 't');
		working->addRev(rev, change, type, istext); //Tell the FileHead to create a new FileRev.
		return; //All done with this line of output!
	}
	/* Here's where we handle integ records.*/
	if (level == '2')
	{
		ArrowType atype; //New integ type.

		char* ptr = data; //ptr is pointing at the first character of the integ type.
		switch (*ptr)
		{
		default:
		case 'm': atype = merge; break;  // 'merge'
		case 'b': atype = branch; break; // 'branch'
		case 'e': atype = impure; break;  // 'edit'
		case 'a': atype = impure; break;  // 'add'
		case 'c': atype = copy; break;   // 'copy'
		case 'i': atype = ignore; break; // 'ignored'
		}
		
		while (*ptr != ' ') {ptr++;} //Skip past the rest of that word to the next space.
		ptr++; //Skip the space - the current word is either 'from' or 'into'.

		/* A "from" integ record will be indicated by the word "from" in most cases.
	     * For example, "merge from" or "branch from".  The exception is the word
		 * "ignored".  If this is the case, we'll be looking at a filespec rather
		 * than a "from" or "into". */
		if (*ptr == 'f' || *ptr == '/') // 'from' or the beginning of a filespec.
		{ //This is a "from" record, so note this in the appropriate FileRev.
			StrBuf filepath = StrBuf(); //This will be the "fromfile".
			StrBuf rev = StrBuf(); //This will be the "fromrev".

			if (*ptr == 'f') //If this word is "from", skip past it to the file.
			{

				while (*ptr != ' ') {ptr++;}
				ptr++; //now we're at the start of the "from" filespec
			}
			//If it wasn't, it was an "ignored" and we're there anyway.
			while (*ptr != '#') //scan up to the '#' revision marker.
			{
				filepath.Append(ptr, 1);
				ptr++;
			}
			ptr ++; //Skip over the '#'.  Now looking at a revision number.
			/* At this point we'll either see a single revision or a revision
			 * range.  If it's a revision range it'll be of the form:
			 * #12,#15
			 * whereas a single revision will just be
			 * #15
			 * If it's a range, we want to look at the last number in that range. */
			while ((*ptr != ',') && (*ptr != '\0'))
			{
				rev.Append(ptr, 1);
				ptr++;
			} //rev now contains either the single revision, or the first rev in a range.
			if ( *ptr == '\0' || *ptr == '\n' )  //Single revision - use it.
			{
				working->tail->AddFromText(filepath, rev, atype);
				return; //All done with this line.
			}
			rev.Clear();   //This isn't the end of the line, so there must be another rev.
			ptr+=2; //skip over ",#" to get to the start of the end rev.
			while ( *ptr != '\0' && *ptr != '\n' )
			{
				rev.Append(ptr, 1);
				ptr++;
			} //Now rev contains the end rev of the range.
			working->tail->AddFromText(filepath, rev, atype);
			return; //Done.
		}
		else // This line is an "into".
		{
			StrBuf filepath = StrBuf();
			StrBuf rev = StrBuf();
			while (*ptr != ' ') {ptr++;} //Skip over this word, be it "into" or "by".
			ptr++; //Skip the space - now we're at the start of an "into" filespec.
			while (*ptr != '#') //Go up to the '#' marker.
			{
				filepath.Append(ptr, 1);
				ptr++;
			} // We now have the "into" file.
			ptr++; //Skip the '#' and get to the revision.  This is not a range.
			while ( *ptr != '\0' && *ptr != '\n' )
			{
				rev.Append(ptr, 1);
				ptr++;
			}
			working->tail->AddIntoText(filepath, rev, atype);
			return; //Done!
		}
	}
}