Материалы представленные на сайте исключительно с целью ознакомления пользователям Интернета и не преследуют коммерческих целей или нарушение авторских прав.
© 2018 - 2024
Как уже было сказано выше, класс Facade является посредником между двумя основными подсистемами – графическим интерфейсом пользователя и логикой работы интерпретатора. Здесь использован паттерн Facade. Все обращения извне к классам пространства имен interpr.logic производятся через вызов методов класса Facade. Сама же подсистема логики работы интерпретатора не хранит ссылок, как это требует данный паттерн, ни на класс Facade, ни на другие классы, не входящие в нее. Таким образом, класс Facade является как бы мостом между пространством имен interpr.logic и классами, реализующими пользовательский интерфейс.
При запуске интерпретатора в обработчике события Load класса Form1 происходит начальная инициализация приложения. Вначале вызывается статический метод Facade.Create(), которому передается ссылка на элемент управления ConsoleBox, расположенный на главной форме интерпретатора. Тип этого параметра – интерфейс IConsole. Переданная ссылка но объект консоли присваивается свойству InterprEnvironment.CurrentConsole. В методе Facade.Create() создается единственный объект класса Facade, к которому в дальнейшем доступ осуществляется через статическое свойство только для чтения Facade.Instance. Здесь используется паттерн Singleton.
При первом обращении к свойству InterprEnvironment.Instance вызывается конструктор класса InterprEnvironment, В нем создается объект ConsoleNamespace для пространства имен консоли. Затем производится восстановление переменных, сохраненных в файле variables в рабочем каталоге интерпретатора. Если этот файл отсутствует, то он создается (пустой) и восстановление не производится. Данный файл является двоичным. В его начале записывается общее число переменных, затем для каждой из них сохраняется информация о типе (один символ), имя (строка) и значение. Для массива после имени записывается общее число элементов, затем каждый из элементов в виде пары «тип-значение». Восстановление переменных производится в методе ConsoleNamespace.Restore(). Если восстановление не прошло успешно по причине неправильного формата файла variables, то в методе Restore() генерируется исключение NamespaceSerialisationException. Оно перехватывается в конструкторе класса InterprEnvironment, в результате чего изменяется значение соответствующего поля, после этого свойство InterprEnvironment.NotRestored, как и обращающееся к нему свойство Facade.NotRestored, возвращает истину. В случае, если такая ошибка произошла, в обработчике Form1.Form1_Load выдается соответствующее сообщение пользователю.
На следующем шаге инициализации устанавливается обработчик для события Facade.Done (завершение выполнения команды). Затем загружаются пользовательские функции с помощью метода Facade.LoadSubs(), вызывающего метод InterprEnvironment.LoadSubs(). Если при загрузке какой-либо функции произошла ошибка, сообщение выводится на консоль. Наконец, вызывается метод Prompt() (вывести приглашение и ждать ввода команды) элемента управления ConsoleBox, расположенного на главной форме.
Класс Facade имеет целый ряд методов для работы с пользовательскими функциями и переменными среды консоли, которые вызывают соответствующие методы объекта InterprEnvironment.Instance. Среди них: LoadSub(), LoadSubs(), GetSubs(), UnloadSub(), GetVariables(), DeleteVariable(), SaveVariables(). Через эти методы производятся операции во многих обработчиках событий пользовательского интерфейса.
Но, пожалуй, наиболее важным из методов класса Facade является ExecuteCommand() – выполнить команду. Он вызывается в обработчике события GetCommand элемента ConsoleBox на главной форме. В нем в отдельном потоке запускается на выполнение частный метод ThrStart(), в котором введенная с консоли команда сначала «компилируется» методом LineCompiler.CompileCommand(), затем выполняется, по окончании чего генерируется событие Facade.Done(), в обработчике которого консоль переводится в состояние ожидания следующей команды методом ConsoleBox.Prompt(). И «компиляция» и выполнение команды производятся в блоках try, в случае возникновения исключения на консоль выдается соответствующее сообщение об ошибке.
Необходимость выполнять команды в отдельном потоке связана с тем, что только в этом случае можно прервать зациклившуюся или долго работающую пользовательскую функцию без аварийного завершения интерпретатора. Для перезапуска интерпретатора, возможно, с прерыванием работы пользовательской функции, предназначен метод Facade.Restart(). В нем в отдельном потоке запускается метод DoRestart(), в котором выполняются следующие действия. Во-первых, если в данный момент времени выполняется команда, то вызывается статический метод Subroutine.Moment.Break().В нем с помощью метода Interlocked.Exchange() (безопасное при параллельном выполнении присваивание) статическому полю Subroutine.Moment.s_break присваивается значение 1. На каждой итерации цикла в методе Subroutine.Moment.Run(), помимо выполнения очередного оператора функции, проверяется значение этого поля. Если оно равно единице, то генерируется исключение CalcException, то есть выполнение команды завершается с ошибкой времени выполнения. После вызова Subroutine.Moment.Break() в методе DoRestart() следует цикл без тела, который выполняется до тех пор, пока выполнение команды не будет завершено, чего, конечно же, не приходится долго ждать. После того, как выполнение будет прервано, производится повторная инициализация, аналогичная происходящей при запуске интерпретатора.
Для реализации многопоточности используется стандартный класс System.Threading.Thread. Его конструктору передается один параметр типа делегата System.Threading.ThreadStart (процедура без параметров). Метод, на который указывает этот делегат, начинает выполняться в отдельном потоке при вызове метода Start() объекта потока. Когда метод, запущенный в потоке, возвращается, выполнение потока завершается. Повторное использование того же объекта класса Thread невозможно, его нужно создавать заново. При использовании многопоточности следует принимать ряд мер предосторожности для обеспечения безопасного доступа к общим данным. Например, присваивание значений переменным, используемым несколькими потоками, по возможности следует производить с помощью метода Interlocked.Exchange, который гарантирует атомарность операции, то есть то, что ее выполнение не будет прервано до полного завершения для передачи управления другому потоку. Также обращаться к методам и свойствам элементов графического интерфейса пользователя напрямую можно только из того же потока, в котором они были созданы. Если необходимо воздействовать на графический интерфейс пользователя из других потоков, то это следует делать в методе (процедуре без параметров), вызываемом с помощью делегата System.Windows.Forms.MethodInvoker. В языке C# имеются и другие средства синхронизации работы потоков, которые не используются в данном интерпретаторе.
Заключение
Мною выполнен интерпретатор несложного языка программирования. Интерпретатор работает в интерактивном режиме, выполняя команды, вводимые с консоли, которые могут содержать вызовы пользовательских функций (подпрограмм). Пользовательские функции могут содержать структурные конструкции – циклы, ветвления, вызовы других функций (возможна и рекурсия). Возможна работа с числовыми и строковыми данными, а также с одномерными массивами. Имеется достаточно большое число встроенных математических и других функций. Предварительного объявления переменных не требуется, синтаксис математический выражений – традиционный для языков высокого уровня. Это делает интерпретатор удобным в использовании. Данный интерпретатор может применяться как в учебных целях, например, для обучения школьников основам программирования, так и качестве «программируемого микрокалькулятора» для практических расчетов, сложность которых не требует применения специфического программного обеспечения.
Приложение. Исходный текст (сокращенно).
Ввиду большого объема исходного кода, приведены лишь наиболее важные его фрагменты.
Класс VarBase.
using System;
using System.IO;
namespace interpr.logic.vartypes {
public abstract class VarBase : ICloneable , IComputable {
public bool IsArray() {
return (this is ArrayVar);
}
public bool IsNum() {
return (this is NumVar);
}
public bool IsString() {
return (this is StringVar);
}
public bool IsInt() {
return (this is IntVar);
}
public bool IsReal() {
return (this is RealVar);
}
public bool IsSingle() {
return (this is SingleVar);
}
public virtual VarBase Compute() {
return this.Clone() as VarBase;
}
public abstract System.Object Clone();
public override abstract string ToString();
public abstract void Serialise(BinaryWriter bw);
}
}
Класс ArrayVar.
using System.Collections;
using System.IO;
namespace interpr.logic.vartypes {
public class ArrayVar : VarBase {
public virtual IntVar Size {
get { return new IntVar(m_list.Count); }
}
private ArrayList m_list;
public ArrayVar() {
m_list = new ArrayList();
}
public int GetSize() {
return m_list.Count;
}
public void setAt(int index, SingleVar var) {
if (var == null) {
throw new CalcException("Ошибка");
}
if (index < 0)
throw new CalcException("Индекс не может быть отрицательным");
for (int ind = index, s = m_list.Count; ind >= s; ind--)
m_list.Add(null);
m_list[index] = var.Clone();
}
public SingleVar getAt(int index) {
if (index < 0)
throw new CalcException("Индекс не может быть отрицательным");
if (index >= m_list.Count)
throw new CalcException("Выход за пределы массива");
else
return (SingleVar) m_list[index];
}
public SingleVar this[int index] {
get { return getAt(index); }
set { setAt(index, value); }
}
public IntVar IsElementDefined(int index) {
bool result = index>=0;
result = result&&(index<m_list.Count);
result = result&&(m_list[index]!=null);
return new IntVar(result);
}
public override System.Object Clone() {
ArrayVar res = new ArrayVar();
int li = 0;
SingleVar e = null;
while (li < m_list.Count) {
e = (SingleVar) m_list[li++];
if (e != null)
res.m_list.Add(e.Clone());
else
res.m_list.Add(null);
}
return res;
}
public override void Serialise(BinaryWriter bw) {
bw.Write('a');
int size = m_list.Count;
bw.Write(size);
for (int i = 0; i < size; i++) {
if (m_list[i] == null)
bw.Write('n');
else
(m_list[i] as VarBase).Serialise(bw);
}
}
public override System.String ToString() {
System.String res = "[";
int li = 0;
SingleVar e = null;
if (li < m_list.Count) {
e = (SingleVar) m_list[li++];
if (e != null) {
res += e.ToString();
}
else
res += "-";
}
while (li < m_list.Count) {
e = (SingleVar) m_list[li++];
if (e != null) {
res += ", " + e.ToString();
}
else
res += ", -";
}
return res + "]";
}
}
}
Класс InterprEnvironment.
using System;
using System.Collections;
using System.IO;
namespace interpr.logic {
public class InterprEnvironment {
private SubroutinesManager m_subsman = null;
private ConsoleNamespace m_console_vars;
private bool m_not_restored = false;
public bool NotRestored {
get { return m_not_restored; }
}
public ConsoleNamespace ConsoleNamespace {
get { return m_console_vars; }
}
public ConsoleNamespace.VariableReport[] GetGlobalVarsList() {
return m_console_vars.GetVariableList();
}
private InterprEnvironment() {
m_current_namespace = new ConsoleNamespace();
m_console_vars = m_current_namespace as ConsoleNamespace;
m_not_restored = false;
try {
m_console_vars.Restore();
} catch {
m_not_restored = true;
m_console_vars = new ConsoleNamespace();
m_current_namespace = m_console_vars;
}
}
public void LoadSubs() {
if (m_current_console == null)
throw new OtherException("Error in Environment.LoadSubs()");
s_instance.m_subsman = SubroutinesManager.GetInstance();
s_instance.m_subsman.ReloadAll();
}
private static InterprEnvironment s_instance = null;
public static InterprEnvironment Instance {
get {
if (s_instance == null)
s_instance = new InterprEnvironment();
return s_instance;
}
}
public static void Reset() {
s_instance = new InterprEnvironment();
}
public void SaveVars() {
m_console_vars.Save();
}
public bool LoadSub(string name) {
return m_subsman.Load(name);
}
private Namespace m_current_namespace = null;
public Namespace CurrentNamespace {
get { return m_current_namespace; }
set { m_current_namespace = value; }
}
private IConsole m_current_console = null;
public IConsole CurrentConsole {
get { return m_current_console; }
set { m_current_console = value; }
}
public Operation GetFunction(string name) {
if (name == "abs")
return Operation.ABS;
...........................
if (name == "size")
return Operation.SIZE;
return new SubName(name);
}
public string[] LoadedSubs {
get { return m_subsman.SubroutineNames; }
}
private class SubroutinesManager {
private ArrayList m_subs = new ArrayList();
private ArrayList m_names = new ArrayList();
private SubroutinesManager() {
DirectoryInfo di =
new DirectoryInfo(Directory.GetCurrentDirectory() + @"\subroutines");
if (!di.Exists) {
di.Create();
}
}
public bool Load(string name) {
FileInfo fi = new FileInfo(Directory.GetCurrentDirectory() + @"\subroutines\" + name);
if (!fi.Exists)
throw new OtherException("Error in SubroutinesManager.Load()");
return LoadFile(fi);
}
private bool LoadFile(FileInfo file) {
try {
StreamReader sr = file.OpenText();
LinkedList ll = new LinkedList();
try {
while (sr.Peek() != -1) {
ll.AddFirst(sr.ReadLine());
}
} finally {
sr.Close();
}
string[] strs = new String[ll.Count];
int i = 0;
while (!ll.IsEmpty()) {
strs[i] = (ll.RemoveLast() as String);
i++;
}
Subroutine sub;
try {
sub = new Subroutine(strs, file.Name);
} catch (LineSyntaxException ex) {
InterprEnvironment.Instance.CurrentConsole.PrintLn("Синтаксическая ошибка в " + ex.Function + "[] at line " + ex.Line + " " + ex.Message);
return false;
} catch (SyntaxErrorException ex) {
InterprEnvironment.Instance.CurrentConsole.PrintLn("Синтаксическая ошибка в " + file.Name + " " + ex.Message);
return false;
}
Set(file.Name, sub);
} catch {
throw new OtherException("Error in Environment.Load()");
}
return true;
}
public Subroutine this[string name] {
get {
int sres = m_names.IndexOf(name);
if (sres < 0)
return null;
else
return m_subs[sres] as Subroutine;
}
}
private void Set(string name, Subroutine sub) {
int sres = m_names.IndexOf(name);
if (sres >= 0) {
m_names.RemoveAt(sres);
m_subs.RemoveAt(sres);
}
m_names.Add(name);
m_subs.Add(sub);
}
private static SubroutinesManager s_inst = null;
public static SubroutinesManager GetInstance() {
if (s_inst == null)
s_inst = new SubroutinesManager();
return s_inst;
}
public string[] SubroutineNames {
get {
int count = m_names.Count;
string[] res = new string[count];
for (int i = 0; i < count; i++) {
res[i] = (m_names[i] as String);
}
for (int i = 0; i < count - 1; i++) {
int k = i;
for (int j = i + 1; j < count; j++)
k = (string.Compare(res[j], res[k]) < 0) ? j : k;
if (i != k) {
string temp = res[i];
res[i] = res[k];
res[k] = temp;
}
}
return res;
}
}
public void ReloadAll() {
m_subs = new ArrayList();
m_names = new ArrayList();
DirectoryInfo di =
new DirectoryInfo(Directory.GetCurrentDirectory() + @"\subroutines");
if (!di.Exists) {
di.Create();
}
foreach (FileInfo file in di.GetFiles()) {
if (Parser.IsID(file.Name)) {
LoadFile(file);
}
}
}
public void Unload(string name) {
int index = m_names.IndexOf(name);
if (index >= 0) {
m_names.RemoveAt(index);
m_subs.RemoveAt(index);
}
}
}
public Subroutine GetSub(string name) {
Subroutine res = m_subsman[name];
if (res == null)
throw new CalcException("Функция " + name + " не существует");
return res;
}
public void UnloadSub(string name) {
m_subsman.Unload(name);
}
}
}
Класс Namespace.
using System;
using System.Collections;
using interpr.logic.vartypes;
namespace interpr.logic {
public class NamespaceSerializationException : Exception {
public NamespaceSerializationException() : base() {}
}
public class Namespace {
protected class Pair {
internal string m_str;
internal VarBase m_var;
}
protected ArrayList m_list = new ArrayList();
protected int m_n = 0;
private Namespace m_previous_namespace = null;
public Namespace PreviousNamespace {
get { return m_previous_namespace; }
}
public Namespace(Namespace previous) {
m_previous_namespace = previous;
}
protected Namespace() {}
public VarBase Get(string name) {
if (m_n == 0)
return null;
int i = 0;
Pair p;
do {
p = (m_list[i++] as Pair);
if (p.m_str == name)
return p.m_var;
} while (i < m_n);
return null;
}
public void Assign(VarBase var, string name) {
Pair p;
if (m_n != 0) {
int i = 0;
do {
p = (m_list[i++] as Pair);
if (p.m_str == name) {
p.m_var = var;
return;
}
} while (i < m_n);
}
p = new Pair();
p.m_var = var;
p.m_str = name;
m_list.Add(p);
m_n++;
}
public void AssignToElement(SingleVar var, string name, int index) {
Pair p;
if (m_n != 0) {
int i = 0;
do {
p = (m_list[i++] as Pair);
if (p.m_str == name) {
if (!p.m_var.IsArray())
throw new CalcException("Переменная не является массивом");
(p.m_var as ArrayVar)[index] = var;
return;
}
} while (i < m_n);
}
p = new Pair();
p.m_var = new ArrayVar();
(p.m_var as ArrayVar)[index] = var;
p.m_str = name;
m_list.Add(p);
m_n++;
}
public void Remove(String name) {
if (m_n == 0)
return;
int i = 0;
do {
Pair p = (m_list[i++] as Pair);
if (p.m_str == name) {
m_list.RemoveAt(i - 1);
m_n--;
return;
}
} while (i < m_n);
}
public VarBase this[string name] {
set { Assign(value, name); }
get { return Get(name); }
}
}
}
Интерфейс IСomputable.
namespace interpr.logic {
public interface IComputable {
logic.vartypes.VarBase Compute();
}
}
Класс Call.
using interpr.logic.vartypes;
namespace interpr.logic {
public class Call : IComputable {
private Operation m_op;
private ArgList m_al = null;
public Call(Operation op) {
m_op = op;
}
public void SetArgList(ArgList al) {
m_al = al;
}
public int ReqCount {
get { return m_op.ReqCount; }
}
public VarBase Compute() {
return m_op.Perform(m_al);
}
}
}
Класс ArgList
using interpr.logic.vartypes;
namespace interpr.logic {
public class ArgList {
private bool m_read = false;
private LinkedList m_list = new LinkedList();
private LinkedList.Iterator m_i = null;
public void Add(VarBase var) {
if (m_read)
throw new OtherException("Write to the argument list after reading begin");
m_list.Add(var);
}
public VarBase Get() {
if (!m_read)
throw new OtherException("Try to read from argument list before reset");
if (!m_i.HasPrevious)
throw new OtherException("Try to read from empty argument list");
m_read = true;
IComputable obj = (m_i.Previous() as IComputable);
if (obj == null)
throw new CalcException("Переменная не инициализированна.");
return obj.Compute();
}
public void Reset() {
m_read = true;
m_i = m_list.GetIterator(m_list.Count);
}
public int Count {
get { return m_list.Count; }
}
}
}
Класс Expression.
using System;
using interpr.logic.vartypes;
namespace interpr.logic {
public class Expression {
public Expression(String str) {
Parser p = new Parser(str);
Analyse(p);
}
public Expression(Parser p) {
Analyse(p);
}
private class Element {
internal IComputable m_o;
internal Element m_next;
internal Element(IComputable obj, Element next) {
m_o = obj;
m_next = next;
}
}
private Element m_top = null;
private Element m_bottom = null;
private int m_c = 0;
private void AddFront(IComputable obj) {
m_c++;
if (m_c == 1)
m_top = m_bottom = new Element(obj, null);
else {
Element t = new Element(obj, null);
m_bottom.m_next = t;
m_bottom = t;
}
}
private void Analyse(Parser p) {
try {
LinkedList l = new LinkedList();
while (p.MoveNext())
l.Add(p.Current);
OPZ(l);
}
catch (CalcException ex) {
throw ex;
}
catch {
throw new SyntaxErrorException("Синтаксическая ошибка в выражении");
}
}
private void OPZ(LinkedList tokens) {
/* ** Бинарная операция выталкивает из стека в результат
* все операции с большим или равным приоритетом, затем
* записывается в стек сама
* ** Унарная операция записывается в стек
* ** Открывающая скобка записывается в стек
* ** Закрывающая скобка выталкивает в результат все операции
* из стека до открывающей скобки, затем
* скобки уничтожаются и выталкиваются унарные операции
* ** Переменная или константа сразу пишутся в результат, затем
* выталкиваются из стека унарные операции
* ** При вызове функции
* сначала отдельно разбираются все операнды, затем в результат
* дописывается сама функция, как операция
* ** Обращение к элементу массива обрабатывается аналогично
* В конце все оставшиеся в стеке операции выталкиваются в результат
*/
InterprEnvironment env = InterprEnvironment.Instance;
if (tokens.IsEmpty()) return;
LinkedList.Iterator itr = tokens.GetIterator();
LinkedList stk = new LinkedList();
while (itr.HasMore) {
string si = (itr.Step() as System.String);
if (si == "(") {
stk.Add(O_BR);
}
else if (si == ")") {
while (true) {
object o = stk.RemoveLast();
if (o == O_BR) break;
AddFront(new Call(o as Operation));
}
while ((!stk.IsEmpty()) && IsUnary(stk.Last)) {
AddFront(new Call(stk.RemoveLast() as Operation));
}
}
else if (Parser.IsID(si)) {
bool bfun = false;
bool barray = false;
if (itr.HasMore) {
string s = (itr.Step() as System.String);
if (s == "[")
bfun = true;
else if (s == "{")
barray = true;
else
itr.Previous();
}
if (bfun) {
LinkedList l = null;
while (true) {
l = new LinkedList();
int level = 0;
while (true) {
if (!itr.HasMore)
throw new SyntaxErrorException("Синтаксическая ошибка в выражении");
string sj = (itr.Step() as System.String);
if (sj == "[") {
level++;
l.Add(sj);
}
else if (sj == "]") {
if (level == 0)
goto label1;
else {
level--;
l.Add(sj);
}
}
else if (sj == ",") {
if (level > 0)
l.Add(sj);
else
break;
}
else
l.Add(sj);
}
OPZ(l);
}
label1:
if (l != null)
OPZ(l);
Operation sub = env.GetFunction(si);
AddFront(new Call(sub));
while ((stk.Count > 0) && IsUnary(stk.Last)) {
AddFront(new Call((Operation) stk.RemoveLast()));
}
}
else if (barray) {
LinkedList l = new LinkedList();
int level = 0;
while (true) {
if (!itr.HasMore)
throw new SyntaxErrorException("Синтаксическая ошибка в выражении");
String sj = (String) itr.Step();
if (sj == "{") {
level++;
l.Add(sj);
}
else if (sj == "}") {
if (level == 0)
break;
else {
level--;
l.Add(sj);
}
}
else
l.Add(sj);
}
OPZ(l);
VarName v = new VarName(si);
AddFront(v);
AddFront(new Call(Operation.INDEX));
while ((stk.Count > 0) && IsUnary(stk.Last)) {
AddFront(new Call(stk.RemoveLast() as Operation));
}
}
else {
VarName v = new VarName(si);
AddFront(v);
while ((stk.Count > 0) && IsUnary(stk.Last)) {
AddFront(new Call(stk.RemoveLast() as Operation));
}
}
}
else {
Operation op = StrToOperation(si);
if (op == null) {
SingleVar sv = SingleVar.FromString(si);
if (si == null)
throw new SyntaxErrorException("Синтаксическая ошибка в выражении");
AddFront(sv);
while ((stk.Count > 0) && IsUnary(stk.Last)) {
AddFront(new Call(stk.RemoveLast() as Operation));
}
}
else {
//operation
if (op == Operation.ADD) {
itr.Previous();
if (!itr.HasPrevious) {
stk.Add(Operation.UPLUS);
itr.Step();
continue;
}
String strpr = (String) itr.Previous();
itr.Step();
itr.Step();
if ((StrToOperation(strpr) != null) || (strpr == "(") ||
(strpr == "[") || (strpr == "{")) {
stk.Add(Operation.UPLUS);
continue;
}
}
else if (op == Operation.SUB) {
itr.Previous();
if (!itr.HasPrevious) {
stk.Add(Operation.UMINUS);
itr.Step();
continue;
}
String strpr = (String) itr.Previous();
itr.Step();
itr.Step();
if ((StrToOperation(strpr) != null) || (strpr == "(") ||
(strpr == "[") || (strpr == "{")) {
stk.Add(Operation.UMINUS);
continue;
}
}
else if (op == Operation.NOT) {
stk.Add(op);
continue;
}
if (stk.IsEmpty() || (stk.Last == O_BR)) {
stk.Add(op);
}
else {
int pr = Priority(op);
while (true) {
if (stk.IsEmpty())
break;
Object stktop = stk.Last;
if (stktop is Operation) {
int pr1 = Priority(stktop as Operation);
if ((pr <= pr1) && (pr1 < 6)) {
AddFront(new Call(stktop as Operation));
stk.RemoveLast();
}
else
break;
}
else
break;
}
stk.Add(op);
}
}
}
}
while (!stk.IsEmpty()) {
Object o = stk.RemoveLast();
AddFront(new Call(o as Operation));
}
}
public VarBase Calculate() {
if (m_c == 0)
throw new CalcException("Ошибка: пустое выражение.");
Element top1 = null;
Element cur = m_top;
try {
for (; cur != null; cur = cur.m_next) {
if (cur.m_o is Call) {
int rc = (cur.m_o as Call).ReqCount;
ArgList al = new ArgList();
for (int i = 0; i < rc; i++) {
if (top1 == null)
throw new CalcException("Ошибка при вычислении выражения");
al.Add(top1.m_o.Compute());
top1 = top1.m_next;
}
(cur.m_o as Call).SetArgList(al);
top1 = new Element((cur.m_o as Call).Compute(), top1);
}
else {
top1 = new Element(cur.m_o, top1);
}
}
if ((top1 == null) || (top1.m_next != null))
throw new CalcException("Ошибка при вычислении выражения");
return top1.m_o.Compute();
}
catch (CalcException ex) {
throw ex;
}
catch {
throw new CalcException("Ошибка при вычислении выражения");
}
}
private static Operation StrToOperation(String str) {
//не возвращает унарные плюс и минус
if (str == "+")
return Operation.ADD;
else if (str == "-")
return Operation.SUB;
else if (str == "*")
return Operation.MUL;
else if (str == "/")
return Operation.DIV;
else if (str == "~")
return Operation.NOT;
else if (str == "|")
return Operation.OR;
else if (str == "&")
return Operation.AND;
else if (str == "^")
return Operation.XOR;
else if (str == "~=")
return Operation.BE;
else if (str == "=")
return Operation.EQ;
else if (str == "<>")
return Operation.NE;
else if (str == ">=")
return Operation.GE;
else if (str == "<=")
return Operation.LE;
else if (str == ">")
return Operation.GT;
else if (str == "<")
return Operation.LT;
else
return null;
}
private static int Priority(Operation op) {
if ((op == Operation.OR) || (op == Operation.XOR) ||
(op == Operation.BE))
return 1;
else if (op == Operation.AND)
return 2;
else if ((op == Operation.EQ) || (op == Operation.NE) ||
(op == Operation.LE) || (op == Operation.LT) ||
(op == Operation.GE) || (op == Operation.GT))
return 3;
else if ((op == Operation.ADD) || (op == Operation.SUB))
return 4;
else if ((op == Operation.MUL) || (op == Operation.DIV))
return 5;
else
return 6;
}
private static bool IsBinary(Operation op) {
return Priority(op) < 6;
}
private static bool IsUnary(object obj) {
return ((obj == Operation.NOT) || (obj == Operation.UPLUS) ||
(obj == Operation.UMINUS));
}
private class BR_c {}
private static object O_BR = new BR_c();
}
}
Дата: 2019-07-24, просмотров: 172.