private void GetStructDecl( TableDescriptor.StructDef structDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); string start = string.Format( "{0}public sealed class {1} : Brickred.Table.BaseStruct{2}" + "{0}{{{2}", indent, structDef.Name, this.newLineStr); string end = string.Format( "{0}}}{1}", indent, this.newLineStr); string fieldDecl; string parseFuncDecl; indent += " "; GetStructDeclFieldDecl( structDef, indent, out fieldDecl); GetStructDeclParseFunc( structDef, indent, out parseFuncDecl); sb.Append(start); if (fieldDecl != "") { sb.Append(fieldDecl); sb.Append(this.newLineStr); } sb.Append(parseFuncDecl); sb.Append(end); output = sb.ToString(); }
private string GenerateGlobalStructFile( TableDescriptor.StructDef structDef) { string dontEditComment; string namespaceDeclStart; string namespaceDeclEnd; string structDecl; string indent = ""; GetDontEditComment( out dontEditComment); GetNamespaceDecl( out namespaceDeclStart, out namespaceDeclEnd); if (namespaceDeclStart != "") { indent += " "; } GetStructDecl(structDef, indent, out structDecl); StringBuilder sb = new StringBuilder(); sb.Append(dontEditComment); sb.Append(this.newLineStr); sb.Append(namespaceDeclStart); sb.Append(structDecl); sb.Append(namespaceDeclEnd); return(sb.ToString()); }
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 GetStructDeclFieldDecl( TableDescriptor.StructDef structDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < structDef.Fields.Count; ++i) { TableDescriptor.StructDef.FieldDef fieldDef = structDef.Fields[i]; string csharpType = GetCSharpType(fieldDef); string defaultValue = GetCSharpTypeDefaultValue(fieldDef); sb.AppendFormat("{0}public {1} {2} = {3};{4}", indent, csharpType, fieldDef.Name, defaultValue, this.newLineStr); } output = sb.ToString(); }
private void GetStructDeclParseFunc( TableDescriptor.StructDef structDef, string indent, out string output) { StringBuilder sb = new StringBuilder(); string start = string.Format( "{0}public override bool Parse(string text){1}" + "{0}{{{1}", indent, this.newLineStr); string end = string.Format( "{0}}}{1}", indent, this.newLineStr); sb.Append(start); indent += " "; if (structDef.Fields.Count == 0) { sb.AppendFormat( "{0}return true;{1}", indent, this.newLineStr); } else { sb.AppendFormat( "{0}Brickred.Table.ColumnSpliter s ={1}" + "{0} new Brickred.Table.ColumnSpliter(text, ';');{1}" + "{1}", indent, this.newLineStr); for (int i = 0; i < structDef.Fields.Count; ++i) { TableDescriptor.StructDef.FieldDef fieldDef = structDef.Fields[i]; if (fieldDef.Type == FieldType.Int) { sb.AppendFormat( "{0}if (s.NextInt(ref this.{1}) == false) {{{2}" + "{0} return false;{2}" + "{0}}}{2}", indent, fieldDef.Name, this.newLineStr); } else if (fieldDef.Type == FieldType.String) { sb.AppendFormat( "{0}if (s.NextString(ref this.{1}) == false) {{{2}" + "{0} return false;{2}" + "{0}}}{2}", indent, fieldDef.Name, this.newLineStr); } } sb.AppendFormat( "{0}if (s.NextString()) {{{1}" + "{0} return false;{1}" + "{0}}}{1}" + "{1}" + "{0}return true;{1}", indent, this.newLineStr); } sb.Append(end); output = sb.ToString(); }
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 bool AddStructFieldDef( TableDescriptor.StructDef structDef, XElement element) { // check name attr string name; { XAttribute attr = element.Attribute("name"); if (attr == null) { PrintLineError(element, "`field` node must contain a `name` attribute"); return(false); } name = attr.Value; } if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false) { PrintLineError(element, "`field` node `name` attribute is invalid"); return(false); } if (structDef.FieldNameIndex.ContainsKey(name)) { PrintLineError(element, "`field` node `name` attribute duplicated"); return(false); } // check type attr string type; { XAttribute attr = element.Attribute("type"); if (attr == null) { PrintLineError(element, "`field` node must contain a `type` attribute"); return(false); } type = attr.Value; } TableDescriptor.StructDef.FieldDef def = new TableDescriptor.StructDef.FieldDef(); def.ParentRef = structDef; def.Name = name; def.LineNumber = GetLineNumber(element); if (type == "int") { def.Type = TableDescriptor.StructDef.FieldType.Int; } else if (type == "string") { def.Type = TableDescriptor.StructDef.FieldType.String; } else { PrintLineError(element, "type `{0}` is invalid", type); return(false); } structDef.Fields.Add(def); structDef.FieldNameIndex.Add(def.Name, def); return(true); }
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); }
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); }