public override void CopyValues(ScrObjLibraryEntry other)
{
base.CopyValues(other);
CharEntry cd = (CharEntry)other;
portraitSet = cd.portraitSet;
startClass = cd.startClass;
startClassLevels = cd.startClassLevels;
hp = cd.hp;
dmg = cd.dmg;
mnd = cd.mnd;
skl = cd.skl;
spd = cd.spd;
def = cd.def;
gHp = cd.gHp;
gDmg = cd.gDmg;
gMnd = cd.gMnd;
gSkl = cd.gSkl;
gSpd = cd.gSpd;
gDef = cd.gDef;
supports = new List <SupportTuple>();
for (int i = 0; i < cd.supports.Count; i++)
{
supports.Add(cd.supports[i]);
}
faction = cd.faction;
mustSurvive = cd.mustSurvive;
deathQuote = cd.deathQuote;
}
public override void ResetValues()
{
base.ResetValues();
portraitSet = null;
startClass = null;
startClassLevels = new int[ClassWheel.CLASS_COUNT];
hp = 0;
dmg = 0;
mnd = 0;
skl = 0;
spd = 0;
def = 0;
gHp = 0;
gDmg = 0;
gMnd = 0;
gSkl = 0;
gSpd = 0;
gDef = 0;
supports = new List <SupportTuple>();
faction = Faction.NONE;
mustSurvive = false;
deathQuote = null;
}
public List <ClassEntry> GetAllClasses()
{
command = new SqlCommand();
command.CommandText = "SELECT * FROM tbl_classes ORDER BY order_by ASC";
command.Connection = connection;
command.Connection.Open();
reader = command.ExecuteReader();
List <ClassEntry> allClasses = new List <ClassEntry>();
while (reader.Read())
{
ClassEntry aClassEntry = new ClassEntry();
aClassEntry.Id = Convert.ToInt32(reader["id"]);
aClassEntry.Name = reader["name"].ToString();
aClassEntry.OrderBy = Convert.ToInt32(reader["order_by"]);
allClasses.Add(aClassEntry);
}
reader.Close();
connection.Close();
return(allClasses);
}
/// <summary>
/// Returns a collection of <see cref="ClassEntry" /> containing
/// information about all classes in this stream.
/// </summary>
/// <param name="document">A validated <see cref="XmlDocument"/> representing
/// a mapping file.</param>
public static ICollection GetClassEntries(XmlDocument document)
{
XmlNamespaceManager nsmgr = HbmBinder.BuildNamespaceManager(document.NameTable);
// Since the document is validated, no error checking is done in this method.
HashedSet classEntries = new HashedSet();
XmlNode root = document.DocumentElement;
string assembly = XmlHelper.GetAttributeValue(root, "assembly");
string @namespace = XmlHelper.GetAttributeValue(root, "namespace");
XmlNodeList classNodes = document.SelectNodes(
"//" + HbmConstants.nsClass +
"|//" + HbmConstants.nsSubclass +
"|//" + HbmConstants.nsJoinedSubclass +
"|//" + HbmConstants.nsUnionSubclass,
nsmgr
);
foreach (XmlNode classNode in classNodes)
{
string name = XmlHelper.GetAttributeValue(classNode, "name");
string extends = XmlHelper.GetAttributeValue(classNode, "extends");
ClassEntry ce = new ClassEntry(extends, name, assembly, @namespace);
classEntries.Add(ce);
}
return classEntries;
}
/// <summary>
/// Returns a collection of <see cref="ClassEntry" /> containing
/// information about all classes in this stream.
/// </summary>
/// <param name="document">A validated <see cref="XmlDocument"/> representing
/// a mapping file.</param>
public static ICollection GetClassEntries(XmlDocument document)
{
// TODO this should be extracted into a utility method since there's similar
// code in Configuration
XmlNamespaceManager nsmgr = new XmlNamespaceManager(document.NameTable);
nsmgr.AddNamespace(HbmConstants.nsPrefix, Configuration.MappingSchemaXMLNS);
// Since the document is validated, no error checking is done in this method.
HashedSet classEntries = new HashedSet();
XmlNode root = document.DocumentElement;
string assembly = XmlHelper.GetAttributeValue(root, "assembly");
string @namespace = XmlHelper.GetAttributeValue(root, "namespace");
XmlNodeList classNodes = document.SelectNodes(
"//" + HbmConstants.nsClass +
"|//" + HbmConstants.nsSubclass +
"|//" + HbmConstants.nsJoinedSubclass +
"|//" + HbmConstants.nsUnionSubclass,
nsmgr
);
foreach (XmlNode classNode in classNodes)
{
string name = XmlHelper.GetAttributeValue(classNode, "name");
string extends = XmlHelper.GetAttributeValue(classNode, "extends");
ClassEntry ce = new ClassEntry(extends, name, assembly, @namespace);
classEntries.Add(ce);
}
return classEntries;
}
public List <CharacterSkill> GetSkillsFromLevel(int[] classLevels, ClassEntry startClass, int startLevel)
{
List <CharacterSkill> skills = new List <CharacterSkill>();
bool edit = false;
for (int i = 0; i < classLevels.Length; i++)
{
for (int level = 0; level < classLevels[i]; level++)
{
skills.Add(classes[i].skills[level]);
//Debug.Log("Added skill: " + classes[i].skills[level].entryName + " for class " + ((PlayerClassName)i));
edit = true;
}
}
if (!edit)
{
int levelups = 1 + (startLevel / 10);
for (int i = 0; i < levelups; i++)
{
skills.Add(startClass.skills[i]);
}
}
return(skills);
}
private void OnRequestUseCard(Card drawnCard)
{
if (drawnCard.Player == _player && _isMe)
{
AnimateAndUseCard(drawnCard);
}
if (!_isMe && drawnCard.Player == _player)
{
ClassEntry cardEntry = _cardMap.GetEntryByKey(drawnCard.ID);
TaskScheduler.Instance.Queue(new UnityTask(delegate
{
if (cardEntry != null)
{
GameObject cardInstance = Instantiate(cardEntry.data.prefab, _gameCanvas.transform);
CardScript cardScript = cardInstance.GetComponent <CardScript>();
cardScript.Ready(this, drawnCard);
_cardsOnHand.Add(cardInstance);
AnimateAndUseCard(drawnCard);
}
}));
}
}
private static void DoInit()
{
DoValidateTypes();
List <ClassEntry> exports = new List <ClassEntry>();
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (Type type in assembly.GetTypes())
{
ExportClassAttribute attr = Attribute.GetCustomAttribute(type, typeof(ExportClassAttribute), false) as ExportClassAttribute;
if (attr != null)
{
exports.Add(new ClassEntry(type, attr));
}
RegisterAttribute attr2 = Attribute.GetCustomAttribute(type, typeof(RegisterAttribute), false) as RegisterAttribute;
if (attr2 != null)
{
string name = attr2.Name ?? type.Name;
if (type.IsValueType)
{
TypeEncoder.Register(type, name);
}
else
{
NSObject.Register(type, name);
}
}
}
}
for (int i = 0; i < exports.Count; ++i) // must process base types before derived types
{
for (int j = i + 1; j < exports.Count; ++j) // crappy O(N^2) sort, but it's difficult to use a more efficient sort because we cannot meaningfully compare two elements in isolation
{ // should be OK though, because this is only for exported types, not registered types
if (ClassEntry.LeftDerivesFromRight(exports[i], exports[j]))
{
ClassEntry temp = exports[i];
exports[i] = exports[j];
exports[j] = temp;
}
}
}
foreach (ClassEntry export in exports)
{
if (ms_typeNames.ContainsKey(export.Attr.DerivedName))
{
throw new ArgumentException(string.Format("{0} exports {1} but that class name has already been exported.", export.Type, export.Attr.DerivedName));
}
ms_typeNames.Add(export.Attr.DerivedName, export.Type);
ms_classNames.Add(export.Type, export.Attr.DerivedName);
DoInitClass(export.Attr.DerivedName, export.Attr.BaseName, export.Type, export.Attr.Outlets);
}
}
public StatsContainer(SpawnData pos)
{
level = pos.level;
charData = pos.charData;
currentClass = pos.charData.startClass;
classLevels = pos.charData.startClassLevels;
GenerateStartingStats();
}
private void deleteButton_Click(object sender, EventArgs e)
{
ClassEntry aClassEntry = new ClassEntry();
aClassEntry.Id = Convert.ToInt32(classIdTextBox.Text);
string message = aClassEntryManager.DeleteClass(aClassEntry.Id);
MessageBox.Show(message);
LoadClassEntryListView();
}
public int UpdateClass(ClassEntry aClassEntry)
{
query = "UPDATE tbl_classes SET name = '" + aClassEntry.Name + "', order_by = '" + aClassEntry.OrderBy + "' WHERE id = '" + aClassEntry.Id + "'";
connection.Open();
command = new SqlCommand(query, connection);
int rowAffected = command.ExecuteNonQuery();
connection.Close();
return(rowAffected);
}
public int SaveClass(ClassEntry aClassEntry)
{
string query = "INSERT INTO tbl_classes (name, order_by) VALUES ('" + aClassEntry.Name + "','" + aClassEntry.OrderBy + "')";
connection.Open();
command = new SqlCommand(query, connection);
int rowAffected = command.ExecuteNonQuery();
connection.Close();
return(rowAffected);
}
public void ChangeClass(ClassEntry newClass)
{
eHp += newClass.hp - currentClass.hp;
eDmg += newClass.dmg - currentClass.dmg;
eMnd += newClass.mnd - currentClass.mnd;
eSpd += newClass.spd - currentClass.spd;
eSkl += newClass.skl - currentClass.skl;
eDef += newClass.def - currentClass.def;
currentClass = newClass;
CalculateStats();
}
public bool Equals(ClassEntry obj)
{
if (obj == null)
{
return false;
}
if (ReferenceEquals(this, obj))
{
return true;
}
return Equals(obj.entityName, entityName) && Equals(obj.fullExtends, fullExtends) && Equals(obj.fullClassName, fullClassName);
}
public bool Equals(ClassEntry obj)
{
if (obj == null)
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
return(Equals(obj.entityName, entityName) && Equals(obj.fullExtends, fullExtends) && Equals(obj.fullClassName, fullClassName));
}
public override List <string> ExecuteSemanticAction(Stack <SemanticRecord> semanticRecordTable, Stack <SymbolTable> symbolTable, IToken lastToken, MoonCodeResult moonCode)
{
ClassEntry typeClass = null;
List <string> errors = new List <string>();
string searchType = lastToken.getSemanticName();
// Check if the type is of int or float
if (lastToken.getToken() == Tokens.TokenList.IntRes)
{
typeClass = intClass;
}
else if (lastToken.getToken() == Tokens.TokenList.FloatRes)
{
typeClass = floatClass;
}
// Check if we are recursively using a type defined in the immediate parent
else if (symbolTable.Any() && symbolTable.Peek().getParent() != null && symbolTable.Peek().getParent().getName() == searchType)
{
errors.Add(string.Format("{0}'s member variable or function parameter cannot refer to its own class at line {1}", searchType, lastToken.getLine()));
typeClass = symbolTable.Peek().getParent() as ClassEntry;
}
else
{
// Find the type being referenced in the parent scopes
foreach (SymbolTable table in symbolTable)
{
// Look through this table's entry list for a type
typeClass = table.GetEntries().FirstOrDefault(x => x.getKind() == EntryKinds.classKind && x.getName() == searchType) as ClassEntry;
if (typeClass != null)
{
break;
}
}
}
if (typeClass != null)
{
semanticRecordTable.Push(new SemanticRecord(typeClass));
}
else
{
errors.Add(string.Format("Type name: {0} does not exist at line {1}", searchType, lastToken.getLine()));
semanticRecordTable.Push(new SemanticRecord(new ClassEntry(searchType, 0)));
}
return(errors);
}
public override void CopyValues(ScrObjLibraryEntry other)
{
base.CopyValues(other);
ClassEntry cc = (ClassEntry)other;
className = cc.className;
icon = cc.icon;
playerSprite = cc.playerSprite;
allySprite = cc.allySprite;
enemySprite = cc.enemySprite;
bossSprite = cc.bossSprite;
classType = cc.classType;
movespeed = cc.movespeed;
hp = cc.hp;
dmg = cc.dmg;
mnd = cc.mnd;
skl = cc.skl;
spd = cc.spd;
def = cc.def;
gHp = cc.gHp;
gDmg = cc.gDmg;
gMnd = cc.gMnd;
gSkl = cc.gSkl;
gSpd = cc.gSpd;
gDef = cc.gDef;
lockTouch = cc.lockTouch;
weaponSkills = new List <WeaponType>();
for (int i = 0; i < cc.weaponSkills.Count; i++)
{
weaponSkills.Add(cc.weaponSkills[i]);
}
skills = new List <CharacterSkill>();
for (int i = 0; i < cc.skills.Count; i++)
{
skills.Add(cc.skills[i]);
}
bonusHp = cc.bonusHp;
bonusDmg = cc.bonusDmg;
bonusMnd = cc.bonusMnd;
bonusSkl = cc.bonusSkl;
bonusSpd = cc.bonusSpd;
bonusDef = cc.bonusDef;
}
public bool IsClassNameExist(ClassEntry aClassEntry)
{
query = "SELECT * FROM tbl_classes WHERE name = '" + aClassEntry.Name + "' AND id <> '" + aClassEntry.Id + "'";
connection.Open();
command = new SqlCommand(query, connection);
reader = command.ExecuteReader();
bool isExist = reader.HasRows;
reader.Close();
connection.Close();
return(isExist);
}
private void classEntryListView_DoubleClick(object sender, EventArgs e)
{
ListViewItem selectedItem = classEntryListView.SelectedItems[0];
ClassEntry aClassEntry = (ClassEntry)selectedItem.Tag;
deleteButton.Enabled = true;
if (aClassEntry != null)
{
classNameTextBox.Text = aClassEntry.Name;
orderByTextBox.Text = aClassEntry.OrderBy.ToString();
classIdTextBox.Text = aClassEntry.Id.ToString();
saveButton.Text = "Update";
}
}
public string UpdateClass(ClassEntry aClassEntry)
{
if (aClassGateway.IsClassNameExist(aClassEntry))
{
return("This Class Already Exists");
}
else
{
int rowAffected = aClassGateway.UpdateClass(aClassEntry);
if (rowAffected > 0)
{
return("Update Class Succesfully");
}
return("Update Failed");
}
}
public Holder()
{
var node1 = new ClassNode(typeof(Class01), new Class01());
var node2 = new ClassNode(typeof(Class02), new Class02());
var node3 = new ClassNode(typeof(Class03), new Class03());
node1.Next = node2;
node2.Next = node3;
nodeRef = node1;
structEntriesRef = new StructEntry[3];
structEntriesRef[0] = new StructEntry(typeof(Class01), new Class01());
structEntriesRef[1] = new StructEntry(typeof(Class02), new Class02());
structEntriesRef[2] = new StructEntry(typeof(Class03), new Class03());
classEntriesRef = new ClassEntry[3];
classEntriesRef[0] = new ClassEntry(typeof(Class01), new Class01());
classEntriesRef[1] = new ClassEntry(typeof(Class02), new Class02());
classEntriesRef[2] = new ClassEntry(typeof(Class03), new Class03());
}
private void MergeInherited(ClassEntry base_cls, string class_name)
{
if (!this._obj.ContainsKey(class_name.ToLower()))
{
return;
}
CAutoComplete.ClassEntry cls = (ClassEntry)this._obj[class_name.ToLower()];
if (cls.ClassInheritsFrom == cls.ClassName)
{
return;
}
if (cls.ClassInheritsFrom != "")
{
MergeInherited(cls, cls.ClassInheritsFrom);
}
foreach (ClassEntry.FuncEntry func in cls.func_list.Values)
{
if (base_cls.func_list.ContainsKey(func.func_name.ToLower()))
{
//base_cls.func_list.Remove(base_cls.func_list[func.func_name.ToLower()]);
continue;
}
base_cls.func_list.Add(func.func_name.ToLower(), func);
}
foreach (ClassEntry.PropEntry prop in cls.prop_list.Values)
{
if (base_cls.prop_list.ContainsKey(prop.prop_name.ToLower()))
{
//base_cls.prop_list.Remove(base_cls.prop_list[prop.prop_name.ToLower()]);
continue;
}
base_cls.prop_list.Add(prop.prop_name.ToLower(), prop);
}
}
private void saveButton_Click(object sender, EventArgs e)
{
ClassEntry aClassEntry = new ClassEntry();
aClassEntry.Name = classNameTextBox.Text;
aClassEntry.OrderBy = Convert.ToInt32(orderByTextBox.Text);
if (saveButton.Text == "Save")
{
string message = aClassEntryManager.SaveClass(aClassEntry);
MessageBox.Show(message);
}
else
{
aClassEntry.Id = Convert.ToInt32(classIdTextBox.Text);
string message = aClassEntryManager.UpdateClass(aClassEntry);
MessageBox.Show(message);
}
LoadClassEntryListView();
}
private void OnCardAddedToHand(Card card, bool isDrawn)
{
if (!_isMe)
{
return;
}
if (card.Player != _player)
{
return;
}
ClassEntry cardEntry = _cardMap.GetEntryByKey(card.ID);
if (cardEntry != null)
{
GameObject cardInstance = Instantiate(cardEntry.data.prefab, _gameCanvas.transform);
CardScript cardScript = cardInstance.GetComponent <CardScript>();
cardScript.Ready(this, card);
cardInstance.transform.position = _deckObject.transform.position;
cardInstance.transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
float delay = 0.5f;
LeanTween
.scale(cardInstance, new Vector3(0.45f, 0.45f, 0.45f), delay)
.setDelay(_addToHandDelay)
.setOnComplete(() =>
{
_addToHandDelay -= delay;
})
.setOnStart(() =>
{
_cardsOnHand.Add(cardInstance);
ReArrangeCardsOnHand(delay);
cardScript.FlipCard(true);
});
_addToHandDelay += delay;
}
}
private static void MethodDecl(ClassEntry parentEntry)
{
if (analyzer.Token == Symbol.publict)
{
Match(Symbol.publict);
var(type, _) = Type();
var entry = symTable.Insert <MethodEntry>(analyzer.Lexeme, analyzer.Token, currentDepth);
entry.ReturnType = type;
parentEntry.MethodNames.Add(analyzer.Lexeme);
Emit($"proc {entry.Lexeme}");
Match(Symbol.idt);
Match(Symbol.lparent);
FormalList(entry);
Match(Symbol.rparent);
Match(Symbol.begint);
VarDecl(entry);
SeqOfStatements(entry);
Match(Symbol.returnt);
var retEntry = symTable.Lookup(analyzer.Lexeme);
Expr(ref retEntry, entry);
if (retEntry != null)
{
Emit($"_AX = {GetBasePointerOffset(retEntry, entry)}");
}
Match(Symbol.semit);
Match(Symbol.endt);
Emit($"endp {entry.Lexeme}");
Emit($""); // space
currentOffset = 0;
MethodDecl(parentEntry);
}
currentOffset = 0;
}
internal MethodHandleEntry ToConstantPool()
{
var referenceOwner = new ClassEntry(new Utf8Entry(Owner.Name));
var referenceNameAndType = new NameAndTypeEntry(new Utf8Entry(Name), new Utf8Entry(Descriptor.ToString()));
var reference = Type switch
{
ReferenceKindType.GetField => (ReferenceEntry) new FieldReferenceEntry(referenceOwner,
referenceNameAndType),
ReferenceKindType.GetStatic => new FieldReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.PutField => new FieldReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.PutStatic => new FieldReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.InvokeVirtual => new MethodReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.NewInvokeSpecial => new MethodReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.InvokeStatic => new MethodReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.InvokeSpecial => new MethodReferenceEntry(referenceOwner, referenceNameAndType),
ReferenceKindType.InvokeReference => new InterfaceMethodReferenceEntry(referenceOwner,
referenceNameAndType),
_ => throw new ArgumentOutOfRangeException(nameof(Type))
};
return(new MethodHandleEntry(Type, reference));
}
}
public override List <string> ExecuteSemanticAction(Stack <SemanticRecord> semanticRecordTable, Stack <SymbolTable> symbolTable, IToken lastToken, MoonCodeResult moonCode)
{
SymbolTable currentTable = symbolTable.Peek();
List <string> errors = new List <string>();
string className = lastToken.getSemanticName();
// Check if the class' name already exists
foreach (Entry entry in currentTable.GetEntries())
{
if (entry.getName() == className)
{
errors.Add(string.Format("Identifier {0} at line {1} has already been declared", className, lastToken.getLine()));
break;
}
}
// Create a class entry
Entry classEntry = new ClassEntry(className, currentTable);
symbolTable.Push(classEntry.getChild());
return(errors);
}
private void SetupValues(CharacterSaveData saveData, CharEntry cStacDatas, ClassEntry cClass)
{
charData = cStacDatas;
currentClass = cClass;
if (saveData == null)
{
return;
}
classLevels = new int[ClassWheel.CLASS_COUNT];
for (int i = 0; i < ClassWheel.CLASS_COUNT; i++)
{
if (i < saveData.classLevels.Length)
{
classLevels[i] = saveData.classLevels[i];
}
}
level = saveData.level;
if (level == -1)
{
return;
}
currentExp = saveData.currentExp;
eHp = saveData.eHp;
eDmg = saveData.eDmg;
eMnd = saveData.eMnd;
eSpd = saveData.eSpd;
eSkl = saveData.eSkl;
eDef = saveData.eDef;
//TODO calculate support boost.
supportBoost = new Boost();
CalculateStats();
}
public void Automate()
{
var vm = new RegisterStudentViewModel(Navigation);
UsernameEntry.Completed += (object sender, EventArgs e) =>
{
PasswordEntry.Focus();
};
PasswordEntry.Completed += (object sender, EventArgs e) =>
{
ConfirmPasswordEntry.Focus();
};
ConfirmPasswordEntry.Completed += (object sender, EventArgs e) =>
{
PhoneNumberEntry.Focus();
};
PhoneNumberEntry.Completed += (object sender, EventArgs e) =>
{
NameEntry.Focus();
};
NameEntry.Completed += (object sender, EventArgs e) =>
{
AgeEntry.Focus();
};
AgeEntry.Completed += (object sender, EventArgs e) =>
{
ClassEntry.Focus();
};
ClassEntry.Completed += (object sender, EventArgs e) =>
{
INameEntry.Focus();
};
INameEntry.Completed += (object sender, EventArgs e) =>
{
vm.RegisterStudent.Execute(null);
};
}
private void ReadConfig (XmlTextReader xtr)
{
if (!CheckForMWFConfig (xtr))
return;
while (xtr.Read ()) {
switch (xtr.NodeType) {
case XmlNodeType.Element:
ClassEntry class_entry = classes_hashtable [xtr.Name] as ClassEntry;
if (class_entry == null) {
class_entry = new ClassEntry ();
class_entry.ClassName = xtr.Name;
classes_hashtable [xtr.Name] = class_entry;
}
class_entry.ReadXml (xtr);
break;
}
}
}
public void SetValue (string class_name, string value_name, object value)
{
ClassEntry class_entry = classes_hashtable [class_name] as ClassEntry;
if (class_entry == null) {
class_entry = new ClassEntry ();
class_entry.ClassName = class_name;
classes_hashtable [class_name] = class_entry;
}
class_entry.SetValue (value_name, value);
}
public void LoadClassData(string filename)
{
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Enter - " + filename);
_obj = new Hashtable();
StreamReader reader = new StreamReader(filename);
string fulldata = reader.ReadToEnd();
reader.Close();
Regex classes = new Regex(@"\s*class\s*(\b[A-Z_][A-Z0-9_]*\b)\s*(\:\s*public\s*(\b[A-Z][A-Z0-9]*\b)\s*)?\s*\{\s*(.*?)\};", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline);
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Loading classes");
foreach(Match m in classes.Matches(fulldata)) {
// Define the object and declare their functions
if (this._obj.ContainsKey(m.Groups[1].Value.ToLower()))
continue;
ClassEntry cls = new ClassEntry();
cls.ClassName = m.Groups[1].Value;
cls.ClassInheritsFrom = m.Groups[3].Value;
// Run a regex on the list of functions
Regex funcs = new Regex(@"(^\s*\/\*\!\s*(.*)\s*\*\/\n)?^\s*virtual\s*(void|bool|string|int|float|double)\s*(\b[A-Z_][A-Z0-9_]*)\s*\((.*)\)\s*\{\}\s*$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
foreach(Match func_m in funcs.Matches(m.Groups[4].Value)) {
// Insert function data into the arraylists
if (cls.func_list.ContainsKey(func_m.Groups[4].Value.ToLower()))
continue;
ClassEntry.FuncEntry func = new ClassEntry.FuncEntry();
func.func_descr = func_m.Groups[2].Value;
func.func_name = func_m.Groups[4].Value;
func.func_ret = func_m.Groups[3].Value;
func.func_params = func_m.Groups[5].Value;
cls.func_list.Add(func.func_name.ToLower(), func);
}
// ^\s*\/\*\!\s*\n\s*\*\/\n\s*(\b[A-Z_][A-Z0-9_]+\b)\s*(\b[A-Z_][A-Z0-9_]+\b)\s*\;\s*$
// Pull the list of parameters next
Regex param_list = new Regex(@"^\s*\/\*\!\s*(\n)?\s*\*\/(\n)?\s*(\b[A-Z_][A-Z0-9_]+\b)\s*(\b[A-Z_][A-Z0-9_]+\b)\s*\;\s*$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
foreach(Match param_m in param_list.Matches(m.Groups[4].Value)) {
// Insert parameter data into the arraylists
if (cls.prop_list.ContainsKey(param_m.Groups[4].Value.ToLower()))
continue;
ClassEntry.PropEntry prop = new ClassEntry.PropEntry();
prop.prop_name = param_m.Groups[4].Value;
prop.prop_type = param_m.Groups[3].Value;
cls.prop_list.Add(prop.prop_name.ToLower(), prop);
}
this._obj.Add(m.Groups[1].Value.ToLower(), cls);
}
// Merge the inherited functions and properties into the list:
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Merging inheritence tree");
foreach(CAutoComplete.ClassEntry cls in this._obj.Values) {
if (cls.ClassInheritsFrom != "")
MergeInherited(cls, cls.ClassInheritsFrom);
}
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Done");
}
public void LoadClassData(string filename)
{
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Enter - " + filename);
_obj = new Hashtable();
StreamReader reader = new StreamReader(filename);
string fulldata = reader.ReadToEnd();
reader.Close();
Regex classes = new Regex(@"\s*class\s*(\b[A-Z_][A-Z0-9_]*\b)\s*(\:\s*public\s*(\b[A-Z][A-Z0-9]*\b)\s*)?\s*\{\s*(.*?)\};", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline);
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Loading classes");
foreach (Match m in classes.Matches(fulldata))
{
// Define the object and declare their functions
if (this._obj.ContainsKey(m.Groups[1].Value.ToLower()))
{
continue;
}
ClassEntry cls = new ClassEntry();
cls.ClassName = m.Groups[1].Value;
cls.ClassInheritsFrom = m.Groups[3].Value;
// Run a regex on the list of functions
Regex funcs = new Regex(@"(^\s*\/\*\!\s*(.*)\s*\*\/\n)?^\s*virtual\s*(void|bool|string|int|float|double)\s*(\b[A-Z_][A-Z0-9_]*)\s*\((.*)\)\s*\{\}\s*$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
foreach (Match func_m in funcs.Matches(m.Groups[4].Value))
{
// Insert function data into the arraylists
if (cls.func_list.ContainsKey(func_m.Groups[4].Value.ToLower()))
{
continue;
}
ClassEntry.FuncEntry func = new ClassEntry.FuncEntry();
func.func_descr = func_m.Groups[2].Value;
func.func_name = func_m.Groups[4].Value;
func.func_ret = func_m.Groups[3].Value;
func.func_params = func_m.Groups[5].Value;
cls.func_list.Add(func.func_name.ToLower(), func);
}
// ^\s*\/\*\!\s*\n\s*\*\/\n\s*(\b[A-Z_][A-Z0-9_]+\b)\s*(\b[A-Z_][A-Z0-9_]+\b)\s*\;\s*$
// Pull the list of parameters next
Regex param_list = new Regex(@"^\s*\/\*\!\s*(\n)?\s*\*\/(\n)?\s*(\b[A-Z_][A-Z0-9_]+\b)\s*(\b[A-Z_][A-Z0-9_]+\b)\s*\;\s*$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
foreach (Match param_m in param_list.Matches(m.Groups[4].Value))
{
// Insert parameter data into the arraylists
if (cls.prop_list.ContainsKey(param_m.Groups[4].Value.ToLower()))
{
continue;
}
ClassEntry.PropEntry prop = new ClassEntry.PropEntry();
prop.prop_name = param_m.Groups[4].Value;
prop.prop_type = param_m.Groups[3].Value;
cls.prop_list.Add(prop.prop_name.ToLower(), prop);
}
this._obj.Add(m.Groups[1].Value.ToLower(), cls);
}
// Merge the inherited functions and properties into the list:
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Merging inheritence tree");
foreach (CAutoComplete.ClassEntry cls in this._obj.Values)
{
if (cls.ClassInheritsFrom != "")
{
MergeInherited(cls, cls.ClassInheritsFrom);
}
}
g.LogDebug("CAUTOCOMPLETE::LoadClassData: Done");
}
private void MergeInherited(ClassEntry base_cls, string class_name)
{
if (!this._obj.ContainsKey(class_name.ToLower()))
return;
CAutoComplete.ClassEntry cls = (ClassEntry)this._obj[class_name.ToLower()];
if (cls.ClassInheritsFrom == cls.ClassName)
return;
if (cls.ClassInheritsFrom != "")
MergeInherited(cls, cls.ClassInheritsFrom);
foreach(ClassEntry.FuncEntry func in cls.func_list.Values) {
if (base_cls.func_list.ContainsKey(func.func_name.ToLower()))
//base_cls.func_list.Remove(base_cls.func_list[func.func_name.ToLower()]);
continue;
base_cls.func_list.Add(func.func_name.ToLower(), func);
}
foreach(ClassEntry.PropEntry prop in cls.prop_list.Values) {
if (base_cls.prop_list.ContainsKey(prop.prop_name.ToLower()))
//base_cls.prop_list.Remove(base_cls.prop_list[prop.prop_name.ToLower()]);
continue;
base_cls.prop_list.Add(prop.prop_name.ToLower(), prop);
}
}
/// <summary>
/// Gets an <see cref="IList"/> of <c>hbm.xml</c> resources in the correct order.
/// </summary>
/// <returns>
/// An <see cref="IList"/> of <c>hbm.xml</c> resources in the correct order.
/// </returns>
public IList GetHbmFiles()
{
// tracks if any hbm.xml files make use of the "extends" attribute
bool containsExtends = false;
foreach( string fileName in _hbmResources )
{
Stream xmlInputStream = null;
XmlReader xmlReader = null;
try
{
xmlInputStream = _assembly.GetManifestResourceStream( fileName );
xmlReader = new XmlTextReader( xmlInputStream );
while( xmlReader.Read() )
{
if( xmlReader.NodeType != XmlNodeType.Element )
{
continue;
}
if( xmlReader.Name=="class" )
{
xmlReader.MoveToAttribute("name");
string className = StringHelper.GetClassname( xmlReader.Value );
ClassEntry ce = new ClassEntry( null, className, fileName );
_classes.Add(ce);
}
else if( xmlReader.Name=="joined-subclass" || xmlReader.Name=="subclass" )
{
xmlReader.MoveToAttribute("name");
string className = StringHelper.GetClassname( xmlReader.Value );
if( xmlReader.MoveToAttribute("extends") )
{
containsExtends = true;
string baseClassName = StringHelper.GetClassname( xmlReader.Value );
ClassEntry ce = new ClassEntry( baseClassName, className, fileName );
_classes.Add(ce);
}
}
}
}
finally
{
if( xmlReader!=null )
{
xmlReader.Close();
}
if( xmlInputStream!=null )
{
xmlInputStream.Close();
}
}
}
// only bother to do the sorting if one of the hbm files uses 'extends' -
// the sorting does quite a bit of looping through collections so if we don't
// need to spend the time doing that then don't bother.
if( containsExtends )
{
return OrderedHbmFiles( _classes );
}
else
{
return _hbmResources;
}
}
public override List <string> ExecuteSemanticAction(Stack <SemanticRecord> semanticRecordTable, Stack <SymbolTable> symbolTable, IToken lastToken, MoonCodeResult moonCode)
{
Stack <SemanticRecord> callChain = new Stack <SemanticRecord>();
List <string> errors = new List <string>();
if (!semanticRecordTable.Any())
{
errors.Add(string.Format("Grammar error at line {0}: could not verify factor for emtpy stack", lastToken.getLine()));
return(errors);
}
SemanticRecord lastRecord = semanticRecordTable.Pop();
// Accumulate semantic records until we reach the start of the factor
while (lastRecord.recordType != RecordTypes.FactorStart)
{
callChain.Push(lastRecord);
if (!semanticRecordTable.Any())
{
errors.Add(string.Format("Grammar error at {0}. Could not find start for a factor", lastToken.getLine()));
break;
}
lastRecord = semanticRecordTable.Pop();
}
SemanticRecord currentLink = callChain.Pop();
Entry linkedVariable = null;
// The first element in the chain is a reference to a locally accessible variable or function
// Go through symbol tables of increasing scope until we find the referenced identifier
foreach (SymbolTable table in symbolTable)
{
linkedVariable = table.GetEntries().FirstOrDefault(x => (x is VarParamEntry || x is FunctionEntry) && x.getName() == currentLink.getValue());
if (linkedVariable != null)
{
break;
}
}
// Verify the validity of this initial reference
bool success = VerifyLink(currentLink, linkedVariable, lastToken, errors);
// Go through the call chain and verify each link
while (callChain.Any() && success)
{
currentLink = callChain.Pop();
ClassEntry referredClass = ((VarParamEntry)linkedVariable).getVariable().getClass();
if (referredClass.getChild() == null)
{
errors.Add(string.Format("Identifier {0} cannot be reached at line {1}", currentLink.getValue(), lastToken.getLine()));
return(errors);
}
// Look in the referred class for the variable or function that is being referred to
linkedVariable = referredClass.getChild().GetEntries().FirstOrDefault(x => (x is VarParamEntry || x is FunctionEntry) && x.getName() == currentLink.getValue());
success = VerifyLink(currentLink, linkedVariable, lastToken, errors);
}
ClassEntry expressionType = new ClassEntry("undefined", 0);
// Find the linked variable and create a new expression for it
if (linkedVariable is VarParamEntry)
{
expressionType = ((VarParamEntry)linkedVariable).getVariable().getClass();
}
else if (linkedVariable is FunctionEntry)
{
expressionType = ((FunctionEntry)linkedVariable).GetReturnType();
}
if (linkedVariable == null)
{
errors.Add(string.Format("Grammar error: Could not link variable at line {0}", lastToken.getLine()));
}
else
{
semanticRecordTable.Push(new ExpressionRecord(expressionType, linkedVariable.getAddress()));
}
return(errors);
}
/// <summary>
/// Returns an <see cref="IList"/> of <c>hbm.xml</c> files in the order that ensures
/// base classes are loaded before their subclass/joined-subclass.
/// </summary>
/// <param name="unorderedClasses">An <see cref="IList"/> of <see cref="ClassEntry"/> objects.</param>
/// <returns>
/// An <see cref="IList"/> of <see cref="String"/> objects that contain the <c>hbm.xml</c> file names.
/// </returns>
private IList OrderedHbmFiles(IList unorderedClasses)
{
// Make sure joined-subclass mappings are loaded after base class
ArrayList sortedList = new ArrayList();
foreach (ClassEntry ce in unorderedClasses)
{
// this class extends nothing - so put it at the front of
// the list because it is safe to process at any time.
if (ce.BaseClassName == null)
{
sortedList.Insert(0, ce);
}
else
{
int insertIndex = -1;
// try to find this classes base class in the list already
for (int i = 0; i < sortedList.Count; i++)
{
ClassEntry sce = (ClassEntry)sortedList[i];
// base class was found - insert at the index
// immediately following it
if (sce.ClassName == ce.BaseClassName)
{
insertIndex = i + 1;
break;
}
}
// This Classes' baseClass was not found in the list so we still don't
// know where to insert it. Check to see if any of the classes that
// have already been sorted derive from this class.
if (insertIndex == -1)
{
for (int j = 0; j < sortedList.Count; j++)
{
ClassEntry sce = (ClassEntry)sortedList[j];
// A class already in the sorted list derives from this class so
// insert this class before the class deriving from it.
if (sce.BaseClassName == ce.ClassName)
{
insertIndex = j;
break;
}
}
}
// could not find any classes that were subclasses of this one or
// that this class was a subclass of so it should be inserted at
// then end.
if (insertIndex == -1)
{
// Insert at end
insertIndex = sortedList.Count;
}
sortedList.Insert(insertIndex, ce);
}
}
// now that we know the order the classes should be loaded - order the
// hbm.xml files those classes are contained in.
StringCollection loadedFiles = new StringCollection();
foreach (ClassEntry ce in sortedList)
{
// Check if this file already loaded (this can happen if
// we have mappings for multiple classes in one file).
if (loadedFiles.Contains(ce.FileName) == false)
{
loadedFiles.Add(ce.FileName);
}
}
return(loadedFiles);
}
/// <summary>
/// Gets an <see cref="IList"/> of <c>hbm.xml</c> resources in the correct order.
/// </summary>
/// <returns>
/// An <see cref="IList"/> of <c>hbm.xml</c> resources in the correct order.
/// </returns>
public IList GetHbmFiles()
{
// tracks if any hbm.xml files make use of the "extends" attribute
bool containsExtends = false;
foreach (string fileName in _hbmResources)
{
Stream xmlInputStream = null;
XmlReader xmlReader = null;
try
{
xmlInputStream = _assembly.GetManifestResourceStream(fileName);
xmlReader = new XmlTextReader(xmlInputStream);
while (xmlReader.Read())
{
if (xmlReader.NodeType != XmlNodeType.Element)
{
continue;
}
if (xmlReader.Name == "class")
{
xmlReader.MoveToAttribute("name");
string className = StringHelper.GetClassname(xmlReader.Value);
ClassEntry ce = new ClassEntry(null, className, fileName);
_classes.Add(ce);
}
else if (xmlReader.Name == "joined-subclass" || xmlReader.Name == "subclass")
{
xmlReader.MoveToAttribute("name");
string className = StringHelper.GetClassname(xmlReader.Value);
if (xmlReader.MoveToAttribute("extends"))
{
containsExtends = true;
string baseClassName = StringHelper.GetClassname(xmlReader.Value);
ClassEntry ce = new ClassEntry(baseClassName, className, fileName);
_classes.Add(ce);
}
}
}
}
finally
{
if (xmlReader != null)
{
xmlReader.Close();
}
if (xmlInputStream != null)
{
xmlInputStream.Close();
}
}
}
// only bother to do the sorting if one of the hbm files uses 'extends' -
// the sorting does quite a bit of looping through collections so if we don't
// need to spend the time doing that then don't bother.
if (containsExtends)
{
return(OrderedHbmFiles(_classes));
}
else
{
return(_hbmResources);
}
}
