public static string func_if(List <string> args)
{
Variable.variable v = null;
if (args[0].StartsWith("UNRESOLVED"))
{
if (args.Count == 2)
{
v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(if " + args[0] + "," + args[1] + ")");
}
else if (args.Count == 3)
{
v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(if " + args[0] + "," + args[1] + "," + args[2] + ")");
}
return(v.name);
}
if (Variable.ExpandString(args[0].Trim()) == "")
{
if (args.Count == 3)
{
// Evaluate else part
return(Variable.ExpandString(args[2].Trim()));
}
return("");
}
else
{
// Evaluate then part
return(Variable.ExpandString(args[1].Trim()));
}
}
public static string func_origin(List <string> args)
{
Variable.variable v = Variable.lookup_variable(args[0]);
if (v == null)
{
return("undefined");
}
switch (v.origin)
{
default:
case Variable.variable_origin.o_invalid:
return("invalid");
case Variable.variable_origin.o_default:
return("default");
case Variable.variable_origin.o_env:
return("environment");
case Variable.variable_origin.o_file:
return("file");
case Variable.variable_origin.o_env_override:
return("environment override");
case Variable.variable_origin.o_command:
return("command line");
case Variable.variable_origin.o_override:
return("override");
case Variable.variable_origin.o_automatic:
return("automatic");
}
}
public static string func_words(List <string> args)
{
if (args[0].StartsWith("UNRESOLVED"))
{
Variable.variable v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(words " + args[0] + ")");
return(v.name);
}
return(ChopString(args[0]).Count.ToString());
}
public static string func_call(List <string> args)
{
if (args.Count == 0)
{
return("");
}
// There is no way to define a variable with a space in the name, so strip leading and trailing whitespace as a favor to the user
string fname = args[0].Trim();
if (fname == "")
{
return("");
}
// Are we invoking a builtin function?
function func = lookup_function(fname);
if (func != null)
{
// How many arguments do we have?
List <string> subargs = new List <string>();
for (int j = 1; j < args.Count; j++)
{
subargs.Add(args[j]);
}
return(expand_builtin_function("", subargs, func));
}
// Not a builtin, so the first argument is the name of a variable to be expanded and interpreted as a function. Find it
Variable.variable v = Variable.lookup_variable(fname);
if (v == null)
{
MessageBox.Show("Undefined Variable in Call '" + fname + "' - (" + (new StackFrame()).GetFileName() + " - " + (new StackFrame()).GetFileLineNumber() + ")");
return("");
}
if (v.value == "")
{
return("");
}
// Set up arguments $(1) .. $(N). $(0) is the function name
for (int i = 0; i < args.Count; i++)
{
Variable.define_variable_in_set(i.ToString(), args[i], Variable.variable_origin.o_automatic, false, Variable.current_variable_set_list);
}
// Expand the body in the context of the arguments, adding the result to the variable buffer
string result = Variable.ExpandString("$(" + fname + ")");
for (int i = 0; i < args.Count; i++)
{
Variable.undefine_variable(i.ToString(), null);
}
return(result);
}
public static string func_value(List <string> args)
{
Variable.variable v = Variable.lookup_variable(args[0]);
if (v == null)
{
return("");
}
else
{
return(v.value);
}
}
public static string func_lastword(List <string> args)
{
List <string> strs = ChopString(args[0]);
if (strs[strs.Count - 1].StartsWith("UNRESOLVED"))
{
Variable.variable v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(lastword " + strs[strs.Count - 1] + ")");
return(v.name);
}
else
{
return(strs[strs.Count - 1]);
}
}
public static string func_flavor(List <string> args)
{
Variable.variable v = Variable.lookup_variable(args[0]);
if (v == null)
{
return("undefined");
}
if (v.flavor == Variable.variable_flavor.f_recursive)
{
return("recursive");
}
else
{
return("simple");
}
}
public static string func_foreach(List <string> args)
{
string varname = Variable.ExpandString(args[0]);
List <string> list = ChopString(Variable.ExpandString(args[1]));
string body = args[2];
/*
* foreach(string item in list)
* {
* if(item.StartsWith("UNRESOLVED"))
* {
* Variable.variable v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(foreach " + args[0] + "," + args[1] + "," + args[2] + ")", null);
* return v.name;
* }
* }
*/
string result = "";
Variable.variable saveVar = Variable.lookup_variable(varname);
if (saveVar != null)
{
Variable.undefine_variable(varname, null);
}
Variable.variable var = Variable.define_variable_in_set(varname, "", Variable.variable_origin.o_automatic, false, Variable.current_variable_set_list);
for (int i = 0; i < list.Count; i++)
{
var.value = list[i];
result += Variable.ExpandString(body);
if (i < list.Count - 1)
{
result += " ";
}
}
Variable.undefine_variable(varname, null);
if (saveVar != null)
{
Variable.current_variable_set_list.Add(saveVar.name, saveVar);
}
return(result);
}
public static string func_abspath(List <string> args)
{
List <string> strs = ChopString(args[0]);
string result = "";
for (int i = 0; i < strs.Count; i++)
{
if (strs[i].StartsWith("UNRESOLVED"))
{
Variable.variable v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(abspath " + strs[i] + ")");
result += v.name;
}
else
{
result += strs[i].Replace(".", "").Replace("//", "/");
}
if (i < strs.Count - 1)
{
result += " ";
}
}
return(result);
}
public static void ParseMakeFile()
{
Form1.makefileTextControl.Text = "";
Form1.makefileReader = new StreamReader(Form1.makefileName);
int ignoring = 0;
int in_ignored_define = 0;
List <string> filenames = new List <string>(); // nameseq
List <string> targets = new List <string>();
List <string> prerequisites = new List <string>();
while (true)
{
string line = "";
int wlen;
string p = "";
string p2 = "";
vmodifiers vmod = new vmodifiers();
// If line is equal to null, then we are done parsing!
if ((line = ReadLine()) == "")
{
break;
}
if (line[0] == TAB_CHAR) // This is a start of a recipe line
{
foreach (string target in targets)
{
Form1.rules[target].recipe += Variable.ExpandRecipeString(line.Substring(1), Form1.rules[target]);
}
Form1.UpdateRulesTree();
continue;
}
// See if this is a variable assignment. We need to do this early, to allow variables with names like 'ifdef', 'export', 'private', etc.
p = parse_var_assignment(line, ref vmod);
if (vmod.assign_v)
{
Variable.variable v = new Variable.variable();
Variable.variable_origin origin = vmod.override_v? Variable.variable_origin.o_override : Variable.variable_origin.o_file;
// If we're ignoring then we're done now.
if (ignoring == 1)
{
in_ignored_define = 1;
continue;
}
if (vmod.undefine_v)
{
do_undefine(p, origin);
continue;
}
else if (vmod.define_v)
{
v = do_define(p, origin);
}
else
{
v = Variable.try_variable_definition(p, origin, 0);
}
if (v == null)
{
MessageBox.Show("Variable at line(" + LINENO + ") should not be NULL");
}
if (vmod.export_v)
{
v.export = Variable.variable_export.v_export;
}
if (vmod.private_v)
{
v.private_var = true;
}
// This line has been dealt with.
continue;
}
// If this line is completely empty, ignore it.
if (p.Length == 0)
{
continue;
}
p2 = Utils.end_of_token(p);
wlen = p.IndexOf(p2);
p2 = Utils.next_token(p2);
// If we're in an ignored define, skip this line (but maybe get out).
if (in_ignored_define == 1)
{
// See if this is an endef line (plus optional comment).
if (p.Equals("endef") && (p2.Length == 0 || p2[0] == '#'))
{
in_ignored_define = 0;
}
continue;
}
if (line.StartsWith("ifeq") || line.StartsWith("ifneq") || line.StartsWith("ifdef") || line.StartsWith("ifndef"))
{
IF_COUNTS++;
}
// Check for conditional state changes.
/*{
* int i = conditional_line(p, wlen, fstart);
* if (i != -2)
* {
* if (i == -1)
* MessageBox.Show("Invalid syntax in conditional - (" + (new StackFrame()).GetFileName() + " - " + (new StackFrame()).GetFileLineNumber() + ")");
*
* ignoring = i;
* continue;
* }
* }*/
// Manage the "export" keyword used outside of variable assignment as well as "unexport".
if (p.StartsWith("export") || p.StartsWith("unexport"))
{
bool exporting = p[0] == 'u';
// (un)export by itself causes everything to be (un)exported.
if (p2.Length == 0)
{
export_all_variables = exporting;
}
else
{
string cp = "";
string ap = "";
// Expand the line so we can use indirect and constructed variable names in an (un)export command.
cp = ap = Variable.ExpandString(p2);
for (p = Utils.find_next_token(ref cp); p != null; p = Utils.find_next_token(ref cp))
{
if (cp != "")
{
p = p.Substring(0, p.IndexOf(cp));
}
Variable.variable v = Variable.lookup_variable(p);
if (v == null)
{
v = Variable.do_variable_definition(p, "", Variable.variable_origin.o_file, 0, 0);
}
v.export = exporting ? Variable.variable_export.v_export : Variable.variable_export.v_noexport;
}
}
continue;
}
// Handle the special syntax for vpath.
if (p.StartsWith("vpath"))
{
string cp = "";
string vpat = "";
cp = Variable.ExpandString(p2);
p = Utils.find_next_token(ref cp);
if (p != null)
{
if (cp != "")
{
vpat = p.Substring(0, p.IndexOf(cp));
}
p = Utils.find_next_token(ref cp);
// No searchpath means remove all previous selective VPATH's with the same pattern.
}
else
{
// No pattern means remove all previous selective VPATH's.
vpat = "";
}
//construct_vpath_list(vpat, p);
continue;
}
// Handle include and variants.
if (p.StartsWith("include") || p.StartsWith("-include") || p.StartsWith("sinclude"))
{
// "-include" (vs "include") says no error if the file does not exist. "sinclude" is an alias for this from SGI.
bool noerror = p[0] != 'i';
p = Variable.ExpandString(p2);
// If no filenames, it's a no-op.
if (p == null || p == "")
{
continue;
}
// Parse the list of file names. Don't expand archive references!
List <string> files = Utils.ChopString(p);
// Read each included makefile.
foreach (string file in files)
{
Form1.Includes.Add("[INCLUDE]" + file);
}
continue;
}
string expandedLine = Variable.ExpandString(line);
int colonIndex = expandedLine.IndexOf(':');
if (colonIndex >= 0)
{
bool singleColon = false;
if (colonIndex == expandedLine.Length - 1)
{
singleColon = true;
}
else
{
if (expandedLine[colonIndex + 1] == ':')
{
singleColon = false;
}
else
{
singleColon = true;
}
}
int semiColonIndex = expandedLine.IndexOf(';', colonIndex);
targets = Utils.ChopString(expandedLine.Substring(0, colonIndex));
if (semiColonIndex >= 0)
{
prerequisites = Utils.ChopString(expandedLine.Substring(singleColon ? colonIndex + 1 : colonIndex + 2, semiColonIndex - (singleColon ? colonIndex + 1 : colonIndex + 2)));
}
else
{
prerequisites = Utils.ChopString(expandedLine.Substring(singleColon ? colonIndex + 1 : colonIndex + 2));
}
if (singleColon) // Single-Coloned rules are combined with other -if any-
{
foreach (string target in targets)
{
Rule rule;
if (Form1.rules.ContainsKey(target))
{
rule = Form1.rules[target];
}
else
{
rule = new Rule();
rule.target = target;
rule.singleColon = true;
rule.lineno = LINENO;
Form1.rules.Add(rule.target, rule);
}
foreach (string prerequisite in prerequisites)
{
rule.prerequisites.Add(prerequisite);
}
if (semiColonIndex >= 0)
{
rule.recipe = expandedLine.Substring(semiColonIndex + 1);
}
}
}
else // Double-Coloned rules are added directly to SDG
{
List <string> doubleColonTargets = new List <string>();
foreach (string target in targets)
{
Rule rule = new Rule();
rule.target = Utils.GetTargerName(target);
doubleColonTargets.Add(rule.target);
rule.singleColon = false;
Form1.rules.Add(rule.target, rule);
foreach (string prerequisite in prerequisites)
{
rule.prerequisites.Add(prerequisite);
}
if (semiColonIndex >= 0)
{
rule.recipe = expandedLine.Substring(semiColonIndex + 1);
}
}
targets.Clear();
foreach (string target in doubleColonTargets)
{
targets.Add(target);
}
}
Form1.UpdateRulesTree();
continue;
}
}
}
public static string func_wildcard(List <string> args)
{
Variable.variable v = Variable.define_unresolved_variable(Utils.GetUnresolvedName(), "$(wildcard " + args[0] + ")");
return(v.name);
}
