public static string GenerateMakeCommands(CoG cog, string specName, SpecVars SV, string target)
{
StringBuilder SB = new StringBuilder();
SB.AppendLine("");
SB.AppendLine("cd " + specName);
if (IsUnix())
{
SB.AppendLine("make" + target);
SB.AppendLine("if [ $? -eq 0 ]; ");
SB.AppendLine("then");
SB.AppendLine("echo \"build ok\"");
SB.AppendLine("else");
SB.AppendLine("\texit $?");
SB.AppendLine("fi");
}
else
{
SB.AppendLine("nmake" + target);
SB.AppendLine("if not %errorlevel%==0 goto :error");
}
SB.AppendLine("cd ..");
return(SB.ToString());
}
public static string GenerateDoxygenCommands(CoG cog, string specName, SpecVars SV)
{
StringBuilder SB = new StringBuilder();
SB.AppendLine("");
SB.AppendLine("cd " + specName);
SB.AppendLine("echo \"Running doxygen for " + specName + " \"");
SB.AppendLine("doxygen");
SB.AppendLine("cd ..");
return(SB.ToString());
}
/// <summary>
/// Varies the random generator (built-in, Mersenne Twister)
/// </summary>
/// <param name="mvNames">List of variations on the random generator.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryRandomGenerator(List <string> randomGenerators)
{
List <SpecVars> list = new List <SpecVars>();
foreach (string g in randomGenerators)
{
SpecVars V = this.Clone();
V.RandomGenerator = g;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the dimension of 'this'.
/// </summary>
/// <param name="dimensions">List of variations on the dimension.</param>
/// <returns>a list of variations.</returns>
public List <SpecVars> VaryDimension(List <int> dimensions)
{
List <SpecVars> list = new List <SpecVars>();
foreach (int dim in dimensions)
{
SpecVars V = this.Clone();
V.Dimension = dim;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies whether to report usage of converted SMV in GMV functions.
/// </summary>
/// <param name="reportUsage">List of variations on inlining.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryReportUsage(List <bool> reportUsage)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool bip in reportUsage)
{
SpecVars V = this.Clone();
V.ReportUsage = bip;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies whether to inline code.
/// </summary>
/// <param name="doInline">List of variations on inlining.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryInline(List <bool> doInline)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool bip in doInline)
{
SpecVars V = this.Clone();
V.Inline = bip;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the way GMV memory is allocate (pp, full, dynamic)
/// </summary>
/// <param name="mvNames">List of variations on the memory allocation for GMVs.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryGmvMemAlloc(List <G25.GMV.MEM_ALLOC_METHOD> gmvMemAlloc)
{
List <SpecVars> list = new List <SpecVars>();
foreach (G25.GMV.MEM_ALLOC_METHOD a in gmvMemAlloc)
{
SpecVars V = this.Clone();
V.GmvMemAlloc = a;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the scalar name of 'this'.
/// </summary>
/// <param name="scalarNames">List of variations on the name of the scalar type.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryScalarNames(List <string> scalarNames)
{
List <SpecVars> list = new List <SpecVars>();
foreach (string name in scalarNames)
{
SpecVars V = this.Clone();
V.ScalarName = name;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the way GMV code is generated (runtime, or expand).
/// </summary>
/// <param name="mvNames">List of variations on the code generation for GMVs.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryGmvCode(List <G25.GMV_CODE> gmvCode)
{
List <SpecVars> list = new List <SpecVars>();
foreach (G25.GMV_CODE c in gmvCode)
{
SpecVars V = this.Clone();
V.GmvCode = c;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the parser (builtin or ANTLR) of 'this'.
/// </summary>
/// <param name="useBuiltinParser">List of variations on the parser.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryBuiltInParser(List <bool> useBuiltinParser)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool bip in useBuiltinParser)
{
SpecVars V = this.Clone();
V.BuiltInParser = bip;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the whether to a have a GOM or not.
/// </summary>
/// <param name="haveGOM">List of variations on the GOM yes/no.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryHaveGom(List <bool> haveGom)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool hg in haveGom)
{
SpecVars V = this.Clone();
V.HaveGom = hg;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the grouping method (regular or 'alternative') of 'this'.
/// </summary>
/// <param name="alternativeGrouping">List of variations on the grouping method.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryGroupAlternative(List <bool> alternativeGrouping)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool ac in alternativeGrouping)
{
SpecVars V = this.Clone();
V.GroupAlternative = ac;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the coordinate storage method of 'this'.
/// </summary>
/// <param name="coordStorage">List of variations on the coordinate storage method.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryCoordStorage(List <G25.COORD_STORAGE> coordStorage)
{
List <SpecVars> list = new List <SpecVars>();
foreach (G25.COORD_STORAGE cs in coordStorage)
{
SpecVars V = this.Clone();
V.CoordStorage = cs;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the whether a scalar type is present.
/// </summary>
/// <param name="haveScalar">List of variations on the scalar type.</param>
/// <returns>a list of variations.</returns>
public List <SpecVars> VaryHaveScalarType(List <bool> haveScalar)
{
List <SpecVars> list = new List <SpecVars>();
foreach (bool hs in haveScalar)
{
SpecVars V = this.Clone();
V.HaveScalarType = hs;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the float types.
/// </summary>
/// <param name="reportUsage">List of float types.</param>
/// <returns>Returns a list of variations.</returns>
public List <SpecVars> VaryFloatTypes(List <List <string> > floatTypes)
{
List <SpecVars> list = new List <SpecVars>();
foreach (List <string> FT in floatTypes)
{
SpecVars V = this.Clone();
V.FloatTypes = FT;
list.Add(V);
}
return(list);
}
/// <summary>
/// Varies the output language of 'this'.
/// </summary>
/// <param name="languages">List of variations on the output language.</param>
/// <returns>a list of variations.</returns>
public List <SpecVars> VaryOutputLanguage(List <string> languages)
{
List <SpecVars> list = new List <SpecVars>();
foreach (string lang in languages)
{
SpecVars V = this.Clone();
V.OutputLanguage = lang;
list.Add(V);
}
return(list);
}
public static string GenerateFromVar(CoG cog,
Dictionary <string, List <string> > commands,
string specTemplateName,
string makefileTemplateName,
string specBaseName,
SpecVars SV)
{
GeneratorCount++;
// get name of specification
string specName = specBaseName + "_" + SV.GetShortName();
// get full directory name, create directory
string dirName = System.IO.Path.Combine(OutputDirectory, specName);
try
{
System.IO.Directory.CreateDirectory(dirName);
}
catch (Exception)
{
Console.WriteLine("Warning: this directory is not clean: " + dirName);
}
// get filename of spec, write it
string specFilename = System.IO.Path.Combine(dirName, specName + ".xml");
GenerateSpecFromVar(cog, specTemplateName, specName, specFilename, SV);
// get filename of makefile, write it
string makefileFilename = System.IO.Path.Combine(dirName, "Makefile");
GenerateMakefileFromVar(cog, makefileTemplateName, specName, makefileFilename, specBaseName, SV);
// if myDouble is used, generate it
if (SV.FloatTypes.Contains("myDouble"))
{
string myDoubleFilename = System.IO.Path.Combine(dirName, "my_double.h");
GenerateMyDoubleFromVar(cog, myDoubleFilename, SV);
}
commands[BUILD_CMD].Add(GenerateMakeCommands(cog, specName, SV, ""));
commands[TEST_CMD].Add(GenerateRunCommands(cog, specName, SV));
commands[CLEAN_CMD].Add(GenerateMakeCommands(cog, specName, SV, " clean"));
commands[XML_TEST_CMD].Add(GenerateXmlTestCommands(cog, specName, SV));
commands[DOXYGEN_CMD].Add(GenerateDoxygenCommands(cog, specName, SV));
return(specName);
}
public static void GenerateMyDoubleFromVar(CoG cog, string filename, SpecVars SV)
{
// get name of template
string templateName = "not_set";
if (SV.OutputLanguage == "cpp")
{
templateName = "myDouble_cpp_header";
}
// write template to StringBuilder
StringBuilder SB = new StringBuilder();
cog.EmitTemplate(SB, templateName);
// write template to file
G25.CG.Shared.Util.WriteFile(filename, SB.ToString());
}
public static void GenerateSampleAlgebras(CoG cog, Dictionary <string, List <string> > commands)
{
Console.WriteLine("Generating the sample algebras");
ReduceNbTestsBy = 1;
Shuffle = false;
SpecVars SV = new SpecVars();
SV.HaveGom = true;
SV.Inline = true;
SV.ShortNameLangOnly = true;
List <SpecVars> vars = SV.VaryOutputLanguage(Languages);
GenerateE2gaVariations(cog, commands, vars);
GenerateE3gaVariations(cog, commands, vars);
GenerateP3gaVariations(cog, commands, vars);
GenerateC3gaVariations(cog, commands, vars);
}
public static string GenerateXmlTestCommands(CoG cog, string specName, SpecVars SV)
{
StringBuilder SB = new StringBuilder();
string xmlTestdirName = XML_TEST_CMD;
string fileListName = "g25_file_list.txt";
SB.AppendLine("");
SB.AppendLine("cd " + specName);
SB.AppendLine("g25 -d true -f " + fileListName + " " + specName + ".xml");
SB.AppendLine("mkdir " + xmlTestdirName);
SB.AppendLine("g25 -d true -s " + xmlTestdirName + System.IO.Path.DirectorySeparatorChar + specName + ".xml " + specName + ".xml");
SB.AppendLine("cd " + xmlTestdirName);
SB.AppendLine("g25 -d true -f " + fileListName + " " + specName + ".xml");
SB.AppendLine("g25_diff " + fileListName + " .." + System.IO.Path.DirectorySeparatorChar + fileListName);
if (IsWindows())
{
SB.AppendLine("if not %errorlevel%==0 goto :error");
}
else
{
SB.AppendLine("if [ $? -eq 0 ]; ");
SB.AppendLine("then");
SB.AppendLine("echo \"XML test ok\"");
SB.AppendLine("else");
SB.AppendLine("\texit $?");
SB.AppendLine("fi");
}
SB.AppendLine("cd .."); // leave xmlTestdirName
SB.AppendLine("cd .."); // leave algebra dir
return(SB.ToString());
}
public static string GenerateRunCommands(CoG cog, string specName, SpecVars SV)
{
StringBuilder SB = new StringBuilder();
SB.AppendLine("");
SB.AppendLine("cd " + specName);
SB.AppendLine("echo \"Testing " + specName + " \"");
if (IsUnix())
{
if (SV.OutputLanguage == G25.XML.XML_JAVA)
{
SB.AppendLine("sh ./test.sh");
}
else if (SV.OutputLanguage == G25.XML.XML_CSHARP)
{
SB.AppendLine("mono ./test.exe");
}
else
{
SB.AppendLine("./test");
}
}
else
{
if (SV.OutputLanguage == G25.XML.XML_JAVA)
{
SB.AppendLine("call test.bat");
}
else
{
SB.AppendLine("test.exe");
}
}
SB.AppendLine("cd ..");
return(SB.ToString());
}
public static List <SpecVars> GetVariations(int minDim, int maxDim, bool groupAlternative, string alternativeGmvName, string alternativeScalarName, bool varyGmvCode, bool varyInline, bool varyCoordStorage)
{
List <SpecVars> returnList = new List <SpecVars>();
foreach (string lang in Languages)
{
List <SpecVars> list = new List <SpecVars>();
list.Add(new SpecVars());
// vary output language
list[0].OutputLanguage = lang;
int langMaxDim = (lang == G25.XML.XML_JAVA) ? 10 : maxDim; // limit Java to 10-D due to the 64K method-size limit (doh).
// vary dimension
List <int> dims = new List <int>();
for (int d = minDim; d <= Math.Min(langMaxDim, maxDim); d++)
{
dims.Add(d);
}
list = SpecVars.VaryDimension(list, dims);
// vary scalar type
list = SpecVars.VaryHaveScalarType(list, new List <bool> {
false, true
});
// vary GMV coordinate storage
if (varyCoordStorage)
{
list = SpecVars.VaryCoordStorage(list, new List <G25.COORD_STORAGE> {
G25.COORD_STORAGE.ARRAY, G25.COORD_STORAGE.VARIABLES
});
}
// vary grouping of GMV
if (groupAlternative)
{
list = SpecVars.VaryGroupAlternative(list, new List <bool> {
false, true
});
}
// vary GOM
list = SpecVars.VaryHaveGom(list, new List <bool> {
false, true
});
// vary parser
list = SpecVars.VaryBuiltInParser(list, new List <bool> {
false, true
});
// vary GMV name
if ((alternativeGmvName != null) && (alternativeGmvName.Length > 0))
{
list = SpecVars.VaryGmvNames(list, new List <string> {
"mv", alternativeGmvName
});
}
// vary scalar type name
if ((alternativeScalarName != null) && (alternativeScalarName.Length > 0))
{
list = SpecVars.VaryScalarNames(list, new List <string> {
"scalar", alternativeScalarName
});
}
// vary GMV function coding
if (varyGmvCode)
{
list = SpecVars.VaryGmvCode(list, new List <G25.GMV_CODE> {
G25.GMV_CODE.EXPAND, G25.GMV_CODE.RUNTIME
});
}
// vary GMV function coding
if ((lang == G25.XML.XML_CPP) || (lang == G25.XML.XML_C))
{
list = SpecVars.VaryRandomGenerator(list, new List <string> {
"libc", "mt"
});
}
else
{
list = SpecVars.VaryRandomGenerator(list, new List <string> {
"libc"
});
}
// vary inline, report usage
if ((lang != G25.XML.XML_C) && varyInline)
{
list = SpecVars.VaryInline(list, new List <bool> {
false, true
});
list = SpecVars.VaryReportUsage(list, new List <bool> {
false, true
});
}
// vary GMV memory allocation
List <G25.GMV.MEM_ALLOC_METHOD> AL = new List <G25.GMV.MEM_ALLOC_METHOD> {
G25.GMV.MEM_ALLOC_METHOD.FULL, G25.GMV.MEM_ALLOC_METHOD.PARITY_PURE
};
if (lang != G25.XML.XML_C)
{
AL.Add(G25.GMV.MEM_ALLOC_METHOD.DYNAMIC);
}
list = SpecVars.VaryGmvMemAlloc(list, AL);
// vary floating point types
List <List <string> > FT = null;
if (lang == G25.XML.XML_CPP)
{
if (minDim < 5)
{
FT = new List <List <string> > {
new List <string> {
"float"
},
new List <string> {
"double"
},
new List <string> {
"double", "float", "myDouble"
}
}
}
;
else
{
FT = new List <List <string> > {
new List <string> {
"float"
},
new List <string> {
"myDouble"
},
new List <string> {
"double", "myDouble"
}
}
};
}
else
{
FT = new List <List <string> > {
new List <string> {
"float"
},
new List <string> {
"double"
},
new List <string> {
"double", "float"
}
};
}
list = SpecVars.VaryFloatTypes(list, FT);
returnList.AddRange(list);
}
return(returnList);
}
public static void GenerateMakefileFromVar(CoG cog, string templateName, string specName, string makefileFilename, string algebraName, SpecVars SV)
{
// write template to StringBuilder
StringBuilder SB = new StringBuilder();
cog.EmitTemplate(SB, templateName,
"SV=", SV,
"SPEC_NAME=", specName,
"ALGEBRA_NAME=", algebraName,
"WINDOWS=", IsWindows(),
"MACOSX=", GetPlatformID() == PlatformID.MacOSX,
"LINUX=", GetPlatformID() == PlatformID.Unix
);
// write template to file
G25.CG.Shared.Util.WriteFile(makefileFilename, SB.ToString());
}
public static void GenerateSpecFromVar(CoG cog, string templateName, string specName, string specFilename, SpecVars SV)
{
// write template to StringBuilder
StringBuilder SB = new StringBuilder();
cog.EmitTemplate(SB, templateName, "SV=", SV);
// write template to file
G25.CG.Shared.Util.WriteFile(specFilename, SB.ToString());
}