static void CollectPreBeginNote(PatchTask patchTask, SourceFile sourceFile, int currentLineId)
{
//read content of block
//and also find
int beginAtLine = currentLineId;
//find end end block
int j = sourceFile.LineCount;
int i = beginAtLine - 1; //next line
int count1 = 0;
List <string> notes = new List <string>();
while (i >= 0 && count1 < 2)
{
string prevLine = sourceFile.GetLine(i).TrimStart();
//parse nextline for a command
if (!string.IsNullOrEmpty(prevLine))
{
if (prevLine.StartsWith("//###_"))
{
//stop
break;
}
//this should be end context
notes.Insert(0, prevLine);
count1++;
}
i--;
}
patchTask.preNotes.AddRange(notes); //PRE
}
static void CollectPostEndNote(PatchTask patchTask, SourceFile sourceFile, int currentLineId)
{
//read content of block
//and also find
int beginAtLine = currentLineId;
//find end end block
int j = sourceFile.LineCount;
int i = beginAtLine + 1; //next line
int count1 = 0;
List <string> notes = new List <string>();
while (i < j && count1 < 2)
{
string nextLine = sourceFile.GetLine(i).TrimStart();
if (nextLine.StartsWith("//###"))
{
//stop
break;
}
//parse nextline for a command
if (!string.IsNullOrEmpty(nextLine))
{
//this should be end context
notes.Add(nextLine);
count1++;
}
i++;
}
patchTask.postNotes.AddRange(notes); //POST
}
/// <summary>
/// save patch file to disk
/// </summary>
/// <param name="filename"></param>
public void SavePatchFile(string filename)
{
//save all patch task
int j = patchTasks.Count;
var output = new SourceFile(filename, true);
//first line of patch file is original file name
output.AddLine(_ORIGINAL + " " + this.OriginalFileName);
for (int i = 0; i < j; ++i)
{
PatchTask ptask = patchTasks[i];
List <PatchCommand> cmds = ptask.GetCommands();
//each task begin with start command
output.AddLine(PatchCommand.START + " " + ptask.TaskId);
output.AddLine(ptask.LandMark);
int cmdCount = cmds.Count;
for (int n = 0; n < cmdCount; ++n)
{
PatchWriter.WriteCommand(output, cmds[n], true);
}
}
output.Save();
}
public PatchTask NewTask(string landMark)
{
var srcPos = new PatchTask(landMark, patchTasks.Count);
patchTasks.Add(srcPos);
return(srcPos);
}
public void AddTask(PatchTask task)
{
patchTasks.Add(task);
}
/// <summary>
/// create patch file from a patch file in disk
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
public static PatchFile BuildPatchFile(string filename)
{
//create patch command for specific filename
PatchFile patchFile = new PatchFile(filename);
SourceFile sourceFile = new SourceFile(filename, false);
sourceFile.ReadAllLines();
int j = sourceFile.LineCount;
if (j == 0)
{
return(null);
}
//
PatchTask ptask = null;
int i = 0;
string line = sourceFile.GetLine(0);
//first line is original filename
string originalFilename;
if (GetOriginalFilename(line, out originalFilename))
{
//change origial file name for patch file
patchFile.OriginalFileName = originalFilename;
i++; //next line
}
for (; i < j; ++i)
{
line = sourceFile.GetLine(i).TrimStart(); //***
if (line.StartsWith("//###_"))
{
//what is the comamnd
line = line.TrimEnd();
string cmdline;
int taskId;
string additionalInfo;
ParseCommand(line, out cmdline, out taskId, out additionalInfo);
switch (cmdline)
{
case PatchCommand.START:
{
//start new patch task
//read next line for info
i++; //read next line for land mark
string cmd_value = sourceFile.GetLine(i);
//create new task
ptask = new PatchTask(cmd_value, taskId);
ptask.Owner = patchFile;
if (additionalInfo == "-X") //special cmd
{
ptask.PatchStartCmd = additionalInfo;
}
//
patchFile.AddTask(ptask);
}
break;
case PatchCommand.BEGIN:
{
//begin block ***
//create new patch block
ptask = new PatchTask("", taskId); //we will set land mark later
ptask.Owner = patchFile;
ptask.IsPatchBlock = true;
patchFile.AddTask(ptask);
ParseAutoContextPatchBlock(ptask, sourceFile, ref i);
//parse auto context patch block
}
break;
case PatchCommand.APPPEND_START:
{
//start collect append string
//until find append_stop
var collectAppendStBuilder = new StringBuilder();
i++;
string cmd_value = sourceFile.GetLine(i);
line = cmd_value.TrimStart();
//eval
do
{
if (line.StartsWith(PatchCommand.APPPEND_STOP))
{
//stop here
break;
}
else
{
if (line.StartsWith("//###_"))
{
//other command
throw new NotSupportedException();
}
else
{
//collect this line
collectAppendStBuilder.AppendLine(line);
//read next line
i++;
line = sourceFile.GetLine(i).TrimStart();
}
}
} while (true);
//finish command
ptask.Append(collectAppendStBuilder.ToString());
}
break;
case PatchCommand.APPPEND_STOP:
throw new NotSupportedException();
case PatchCommand.FIND_NEXT_LANDMARK:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.FindNext(cmd_value);
}
break;
case PatchCommand.FOLLOW_BY:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.FollowBy(cmd_value);
}
break;
case PatchCommand.SKIP_UNTIL_AND_ACCEPT:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.SkipUntilAndAccept(cmd_value);
}
break;
case PatchCommand.SKIP_UNTIL_PASS:
{
//has 2 parameters
if (additionalInfo == null)
{
throw new NotSupportedException();
}
//
ptask.SkipUntilPass(additionalInfo);
}
break;
default:
throw new NotSupportedException();
}
}
}
if (patchFile.TaskCount > 0)
{
return(patchFile);
}
else
{
return((ptask != null && ptask.CommandCount > 0) ? patchFile : null);
}
}
static void ParseAutoContextPatchBlock(PatchTask patchTask, SourceFile sourceFile, ref int currentLineId)
{
//read content of block
//and also find
int beginAtLine = currentLineId;
//find end end block
int i = beginAtLine + 1; //next line
int j = sourceFile.LineCount;
List <string> contentLines = new List <string>();
int foundPreNoteCount = 0;
int foundPostNoteCount = 0;
for (; i < j; ++i)
{
string line = sourceFile.GetLine(i).TrimStart(); //***
if (!line.StartsWith("//###_"))
{
contentLines.Add(line);
}
else
{
line = line.TrimEnd();
string cmdline;
int taskId;
string additionalInfo;
ParseCommand(line, out cmdline, out taskId, out additionalInfo);
switch (cmdline)
{
default:
throw new NotSupportedException();
case PatchCommand.PRE:
{
i++;
//read next line for PRE data
patchTask.preNotes.Add(sourceFile.GetLine(i));
foundPreNoteCount++;
}
break;
case PatchCommand.POST:
{
i++;
patchTask.postNotes.Add(sourceFile.GetLine(i));
foundPostNoteCount++;
}
break;
case PatchCommand.END:
{
//------
//find context of begin and end **
//1. begin context
//2. post context
//find proper land mark
//read next line
if (foundPreNoteCount == 0 && foundPostNoteCount == 0)
{
//find auto context
CollectPreBeginNote(patchTask, sourceFile, beginAtLine);
CollectPostEndNote(patchTask, sourceFile, i);
}
else
{
//use existing notes
}
patchTask.ContentLines = contentLines;
currentLineId = i;
return;
}
}
}
}
currentLineId = i;
}
/// <summary>
/// save patch file to disk
/// </summary>
/// <param name="filename"></param>
public void SavePatchFile(string filename)
{
//save all patch task
int j = patchTasks.Count;
var output = new SourceFile(filename, true);
//first line of patch file is original file name
output.AddLine(_ORIGINAL + " " + this.OriginalFileName);
for (int i = 0; i < j; ++i)
{
PatchTask ptask = patchTasks[i];
List <PatchCommand> cmds = ptask.GetCommands();
//each task begin with start command
if (ptask.IsPatchBlock)
{
//this is patch block
output.AddLine(PatchCommand.BEGIN + " 0");
//pre-notes/ post-notes
int noteCount = ptask.preNotes.Count;
for (int m = 0; m < noteCount; ++m)
{
//write each line of pre note
output.AddLine(PatchCommand.PRE);
output.AddLine(ptask.preNotes[m]);
}
//---------
int contentLineCount = ptask.ContentLines.Count;
for (int m = 0; m < contentLineCount; ++m)
{
output.AddLine(ptask.ContentLines[m]);
}
//---------
noteCount = ptask.postNotes.Count;
for (int m = 0; m < noteCount; ++m)
{
//write each line of post note
output.AddLine(PatchCommand.POST);
output.AddLine(ptask.postNotes[m]);
}
output.AddLine(PatchCommand.END + " 0");
}
else
{
if (!string.IsNullOrEmpty(ptask.PatchStartCmd))
{
output.AddLine(PatchCommand.START + " " + ptask.TaskId + " " + ptask.PatchStartCmd);
}
else
{
output.AddLine(PatchCommand.START + " " + ptask.TaskId);
}
output.AddLine(ptask.LandMark);
int cmdCount = cmds.Count;
for (int n = 0; n < cmdCount; ++n)
{
PatchWriter.WriteCommand(output, cmds[n], true);
}
}
}
output.Save();
}
public void PatchContent()
{
PatchingMsg = null;
//1. check if file is exist
string originalFilename = this.OriginalFileName;
if (!File.Exists(originalFilename))
{
throw new NotSupportedException("file not found!");
}
SourceFile input = new SourceFile(originalFilename, false);
input.ReadAllLines();
SourceFile output = new SourceFile(originalFilename, true);
string patchCode;
if (CheckIfFileWasPatched(input, out patchCode))
{
//can't patch
//throw new NotSupportedException("not patch again in this file");
PatchingMsg = this.OriginalFileName + " => has be patched, so skip this file";
return;
}
else
{
//can patch ****
//input patch code with original filename
output.AddLine(patchCode + " " + originalFilename);
}
output.IsCMakeFile = input.IsCMakeFile;
//-----------------------------------------------------------------
//other patch that is not block-patch
int j = patchTasks.Count;
for (int i = 0; i < j; ++i)
{
PatchTask ptask = patchTasks[i];
if (!ptask.IsPatchBlock)
{
ptask.PatchFile(input, output);
}
else
{
ptask.PatchBlockSouldStartAt = output.LineCount;
}
}
int linecount = input.LineCount;
for (int i = input.CurrentLine; i < linecount; ++i)
{
output.AddLine(input.GetLine(i));
input.CurrentLine++;
}
//-----------------------------------------------------------------
//only block-patch
for (int i = 0; i < j; ++i)
{
PatchTask ptask = patchTasks[i];
if (ptask.IsPatchBlock)
{
int newLineCount = ptask.PatchBlockFile(output);
if (newLineCount == 1)
{
for (int n = i + 1; n < j; ++n)
{
//adjust new offset
PatchTask p2 = patchTasks[n];
if (p2.IsPatchBlock)
{
p2.PatchBlockSouldStartAt += 1;
}
}
}
else
{
System.Diagnostics.Debug.WriteLine("output is not saved: " + ptask.Owner.OriginalFileName);
return;
}
}
}
output.Save();
}
/// <summary>
/// create patch file from a patch file in disk
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
public static PatchFile BuildPatchFile(string filename)
{
//if (filename == "d:\\projects\\CefBridge\\cef3\\cefclient\\browser\\client_handler.cc")
//{
//}
//create patch command for specific filename
PatchFile patchFile = new PatchFile(filename);
SourceFile sourceFile = new SourceFile(filename, false);
sourceFile.ReadAllLines();
int j = sourceFile.LineCount;
PatchTask ptask = null;
int i = 0;
string line = sourceFile.GetLine(0);
//first line is original filename
string originalFilename;
if (GetOriginalFilename(line, out originalFilename))
{
//change origial file name for patch file
patchFile.OriginalFileName = originalFilename;
i++; //next line
}
for (; i < j; ++i)
{
line = sourceFile.GetLine(i).TrimStart();
if (line.StartsWith("//###_"))
{
//what is the comamnd
int pos0 = line.IndexOf(' '); //first (must have
if (pos0 < 0)
{
throw new NotSupportedException("pos 0");
}
else
{
string additionalInfo;
int taskId = GetTaskId(line, pos0 + 1, out additionalInfo);
string cmdline = line.Substring(0, pos0);
switch (cmdline)
{
case PatchCommand.START:
//start new patch task
//read next line for info
{
i++;
string cmd_value = sourceFile.GetLine(i);
//create new task
ptask = new PatchTask(cmd_value, taskId);
patchFile.AddTask(ptask);
}
break;
case PatchCommand.APPPEND_START:
//start collect append string
//until find append_stop
{
var collectAppendStBuilder = new StringBuilder();
i++;
string cmd_value = sourceFile.GetLine(i);
line = cmd_value.TrimStart();
//eval
do
{
if (line.StartsWith(PatchCommand.APPPEND_STOP))
{
//stop here
break;
}
else
{
if (line.StartsWith("//###_"))
{
//other command
throw new NotSupportedException();
}
else
{
//collect this line
collectAppendStBuilder.AppendLine(line);
//read next line
i++;
line = sourceFile.GetLine(i).TrimStart();
}
}
} while (true);
//finish command
ptask.Append(collectAppendStBuilder.ToString());
}
break;
case PatchCommand.APPPEND_STOP:
throw new NotSupportedException();
case PatchCommand.FIND_NEXT_LANDMARK:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.FindNext(cmd_value);
}
break;
case PatchCommand.FOLLOW_BY:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.FollowBy(cmd_value);
}
break;
case PatchCommand.SKIP_UNTIL_AND_ACCEPT:
{
i++;
string cmd_value = sourceFile.GetLine(i);
if (taskId != ptask.TaskId)
{
throw new NotSupportedException();
}
ptask.SkipUntilAndAccept(cmd_value);
}
break;
case PatchCommand.SKIP_UNTIL_PASS:
{
//has 2 parameters
if (additionalInfo == null)
{
throw new NotSupportedException();
}
//
ptask.SkipUntilPass(additionalInfo);
}
break;
default:
throw new NotSupportedException();
}
}
}
}
return((ptask != null && ptask.CommandCount > 0) ? patchFile : null);
}
