private string GenerateTableFile(
TableDescriptor.TableDef tableDef)
{
string dontEditComment;
string namespaceDeclStart;
string namespaceDeclEnd;
string tableDecl;
string indent = "";
GetDontEditComment(
out dontEditComment);
GetNamespaceDecl(
out namespaceDeclStart, out namespaceDeclEnd);
if (namespaceDeclStart != "")
{
indent += " ";
}
GetTableDecl(tableDef, indent,
out tableDecl);
StringBuilder sb = new StringBuilder();
sb.Append(dontEditComment);
sb.Append(this.newLineStr);
sb.Append(namespaceDeclStart);
sb.Append(tableDecl);
sb.Append(namespaceDeclEnd);
return(sb.ToString());
}
private void GetTableDeclParseFuncSingleKeyReadDataLine(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
string parseColumns;
GetTableDeclParseFuncParseColumns(
tableDef, indent + " ", out parseColumns);
output = string.Format(
"{0}// read data lines{1}" +
"{0}int lineNumber = 3;{1}" +
"{0}this.rows.Clear();{1}" +
"{0}for (;;) {{{1}" +
"{0} lineBuffer = r.NextLine();{1}" +
"{0} if (lineBuffer == null) {{{1}" +
"{0} break;{1}" +
"{0} }}{1}" +
"{0} if (lineBuffer.Count != columnCountReq) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} column count {{1}} is invalid, " +
"should be {{2}}\",{1}" +
"{0} lineNumber, lineBuffer.Count, " +
"columnCountReq);{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{0} if (lineBuffer[{2}].Length == 0) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} key `{3}` is empty\", " +
"lineNumber);{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{1}" +
"{0} Row row = new Row();{1}" +
"{0} int colNumber = 0;{1}" +
"{1}" +
"{4}" +
"{1}" +
"{0} if (GetRow(row.{3}) != null) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} key `{3}` value {{1}} is duplicated\", " +
"lineNumber, row.{3});{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{1}" +
"{0} this.rows.Add(row.{3}, row);{1}" +
"{1}" +
"{0} lineNumber += 1;{1}" +
"{0}}}{1}" +
"{1}",
indent, this.newLineStr,
tableDef.TableKeyColumnIndex, tableDef.TableKey.Name,
parseColumns);
}
public override bool Generate(
TableDescriptor descriptor, string reader,
string outputDir, NewLineType newLineType)
{
this.descriptor = descriptor;
this.reader = reader;
if (newLineType == NewLineType.Dos)
{
this.newLineStr = "\r\n";
}
else
{
this.newLineStr = "\n";
}
for (int i = 0; i < this.descriptor.GlobalStructs.Count; ++i)
{
TableDescriptor.StructDef def =
this.descriptor.GlobalStructs[i];
string filePath = Path.Combine(
outputDir, def.Name + ".cs");
string fileContent = GenerateGlobalStructFile(def);
try {
File.WriteAllText(filePath, fileContent);
} catch (Exception e) {
Console.Error.WriteLine(string.Format(
"error: write file {0} failed: {1}",
filePath, e.Message));
return(false);
}
}
for (int i = 0; i < this.descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef def = this.descriptor.Tables[i];
string filePath = Path.Combine(
outputDir, def.Name + ".cs");
string fileContent = GenerateTableFile(def);
try {
File.WriteAllText(filePath, fileContent);
} catch (Exception e) {
Console.Error.WriteLine(string.Format(
"error: write file {0} failed: {1}",
filePath, e.Message));
return(false);
}
}
return(true);
}
private void GetTableDeclParseFuncReadNameLine(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
string start = string.Format(
"{0}// read name line{1}" +
"{0}lineBuffer = r.NextLine();{1}" +
"{0}if (lineBuffer == null) {{{1}" +
"{0} errorInfo = \"name line is required\";{1}" +
"{0} return false;{1}" +
"{0}}}{1}" +
"{0}if (lineBuffer.Count != columnCountReq) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"name line column count {{0}} is invalid," +
" should be {{1}}\",{1}" +
"{0} lineBuffer.Count, columnCountReq);{1}" +
"{0} return false;{1}" +
"{0}}}{1}" +
"{0}{{{1}" +
"{0} int colNumber = 0;{1}" +
"{1}",
indent, this.newLineStr);
string end = string.Format(
"{0}}}{1}" +
"{1}",
indent, this.newLineStr);
sb.Append(start);
indent += " ";
for (int i = 0; i < tableDef.Columns.Count; ++i)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[i];
sb.AppendFormat(
"{0}if (lineBuffer[colNumber++] != \"{1}\") {{{2}" +
"{0} errorInfo = string.Format({2}" +
"{0} \"column {{0}} should be named as `{1}`\"," +
" colNumber);{2}" +
"{0} return false;{2}" +
"{0}}}{2}",
indent, columnDef.Name, this.newLineStr);
}
sb.Append(end);
output = sb.ToString();
}
private void GetTableDeclParseFunc(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
string start = string.Format(
"{0}public bool Parse(string text, out string errorInfo){1}" +
"{0}{{{1}" +
"{0} Brickred.Table.LineReader r = " +
"new Brickred.Table.LineReader(text);{1}" +
"{0} System.Collections.Generic.List<string> lineBuffer = " +
"null;{1}" +
"{0} int columnCountReq = {2};{1}" +
"{1}",
indent, this.newLineStr, tableDef.Columns.Count);
string end = string.Format(
"{0} errorInfo = \"\";{1}" +
"{0} return true;{1}" +
"{0}}}{1}",
indent, this.newLineStr);
string readCommentLine;
string readNameLine;
string readDataLine = "";
indent += " ";
GetTableDeclParseFuncReadCommentLine(
tableDef, indent, out readCommentLine);
GetTableDeclParseFuncReadNameLine(
tableDef, indent, out readNameLine);
if (tableDef.TableKeyType == TableKeyType.SingleKey)
{
GetTableDeclParseFuncSingleKeyReadDataLine(
tableDef, indent, out readDataLine);
}
else if (tableDef.TableKeyType == TableKeyType.SetKey)
{
GetTableDeclParseFuncSetKeyReadDataLine(
tableDef, indent, out readDataLine);
}
sb.Append(start);
sb.Append(readCommentLine);
sb.Append(readNameLine);
sb.Append(readDataLine);
sb.Append(end);
output = sb.ToString();
}
private void CalculateTableKeyColumnIndex(
TableDescriptor.TableDef tableDef)
{
for (int i = 0; i < tableDef.Columns.Count; ++i)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[i];
if (columnDef == tableDef.TableKey)
{
tableDef.TableKeyColumnIndex = i;
return;
}
}
}
private void GetTableDeclGetRowFunc(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
output = string.Format(
"{0}public Row GetRow({1} key){2}" +
"{0}{{{2}" +
"{0} Row row = null;{2}" +
"{0} if (this.rows.TryGetValue(key, out row) == false) {{{2}" +
"{0} return null;{2}" +
"{0} }}{2}" +
"{2}" +
"{0} return row;{2}" +
"{0}}}{2}",
indent, GetCSharpType(tableDef.TableKey), this.newLineStr);
}
private void GetTableDeclGetRowSetFunc(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
output = string.Format(
"{0}public System.Collections.Generic.List<Row> GetRowSet({1} key){2}" +
"{0}{{{2}" +
"{0} System.Collections.Generic.List<Row> rowSet = null;{2}" +
"{0} if (this.rowSets.TryGetValue(key, out rowSet) == false) {{{2}" +
"{0} return null;{2}" +
"{0} }}{2}" +
"{2}" +
"{0} return rowSet;{2}" +
"{0}}}{2}",
indent, GetCSharpType(tableDef.TableKey), this.newLineStr);
}
private void GetTableDeclRowClassDecl(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
string start = string.Format(
"{0}public sealed class Row{1}" +
"{0}{{{1}",
indent, this.newLineStr);
string end = string.Format(
"{0}}}{1}",
indent, this.newLineStr);
indent += " ";
sb.Append(start);
for (int i = 0; i < tableDef.Columns.Count; ++i)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[i];
string csharpType = GetCSharpType(columnDef);
string defaultValue = GetCSharpTypeDefaultValue(columnDef);
if (defaultValue.Length > 10)
{
sb.AppendFormat(
"{0}public {1} {2} ={4}" +
"{0} {3};{4}",
indent, csharpType, columnDef.Name, defaultValue,
this.newLineStr);
}
else
{
sb.AppendFormat("{0}public {1} {2} = {3};{4}",
indent, csharpType, columnDef.Name, defaultValue,
this.newLineStr);
}
}
sb.Append(end);
output = sb.ToString();
}
private void GetTableDeclParseFuncReadCommentLine(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
output = string.Format(
"{0}// read comment line{1}" +
"{0}lineBuffer = r.NextLine();{1}" +
"{0}if (lineBuffer == null) {{{1}" +
"{0} errorInfo = \"comment line is required\";{1}" +
"{0} return false;{1}" +
"{0}}}{1}" +
"{0}if (lineBuffer.Count != columnCountReq) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"comment line column count {{0}} is invalid," +
" should be {{1}}\",{1}" +
"{0} lineBuffer.Count, columnCountReq);{1}" +
"{0} return false;{1}" +
"{0}}}{1}" +
"{1}",
indent, this.newLineStr);
}
private void GetTableDeclMemberDecl(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
if (tableDef.TableKeyType == TableKeyType.SingleKey)
{
sb.AppendFormat(
"{0}public System.Collections.Generic.SortedDictionary" +
"<{1}, Row> rows ={2}" +
"{0} new System.Collections.Generic.SortedDictionary" +
"<{1}, Row>();{2}" +
"{0}public System.Collections.Generic.SortedDictionary" +
"<{1}, Row> Rows{2}" +
"{0}{{{2}" +
"{0} get {{ return this.rows; }}{2}" +
"{0}}}{2}",
indent, GetCSharpType(tableDef.TableKey), this.newLineStr);
}
else if (tableDef.TableKeyType == TableKeyType.SetKey)
{
sb.AppendFormat(
"{0}public System.Collections.Generic.SortedDictionary<{2}" +
"{0} {1}, System.Collections.Generic.List<Row>> rowSets ={2}" +
"{0} new System.Collections.Generic.SortedDictionary<{2}" +
"{0} {1}, System.Collections.Generic.List<Row>>();{2}" +
"{0}public System.Collections.Generic.SortedDictionary<{2}" +
"{0} {1}, System.Collections.Generic.List<Row>> RowSets{2}" +
"{0}{{{2}" +
"{0} get {{ return this.rowSets; }}{2}" +
"{0}}}{2}",
indent, GetCSharpType(tableDef.TableKey), this.newLineStr);
}
output = sb.ToString();
}
private bool AddTableDef(XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(element,
"`table` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(element,
"`table` node `name` attribute is invalid");
return(false);
}
if (this.descriptor.TableNameIndex.ContainsKey(name) ||
this.descriptor.GlobalStructNameIndex.ContainsKey(name))
{
PrintLineError(element,
"`table` node `name` attribute duplicated");
return(false);
}
TableDescriptor.TableDef def =
new TableDescriptor.TableDef();
def.Name = name;
def.LineNumber = GetLineNumber(element);
{
IEnumerator <XElement> iter =
element.Elements().GetEnumerator();
while (iter.MoveNext())
{
XElement childElement = iter.Current;
if (childElement.Name == "struct")
{
// parse local struct
if (AddStructDef(def, childElement) == false)
{
return(false);
}
}
else if (childElement.Name == "col")
{
// parse column
if (AddTableColumnDef(def, childElement) == false)
{
return(false);
}
}
else
{
PrintLineError(childElement,
"expect a `struct` or `col` node");
return(false);
}
}
}
// check key/setkey attr
{
string key;
XAttribute attr = element.Attribute("key");
if (attr != null)
{
key = attr.Value;
def.TableKeyType =
TableDescriptor.TableDef.KeyType.SingleKey;
}
else
{
attr = element.Attribute("setkey");
if (attr != null)
{
key = attr.Value;
def.TableKeyType =
TableDescriptor.TableDef.KeyType.SetKey;
}
else
{
PrintLineError(element,
"`table` node must contain a " +
"`key` or `setkey` attribute");
return(false);
}
}
TableDescriptor.TableDef.ColumnDef tableKey = null;
if (def.ColumnNameIndex.TryGetValue(
key, out tableKey) == false)
{
PrintLineError(element,
"table key `{0}` is not defined", key);
return(false);
}
if (tableKey.Type != TableDescriptor.TableDef.ColumnType.Int &&
tableKey.Type != TableDescriptor.TableDef.ColumnType.String)
{
PrintLineError(element,
"table key can only be `int` or `string` type");
return(false);
}
def.TableKey = tableKey;
}
// check file attr
{
XAttribute attr = element.Attribute("file");
if (attr == null)
{
PrintLineError(element,
"`table` node must contain a `file` attribute");
return(false);
}
def.FileName = attr.Value;
}
// check readby attr
{
XAttribute attr = element.Attribute("readby");
if (attr != null)
{
string[] readers = attr.Value.Split('|');
for (int i = 0; i < readers.Length; ++i)
{
string reader = readers[i];
TableDescriptor.ReaderDef readerDef = null;
if (this.descriptor.Readers.TryGetValue(
reader, out readerDef) == false)
{
PrintLineError(element,
"reader `{0}` is not defined", reader);
return(false);
}
def.Readers[reader] = readerDef;
}
}
}
CalculateTableKeyColumnIndex(def);
this.descriptor.Tables.Add(def);
this.descriptor.TableNameIndex.Add(def.Name, def);
return(true);
}
public bool FilterByReader(string reader)
{
if (this.descriptor == null)
{
return(false);
}
if (this.descriptor.Readers.ContainsKey(reader) == false)
{
Console.Error.WriteLine(string.Format(
"error: reader `{0}` is not defined", reader));
return(false);
}
// remove unread tables
List <TableDescriptor.TableDef> filteredTables =
new List <TableDescriptor.TableDef>();
for (int i = 0; i < this.descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef tableDef =
this.descriptor.Tables[i];
if (tableDef.Readers.Count == 0 ||
tableDef.Readers.ContainsKey(reader))
{
filteredTables.Add(tableDef);
}
else
{
this.descriptor.TableNameIndex.Remove(tableDef.Name);
}
}
this.descriptor.Tables = filteredTables;
// remove unread columns
for (int i = 0; i < this.descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef tableDef =
this.descriptor.Tables[i];
List <TableDescriptor.TableDef.ColumnDef> filteredColumns =
new List <TableDescriptor.TableDef.ColumnDef>();
for (int j = 0; j < tableDef.Columns.Count; ++j)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[j];
if (columnDef == tableDef.TableKey ||
columnDef.Readers.Count == 0 ||
columnDef.Readers.ContainsKey(reader))
{
filteredColumns.Add(columnDef);
}
else
{
tableDef.ColumnNameIndex.Remove(columnDef.Name);
}
}
tableDef.Columns = filteredColumns;
CalculateTableKeyColumnIndex(tableDef);
}
// collect used structs
Dictionary <TableDescriptor.StructDef, bool> usedStructs =
new Dictionary <TableDescriptor.StructDef, bool>();
for (int i = 0; i < this.descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef tableDef =
this.descriptor.Tables[i];
for (int j = 0; j < tableDef.Columns.Count; ++j)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[j];
if (columnDef.RefStructDef != null)
{
usedStructs[columnDef.RefStructDef] = true;
}
}
}
// remove unused global structs
List <TableDescriptor.StructDef> filteredGlobalStructs =
new List <TableDescriptor.StructDef>();
for (int i = 0; i < this.descriptor.GlobalStructs.Count; ++i)
{
TableDescriptor.StructDef structDef =
this.descriptor.GlobalStructs[i];
if (usedStructs.ContainsKey(structDef))
{
filteredGlobalStructs.Add(structDef);
}
else
{
this.descriptor.GlobalStructNameIndex.Remove(
structDef.Name);
}
}
this.descriptor.GlobalStructs = filteredGlobalStructs;
// remove unused local structs
for (int i = 0; i < this.descriptor.Tables.Count; ++i)
{
TableDescriptor.TableDef tableDef =
this.descriptor.Tables[i];
List <TableDescriptor.StructDef> filteredLocalStructs =
new List <TableDescriptor.StructDef>();
for (int j = 0; j < tableDef.LocalStructs.Count; ++j)
{
TableDescriptor.StructDef structDef =
tableDef.LocalStructs[j];
if (usedStructs.ContainsKey(structDef))
{
filteredLocalStructs.Add(structDef);
}
else
{
tableDef.LocalStructNameIndex.Remove(structDef.Name);
}
}
tableDef.LocalStructs = filteredLocalStructs;
}
return(true);
}
private void GetTableDeclParseFuncParseColumns(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < tableDef.Columns.Count; ++i)
{
TableDescriptor.TableDef.ColumnDef columnDef =
tableDef.Columns[i];
ColumnType checkType;
if (columnDef.Type == ColumnType.List)
{
checkType = columnDef.ListType;
}
else
{
checkType = columnDef.Type;
}
bool isList = (columnDef.Type == ColumnType.List);
if (checkType == ColumnType.Int)
{
if (isList)
{
sb.AppendFormat(
"{0}Brickred.Table.Util.ReadColumnIntList(" +
"lineBuffer[colNumber++], ref row.{1});{2}",
indent, columnDef.Name, this.newLineStr);
}
else
{
sb.AppendFormat(
"{0}row.{1} = Brickred.Table.Util.Atoi(" +
"lineBuffer[colNumber++]);{2}",
indent, columnDef.Name, this.newLineStr);
}
}
else if (checkType == ColumnType.String)
{
if (isList)
{
sb.AppendFormat(
"{0}Brickred.Table.Util.ReadColumnStringList(" +
"lineBuffer[colNumber++], ref row.{1});{2}",
indent, columnDef.Name, this.newLineStr);
}
else
{
sb.AppendFormat(
"{0}row.{1} = lineBuffer[colNumber++];{2}",
indent, columnDef.Name, this.newLineStr);
}
}
else if (checkType == ColumnType.Struct)
{
if (isList)
{
sb.AppendFormat(
"{0}if (Brickred.Table.Util.ReadColumnStructList({1}" +
"{0} lineBuffer[colNumber++], ref row.{2}) " +
"== false) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} column `{2}` value is invalid\", " +
"lineNumber);{1}" +
"{0} return false;{1}" +
"{0}}}{1}",
indent, this.newLineStr, columnDef.Name);
}
else
{
sb.AppendFormat(
"{0}if (row.{1}.Parse(" +
"lineBuffer[colNumber++]) == false) {{{2}" +
"{0} errorInfo = string.Format({2}" +
"{0} \"line {{0}} column `{1}` value is invalid\", " +
"lineNumber);{2}" +
"{0} return false;{2}" +
"{0}}}{2}",
indent, columnDef.Name, this.newLineStr);
}
}
}
output = sb.ToString();
}
private void GetTableDeclParseFuncSetKeyReadDataLine(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
string parseColumns;
GetTableDeclParseFuncParseColumns(
tableDef, indent + " ", out parseColumns);
string keyDefine = "";
if (tableDef.TableKey.Type == ColumnType.Int)
{
keyDefine = "int key = Brickred.Table.Util.Atoi(keyStr)";
}
else if (tableDef.TableKey.Type == ColumnType.String)
{
keyDefine = "string key = keyStr";
}
output = string.Format(
"{0}// read data lines{1}" +
"{0}int lineNumber = 3;{1}" +
"{0}string lastKey = \"\";{1}" +
"{0}this.rowSets.Clear();{1}" +
"{0}for (;;) {{{1}" +
"{0} lineBuffer = r.NextLine();{1}" +
"{0} if (lineBuffer == null) {{{1}" +
"{0} break;{1}" +
"{0} }}{1}" +
"{0} if (lineBuffer.Count != columnCountReq) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} column count {{1}} is invalid, " +
"should be {{2}}\",{1}" +
"{0} lineNumber, lineBuffer.Count, " +
"columnCountReq);{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{1}" +
"{0} string keyStr = lineBuffer[{2}];{1}" +
"{0} if (keyStr.Length == 0) {{{1}" +
"{0} if (lastKey.Length > 0) {{{1}" +
"{0} keyStr = lastKey;{1}" +
"{0} }} else {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} key `{3}` is empty\", " +
"lineNumber);{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{0} }}{1}" +
"{1}" +
"{0} Row row = new Row();{1}" +
"{0} int colNumber = 0;{1}" +
"{1}" +
"{4}" +
"{1}" +
"{0} {5};{1}" +
"{0} if (keyStr != lastKey) {{{1}" +
"{0} if (GetRowSet(key) != null) {{{1}" +
"{0} errorInfo = string.Format({1}" +
"{0} \"line {{0}} key `{3}` value {{1}} is duplicated\",{1} " +
"{0} lineNumber, row.{3});{1}" +
"{0} return false;{1}" +
"{0} }}{1}" +
"{0} System.Collections.Generic.List<Row> rowSet ={1}" +
"{0} new System.Collections.Generic.List<Row>();{1}" +
"{0} rowSet.Add(row);{1}" +
"{0} this.rowSets.Add(key, rowSet);{1}" +
"{0} lastKey = keyStr;{1}" +
"{0} }} else {{{1}" +
"{0} this.rowSets[key].Add(row);{1}" +
"{0} }}{1}" +
"{1}" +
"{0} lineNumber += 1;{1}" +
"{0}}}{1}" +
"{1}",
indent, this.newLineStr,
tableDef.TableKeyColumnIndex, tableDef.TableKey.Name,
parseColumns, keyDefine);
}
private bool AddTableColumnDef(
TableDescriptor.TableDef tableDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(element,
"`col` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(element,
"`col` node `name` attribute is invalid");
return(false);
}
if (tableDef.ColumnNameIndex.ContainsKey(name))
{
PrintLineError(element,
"`col` node `name` attribute duplicated");
return(false);
}
// check type attr
string type;
{
XAttribute attr = element.Attribute("type");
if (attr == null)
{
PrintLineError(element,
"`col` node must contain a `type` attribute");
return(false);
}
type = attr.Value;
}
TableDescriptor.TableDef.ColumnDef def =
new TableDescriptor.TableDef.ColumnDef();
def.ParentRef = tableDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
// get type info
string columnTypeStr = type;
{
Match m = Regex.Match(type, @"^list{(.+)}$");
if (m.Success)
{
columnTypeStr = m.Groups[1].Value;
def.Type = TableDescriptor.TableDef.ColumnType.List;
}
}
TableDescriptor.TableDef.ColumnType columnType =
TableDescriptor.TableDef.ColumnType.None;
if (columnTypeStr == "int")
{
columnType = TableDescriptor.TableDef.ColumnType.Int;
}
else if (columnTypeStr == "string")
{
columnType = TableDescriptor.TableDef.ColumnType.String;
}
else
{
for (;;)
{
TableDescriptor.StructDef refStructDef = null;
// check is local struct
if (tableDef.LocalStructNameIndex.TryGetValue(
columnTypeStr, out refStructDef))
{
columnType = TableDescriptor.TableDef.ColumnType.Struct;
def.RefStructDef = refStructDef;
break;
}
// check is global struct
if (this.descriptor.GlobalStructNameIndex.TryGetValue(
columnTypeStr, out refStructDef))
{
columnType = TableDescriptor.TableDef.ColumnType.Struct;
def.RefStructDef = refStructDef;
break;
}
PrintLineError(element,
"type `{0}` is undefined", columnTypeStr);
return(false);
}
}
if (def.Type == TableDescriptor.TableDef.ColumnType.List)
{
def.ListType = columnType;
}
else
{
def.Type = columnType;
}
// check readby attr
{
XAttribute attr = element.Attribute("readby");
if (attr != null)
{
string[] readers = attr.Value.Split('|');
for (int i = 0; i < readers.Length; ++i)
{
string reader = readers[i];
TableDescriptor.ReaderDef readerDef = null;
if (this.descriptor.Readers.TryGetValue(
reader, out readerDef) == false)
{
PrintLineError(element,
"reader `{0}` is not defined", reader);
return(false);
}
def.Readers[reader] = readerDef;
}
}
}
tableDef.Columns.Add(def);
tableDef.ColumnNameIndex.Add(def.Name, def);
return(true);
}
private void GetTableDecl(
TableDescriptor.TableDef tableDef,
string indent, out string output)
{
StringBuilder sb = new StringBuilder();
string start = string.Format(
"{0}public sealed class {1}{2}" +
"{0}{{{2}",
indent, tableDef.Name, this.newLineStr);
string end = string.Format(
"{0}}}{1}",
indent, this.newLineStr);
string rowClassDecl;
string memberDecl;
string parseFuncDecl;
string getRowFuncDecl = "";
indent += " ";
GetTableDeclRowClassDecl(
tableDef, indent, out rowClassDecl);
GetTableDeclMemberDecl(
tableDef, indent, out memberDecl);
GetTableDeclParseFunc(
tableDef, indent, out parseFuncDecl);
if (tableDef.TableKeyType == TableKeyType.SingleKey)
{
GetTableDeclGetRowFunc(
tableDef, indent, out getRowFuncDecl);
}
else if (tableDef.TableKeyType == TableKeyType.SetKey)
{
GetTableDeclGetRowSetFunc(
tableDef, indent, out getRowFuncDecl);
}
sb.Append(start);
for (int i = 0; i < tableDef.LocalStructs.Count; ++i)
{
string decl;
GetStructDecl(tableDef.LocalStructs[i],
indent, out decl);
sb.Append(decl);
sb.Append(this.newLineStr);
}
if (rowClassDecl != "")
{
sb.Append(rowClassDecl);
sb.Append(this.newLineStr);
}
sb.Append(memberDecl);
sb.Append(this.newLineStr);
sb.Append(parseFuncDecl);
sb.Append(this.newLineStr);
sb.Append(getRowFuncDecl);
sb.Append(end);
output = sb.ToString();
}
private bool AddStructDef(
TableDescriptor.TableDef tableDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(element,
"`struct` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(element,
"`struct` node `name` attribute is invalid");
return(false);
}
if (tableDef == null)
{
if (this.descriptor.GlobalStructNameIndex.ContainsKey(name) ||
this.descriptor.TableNameIndex.ContainsKey(name))
{
PrintLineError(element,
"`struct` node `name` attribute duplicated");
return(false);
}
}
else
{
if (tableDef.LocalStructNameIndex.ContainsKey(name))
{
PrintLineError(element,
"`struct` node `name` attribute duplicated");
return(false);
}
if (name == "Row" ||
name == "Rows" ||
name == "RowSet" ||
name == "RowSets")
{
PrintLineError(element,
"local struct can not be named as " +
"`Row`, `Rows`, `RowSet` or `RowSets`");
return(false);
}
}
TableDescriptor.StructDef def =
new TableDescriptor.StructDef();
def.ParentRef = tableDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
// parse fields
{
IEnumerator <XElement> iter =
element.Elements().GetEnumerator();
while (iter.MoveNext())
{
XElement childElement = iter.Current;
if (childElement.Name != "field")
{
PrintLineError(childElement,
"expect a `field` node");
return(false);
}
if (AddStructFieldDef(def, childElement) == false)
{
return(false);
}
}
}
if (tableDef == null)
{
this.descriptor.GlobalStructs.Add(def);
this.descriptor.GlobalStructNameIndex.Add(def.Name, def);
}
else
{
tableDef.LocalStructs.Add(def);
tableDef.LocalStructNameIndex.Add(def.Name, def);
}
return(true);
}