Êóðñîâàÿ ðàáîòà: Èíòåðàêòèâíûé èíòåðïðåòàòîð
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);
}
}
}
4. Êëàññ 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); }
}
}
}
5. Èíòåðôåéñ IÑomputable.
namespace interpr.logic {
public interface IComputable {
logic.vartypes.VarBase Compute();
}
}
6. Êëàññ 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);
}
}
}
7. Êëàññ 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; }
}
}
}
8. Êëàññ 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;
}
}
Ñòðàíèöû: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
