public override string Evaluate(Context context)
{
using (StreamReader reader = new StreamReader(Path.GetFullPath(ParseUtilites.GetPathForIncludeParse(PathToFile))))
{
return(reader.ReadToEnd());
}
}
public static void Register(TableOfMacros table, string fileData)
{
try
{
RegisterWitoutBuilding(table, fileData);
for (int position = 0; position < fileData.Length; ++position)
{
if (fileData[position] == StaticData.MacroSeparator)
{
string macrosName = ParseUtilites.GetMacrosNameInPosition(fileData, position);
if (macrosName == "#macro")
{
string macrosData = ParseUtilites.GetMacrossData(fileData, position);
string userDefinedMacrossName = StaticData.MacroSeparator +
ParseUtilites.SplitAvoidingRedundantCharacters(macrosData)[0
];
MainCompositeView cv = new MainCompositeView(fileData);
cv.StartPositionInFile = position;
int startOfMacroData =
ParseUtilites.GetMacrosCloseBracketPosAfterMacroSep(fileData, position) + 1;
Visitor v = new BuildCompositeVisitor(fileData, table, startOfMacroData);
cv.Accept(v);
position = cv.EndPositionInFile + "#end".Length;
((UserDefinedMacross)table.Get(userDefinedMacrossName)).CompositeView = cv;
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error while building table of macros!");
Console.WriteLine("Error message: {0}", ex.Message);
}
}
public override void Visit(CompositeConstruction comCon)
{
int position = currentPosition;
for (; position < fileData.Length; ++position)
{
if (fileData[position] != StaticData.MacroSeparator)
{
continue;
}
string macrosName = ParseUtilites.GetMacrosNameInPosition(fileData, position);
if (!table.Contains(macrosName))
{
continue;
}
if (macrosName != "#end")
{
HandleConstructionAtPosition(comCon, macrosName, ref position);
}
else
{
HandleEndConstructionAtPosition(comCon, position);
return;
}
}
if (currentPosition < fileData.Length)
{
comCon.AddUnit(
new StaticText(comCon, fileData.Substring(currentPosition)));
}
}
public override void Visit(ElseConstruction elseCon, IfConstruction ifCon)
{
for (int position = currentPosition; position < fileData.Length && ifCon.Stop; ++position)
{
if (fileData[position] == StaticData.MacroSeparator)
{
string macrosName = ParseUtilites.GetMacrosNameInPosition(fileData, position);
if (table.Contains(macrosName))
{
if (macrosName == "#else" || macrosName == "#elseif")
{
HandleEndOfElseConstruction(elseCon, position);
HandleElseConstructionAtPosition(ifCon, macrosName, ref position);
}
else if (macrosName == "#end")
{
HandleEndConstructionAtPosition(elseCon, position);
elseCon.SetFatherStop();
return;
}
else
{
HandleConstructionAtPosition(elseCon, macrosName, ref position);
}
}
}
}
}
private static void ParseConfigurationFile()
{
string fileData;
using (var stream = new StreamReader(PagesInfo.ConfigFile))
{
fileData = stream.ReadToEnd();
}
string rootToPreloaded;
string[] preloadedFileNames;
ParseUtilites.ParseConfigFile(fileData, out rootToPreloaded, out preloadedFileNames);
RootToPreloaded = rootToPreloaded;
PreloadedFileNames = preloadedFileNames;
ParsePreloadedFiles();
}
private void HandleConstructionAtPosition(CompositeConstruction comCon, string name, ref int position)
{
Macross currentMacros = table.Get(name);
if (currentMacros.Name == "break")
{
comCon.AddUnit(
new StaticText(comCon, fileData.Substring(currentPosition, position - currentPosition)));
TextUnit comp = new BreakConstruction(comCon, fileData);
comCon.AddUnit(comp);
currentPosition = position + name.Length;
position = currentPosition;
return;
}
int macrosDataEndPos = ParseUtilites.GetMacrosCloseBracketPosAfterMacroSep(fileData, position);
string macrosData = ParseUtilites.GetMacrossData(fileData, position, macrosDataEndPos);
comCon.AddUnit(
new StaticText(comCon, fileData.Substring(currentPosition, position - currentPosition)));
if (currentMacros.IsCompositeMacross() && currentMacros.Name != "#elseif" && currentMacros.Name != "#else")
{
currentPosition = macrosDataEndPos + 1;
TextUnit compositePart = PredefinedMacros.GetMacro(comCon, name, fileData, macrosData);
comCon.AddUnit(compositePart);
CompositeConstruction comp = (CompositeConstruction)compositePart;
comp.StartPositionInFile = position;
comp.Accept(this);
position = currentPosition;
}
else
{
currentPosition = macrosDataEndPos + 1;
if (currentMacros is UserDefinedMacross)
{
UserDefinedMacross userDefined = (UserDefinedMacross)currentMacros;
TextUnit comp = new UserDefinedMacrosConstruction(comCon, userDefined, fileData, macrosData);
comCon.AddUnit(comp);
position = currentPosition;
}
else
{
TextUnit comp = PredefinedMacros.GetMacro(comCon, name, fileData, macrosData);
comCon.AddUnit(comp);
position = currentPosition;
}
}
}
public override string Evaluate(Context context)
{
StringBuilder builder = new StringBuilder(TextData);
List <string> valuesToReplace = new List <string>();
int startingPosition = 0;
int positionOfVariable;
while ((positionOfVariable = TextData.IndexOf(StaticData.VariableSeparator, startingPosition)) != -1)
{
startingPosition = ParseUtilites.GetEndOfVariableAtPosition(TextData, positionOfVariable + 1);
valuesToReplace.Add(TextData.Substring(positionOfVariable + 1, startingPosition - positionOfVariable));
}
foreach (var val in valuesToReplace.Where(context.Contains))
{
builder.Replace(StaticData.VariableSeparator + val, context.GetValue(val).ToString());
}
return(builder.ToString());
}
private static void RegisterWitoutBuilding(TableOfMacros table, string fileData)
{
int positionOfMacros = 0;
int searchAfter = 0;
while ((positionOfMacros = fileData.IndexOf("#macro", searchAfter, StringComparison.Ordinal)) != -1)
{
string macrosData = ParseUtilites.GetMacrossData(fileData, positionOfMacros);
List <string> split = new List <string>(ParseUtilites.SplitAvoidingRedundantCharacters(macrosData));
string macrosName = StaticData.MacroSeparator + split[0];
if (table.Contains(macrosName))
{
throw new Exception("MacroDefinitionAlreadyExists!");
}
split.RemoveAt(0);
Macross macrossToAdd = new UserDefinedMacross(macrosName, split);
table.Add(macrosName, macrossToAdd);
searchAfter = positionOfMacros + 1;
}
}
public override string Evaluate(Context context)
{
StringBuilder res = new StringBuilder();
object[] args = ParseUtilites.ParseArgumentsOfMacro(arguments, context);
string[] names = actualMacross.ArgumentsNames.ToArray();
for (int i = 0; i < names.Length; ++i)
{
names[i] = names[i].Remove(0, 1);
}
for (int i = 0; i < args.Length; ++i)
{
context.AddNewValue(names[i], args[i]);
}
res.Append(actualMacross.CompositeView.Evaluate(context));
for (int i = 0; i < args.Length; ++i)
{
context.DeleteValue(names[i]);
}
return(res.ToString());
}
private void HandleElseConstructionAtPosition(IfConstruction ifCon, string name, ref int position)
{
ifCon.AddUnit(
new StaticText(ifCon, fileData.Substring(currentPosition, position - currentPosition)));
string macrosData = null;
if (name == "#elseif")
{
int macrosDataEndPos = ParseUtilites.GetMacrosCloseBracketPosAfterMacroSep(fileData, position);
macrosData = ParseUtilites.GetMacrossData(fileData, position, macrosDataEndPos);
currentPosition = macrosDataEndPos + 1;
}
else
{
currentPosition = currentPosition + "#else".Length;
}
ElseConstruction compositePart = (ElseConstruction)PredefinedMacros.GetMacro(ifCon, name, fileData, macrosData);
compositePart.SetFatherIfConstruction(ifCon);
ifCon.AddElseConstruction(compositePart);
compositePart.StartPositionInFile = position;
compositePart.Accept(this);
position = currentPosition;
}
public override string Evaluate(Context context)
{
string[] arguments = ParseUtilites.SplitForSet(NewVariable);
context.AddNewValue(arguments[0], ParseUtilites.ParseArgument(arguments[1], context));
return("");
}
public override string Evaluate(Context context)
{
string path = ParseUtilites.GetPathForIncludeParse(FilePath);
return(MacroEngine.Merge(path, new Context()));
}
