/// <summary>
/// Constructor, which creates a clone of a particular var.
/// </summary>
/// <param name="bParam">Var to clone.</param>
public Base(Base bParam)
{
Clear();
name = bParam.name;
use = bParam.use;
lg = bParam.lg;
db = bParam.db;
str = bParam.str;
}
/// <summary>
/// Method, processing simple sequence - A <+,-,*,/> B
/// </summary>
/// <param name="sParam">Sequence</param>
/// <param name="fFunc">Func class instance</param>
/// <returns>Result of the sequence.</returns>
private string processSimpleSeq(string sParam, Func fFunc)
{
if (sParam.IndexOf('+') > -1)
{
string[] sSeqParams = sParam.Split('+');
Base a = new Base();
a.SetUntyped(sSeqParams[0].Trim());
Base b = new Base();
b.SetUntyped(sSeqParams[1].Trim());
Base c = a + b;
return c.Get();
}
else
if (sParam.IndexOf('-') > -1)
{
string[] sSeqParams = sParam.Split('-');
Base a = new Base();
a.SetUntyped(sSeqParams[0].Trim());
Base b = new Base();
b.SetUntyped(sSeqParams[1].Trim());
Base c = a - b;
return c.Get();
}
else
if (sParam.IndexOf('*') > -1)
{
string[] sSeqParams = sParam.Split('*');
Base a = new Base();
a.SetUntyped(sSeqParams[0].Trim());
Base b = new Base();
b.SetUntyped(sSeqParams[1].Trim());
Base c = a * b;
return c.Get();
}
else
if (sParam.IndexOf('/') > -1)
{
string[] sSeqParams = sParam.Split('/');
Base a = new Base();
a.SetUntyped(sSeqParams[0].Trim());
Base b = new Base();
b.SetUntyped(sSeqParams[1].Trim());
Base c = a / b;
return c.Get();
}
else return sParam;
}
/// <summary>
/// This method executes one line of code.
/// </summary>
/// <param name="cmd">The name of command to execute.</param>
/// <param name="param">Parameters for this command</param>
/// <param name="fFunc">The instance of Func class, which is currently running.</param>
/// <returns>String, which is the result of executing this cmd. </returns>
public string execCmd(string cmd, string param, Func fFunc)
{
///Here will be (switch), which will run functions for standart cmd signatures
try
{
if (bStartBreaking) { return ""; }
if ((cmd!="=")&&(cmd!="#in")) ///if we have cmd, that is not changing vars - then process them = change to thier values
{
param=processVars(param,fFunc);
}
switch (cmd.ToLower())
{
case "#outstream":
param = processVars(param, fFunc);
fFunc.sOutput = param.Trim();
return "";
case "#instream":
param = processVars(param, fFunc);
fFunc.sInput = param.Trim();
return "";
case "#temp": // this cmd is used only for testing some features, i.e. processing simple seq.
param = processSimpleSeq(param, fFunc);
frRun1.textBox2.Text += param;
frRun1.textBox2.Refresh();
return "";
case "#in":
string ret = "";
string varName = param.Split(' ')[0];
if (fFunc.sInput.ToLower() == "console")
{
ret = frRun1.gettext();
}
else
{
FileStream FS = new FileStream(fFunc.sInput, FileMode.OpenOrCreate);
StreamReader SR = new StreamReader(FS);
ret = SR.ReadToEnd();
SR.Close();
FS.Close();
}
if (varName.IndexOf('@') == 0) //local var
{
fFunc.setVar(new Base(varName, ret));
}
else
if (varName.IndexOf('&') == 0) //global var
{
fFunc.setGlVar(new Base(varName, ret));
}
return "";
case "=":
string var1Name = param.Split(' ')[0];
param = param.Substring(var1Name.Length + 1);
param = processVars(param, fFunc);
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2], fFunc);
}
param = param.Trim();
if (param[0] == '(' && param[param.Length - 1] == ')')
{
param = processBlanks(param, fFunc);
param = processVars(param, fFunc);
param = processComplicatedSeq(param);
}
long lg;
double db;
Base b;
if (long.TryParse(param,out lg))
{
b = new Base(var1Name, lg);
}
else
if (double.TryParse(param, out db))
{
b = new Base(var1Name, db);
}
else
{
b = new Base(var1Name, param);
}
if (var1Name.IndexOf('@') == 0)
{
fFunc.setVar(b);
}
else
if (var1Name.IndexOf('&') == 0)
{
fFunc.setGlVar(b);
}
return "";
case "#function":
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2],fFunc);
}
string funcPath = param.Split(' ')[0];
param = param.Substring(param.IndexOf(' ') + 1);
string fullPath="";
if (path.Trim() != "")
{
if (File.Exists(Path.GetDirectoryName(path) + "\\" + funcPath + ".ps"))
{
fullPath = Path.GetDirectoryName(path) + "\\" + funcPath + ".ps";
}
}
if (fullPath=="")
if (File.Exists(Path.GetDirectoryName(Application.ExecutablePath) + "\\" + funcPath + ".ps"))
{
fullPath = Path.GetDirectoryName(Application.ExecutablePath) + "\\" + funcPath + ".ps";
}
if (fullPath!="")
{
FileStream FS = new FileStream(fullPath, FileMode.OpenOrCreate);
StreamReader SR = new StreamReader(FS);
string funcSource = SR.ReadToEnd();
SR.Close();
FS.Close();
Func fnAdditional = new Func(funcSource, param);
string sReturn = fnAdditional.Run(this);
return sReturn;
}
else
return "Error while launching function " + funcPath;
case "#random":///random a b
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2], fFunc);
}
Random rnd = new Random(DateTime.Now.Millisecond);
string[] par = param.Split(' ');
string ans = rnd.Next(Int32.Parse(par[0]), Int32.Parse(par[1])).ToString();
param = param.Substring(par[0].Length + 1 + par[1].Length);
param.Trim();
return ans + param;
case "#out":
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2],fFunc);
}
///DELETE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (param[0] == '(' && param[param.Length - 1] == ')')
{
param = processBlanks(param, fFunc);
param = processVars(param, fFunc);
param = processComplicatedSeq(param);
}
param = param.Replace("\\n", "\r\n");
param = param.Replace("==", "=");
if (fFunc.sOutput.ToLower() == "console")
{
frRun1.textBox2.Text += param;
frRun1.textBox2.Refresh();
}
else
{
FileStream FS = new FileStream(fFunc.sOutput.Trim(), FileMode.OpenOrCreate);
StreamWriter SW = new StreamWriter(FS);
SW.Write(param);
SW.Close();
FS.Close();
}
return "";
case "#time":
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2], fFunc);
}
return DateTime.Now.TimeOfDay + " " + param;
case "#sleep":
System.Threading.Thread.Sleep(Int32.Parse(param));
return "";
case "#clear": // this command use for clear program - window
frRun1.textBox2.Clear();
return "";
case "#return":
if (isCmd(param))
{
string[] sCmdPar = extractCmdParam(param);
param = sCmdPar[0] + execCmd(sCmdPar[1], sCmdPar[2], fFunc);
}
return param;
default:
return execCmd("#function", cmd.Remove(0,1) + " " + param, fFunc);
// return "Err";
}
}
catch
{
return "Parse_Error! Unknown command!";
}
}
/// <summary>
/// This method sets all brackets needed in this seq.
/// </summary>
/// <param name="sParam">Unparsed seq.</param>
/// <returns>Seq. with brackets.</returns>
private string CountExpression(string sParam)
{
///Here will be your code
int i1, i2;
bool flag = true;
List<string> sParams = new List<string>(); // Use List , not string[], because we need to delete some elements and insert some new
for (i1 = 0 , i2 = 0; i2 < sParam.Length; i2++)
{
if (sParam[i2] == '*' || sParam[i2] == '/' || sParam[i2] == '+' || sParam[i2] == '-')
{
sParams.Add(sParam.Substring(i1,i2-i1));
i1 = i2 + 1;
sParams.Add(sParam[i2].ToString());
}
}
sParams.Add(sParam.Substring(i1));
Base a = new Base();
Base b = new Base();
Base c;
while (flag)
{
flag = false;
for (int i = 0; i < sParams.Count; i++)
{
if (sParams[i] == "*" || sParams[i] == "/") // In First we find all operations * ans / and count them
{
a.SetUntyped(sParams[i - 1]);
b.SetUntyped(sParams[i + 1]);
switch (sParams[i])
{
case "*":
c = a * b;
break;
case "/":
c = a / b;
break;
default:
c = new Base();
break;
}
sParams.RemoveAt(i - 1);
sParams.RemoveAt(i);
sParams[i - 1] = c.Get();
flag = true;
break;
}
}
}
while (sParams.Count != 1)
{
for (int i = 0; i < sParams.Count; i++) // After we work with + and -
{
if (sParams[i] == "+" || sParams[i] == "-")
{
a.SetUntyped(sParams[i - 1]);
b.SetUntyped(sParams[i + 1]);
switch (sParams[i])
{
case "+":
c = a + b;
break;
case "-":
c = a - b;
break;
default:
c = new Base();
break;
}
sParams.RemoveAt(i - 1);
sParams.RemoveAt(i);
sParams[i - 1] = c.Get();
break;
}
}
}
return sParams[0];
}
/// <summary>
/// This method process some logical sequence and returns result - is it true or false.
/// </summary>
/// <param name="sParam">Some sequence</param>
/// <param name="fFunc">Func class instance</param>
/// <returns>Is this seq. true or false.</returns>
public bool processLogicalSeq(string sParam, Func fFunc)
{
bool answer = false;
string[] logicalMarks = new string[6] { "<=", ">=", "==", "!=", "<", ">"};
string[] sParams = sParam.Split(logicalMarks, StringSplitOptions.None);
if (sParams.Length != 1)
{
string usedLogic = sParam.Substring(sParams[0].Length, sParam.Length - sParams[0].Length - sParams[1].Length).Trim();
sParams[0] = processComplicatedSeq(processVars(sParams[0].Trim(), fFunc));
sParams[1] = processComplicatedSeq(processVars(sParams[1].Trim(), fFunc));
if (!bStartBreaking)
{
Base a = new Base();
a.SetUntyped(sParams[0]);
Base b = new Base();
b.SetUntyped(sParams[1]);
switch (usedLogic)
{
case "<":
answer = (a < b);
break;
case ">":
answer = (a > b);
break;
case "<=":
answer = (a <= b);
break;
case ">=":
answer = (a >= b);
break;
case "!=":
answer = (a != b);
break;
case "==":
answer = (a == b);
break;
}
}
else
switch (sParams[0][0])
{
case '@':
try
{
answer = Convert.ToBoolean(fFunc.getVar(sParams[0].Trim()));
}
catch
{
answer = false;
}
break;
case '&':
try
{
answer = Convert.ToBoolean(fFunc.getGlVar(sParams[0].Trim()));
}
catch
{
answer = false;
}
break;
default:
break;
}
}
return answer;
}
/// <summary>
/// Makes a copy of param var and adds it to the List.
/// </summary>
/// <param name="param">Base-type variable.</param>
private void addVar(Base param)
{
if (varExists(param.name) == -1)
{
vrb.Add(new Base(param));
}
}
/// <summary>
/// Sets the value of param to var from the list, which name is equal to param's name.
/// If such var in list doesn't exists - it is added.
/// </summary>
/// <param name="param">Base-type variable</param>
public void setVar(Base param)
{
int nNum = varExists(param.name);
if (nNum == -1) { addVar(param); }
else vrb[nNum].Set(param);
}
/// <summary>
/// Makes a copy of param global var and adds it to the List.
/// </summary>
/// <param name="param">Base-type variable.</param>
private void addGlVar(Base param)
{
if (varGlExists(param.name) == -1)
{
globalVrb.Add(new Base(param));
}
}
/// <summary>
/// Sets the value of param to global var from the list, which name is equal to param's name.
/// If such var in list doesn't exists - it is added.
/// </summary>
/// <param name="param">Base-type variable</param>
public void setGlVar(Base param)
{
int nNum = varGlExists(param.name);
if (nNum == -1) { addGlVar(param); }
else globalVrb[nNum].Set(param);
}
/// <summary>
/// Sets a value to the var by copying it form another var.
/// </summary>
/// <param name="bParam">Base var to get value from.</param>
public void Set(Base bParam)
{
str = bParam.str;
lg = bParam.lg;
db = bParam.db;
use = bParam.use;
}
public static Base operator /(Base a, Base b)
{
Base c = new Base();
if (a.use == b.use)
{
if (a.use == "Long")
c.lg = a.lg + b.lg;
if (a.use == "Double")
c.db = a.db + b.db;
//a.str /= b.str;
c.use = a.use;
}
return c;
}
public static Base operator -(Base a, Base b)
{
Base c = new Base();
if (a.use == b.use)
{
c.lg = a.lg - b.lg;
c.db = a.db - b.db;
c.use = a.use;
/*while (a.str.IndexOf(b.str) != -1)
{
a.str.Remove(a.str.IndexOf(b.str), a.str.IndexOf(b.str) + b.str.Length);
}*/
}
return c;
}
public static Base operator +(Base a, Base b)
{
Base c = new Base();
if (a.use == b.use)
{
c.lg = a.lg + b.lg;
c.db = a.db + b.db;
c.str= a.str + b.str;
c.use = a.use;
}
return c;
}
