private TypeClause ParseSingleTypeClause()
{
if (_tokenizer.Token == "(")
{
_tokenizer.Advance();
var clause = ParseTupleTypeClause();
RequireToken(")");
return(clause);
}
var name = ParseName();
Assert(Char.IsLetter(name[0]), "Letter expected");
if (Char.IsLower(name[0]))
{
return(new VariableTypeClause(name));
}
var list = new List <TypeClause>();
while (_tokenizer.Token != null && !ReservedKeywords.Contains(_tokenizer.Token) && _tokenizer.Token != ")" &&
_tokenizer.Token != "," && _tokenizer.Token != "->")
{
list.Add(ParseSimpleTypeClause());
}
return(new NamedTypeClause(name, list));
}
private Expression ParseDataTypeDeclarationExpression()
{
RequireToken("data");
var name = ParseName();
Assert(Char.IsUpper(name[0]), "Type names should start with an uppercase letter");
var arguments = new List <string>();
while (_tokenizer.Token != null && !ReservedKeywords.Contains(_tokenizer.Token))
{
var arg = ParseName();
Assert(Char.IsLower(arg[0]), "Type variable names should start with an lowercase letter");
arguments.Add(arg);
}
var constructors = new List <DataTypeConstructorDeclaration>();
while (_tokenizer.Token == "case")
{
constructors.Add(ParseDataTypeConstructorDeclaration());
}
return(new DataTypeDeclarationExpression(name, arguments, constructors));
}
private string ParseName()
{
Assert(_tokenizer.Token != null, "Name expected, but end-of-file found");
Assert(Char.IsLetter(_tokenizer.Token[0]) || _tokenizer.Token[0] == '_',
String.Format("Letter expected, but {0} found", _tokenizer.Token[0]));
Assert(_tokenizer.Token.Skip(1).All(x => Char.IsLetterOrDigit(x) || x == '_'), "Invalid character");
Assert(!ReservedKeywords.Contains(_tokenizer.Token),
String.Format("Non-keyword expected, but {0} found", _tokenizer.Token));
return(_tokenizer.Advance());
}
public static string QuoteObjectName(string str)
{
if (str.ToHashSet().IsSubsetOf(ValidObjectNameChars) && !ReservedKeywords.Contains(str.ToLower()))
{
return(str);
}
else
{
return("\"" + str + "\"");
}
}
private Expression ParseApplication()
{
var res = ParseUnaryMinusExpression();
while (_tokenizer.Token != null && !ReservedKeywords.Contains(_tokenizer.Token) &&
MayStartTerm(_tokenizer.Token[0]))
{
res = new ApplicationExpression(res, ParseTerm());
}
return(res);
}
/// <summary>
/// Append @ to all reserved keywords that appear on the given name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public string Mangle(string name)
{
var builder = new StringBuilder();
string[] names = name.Split(Dot);
for (int i = 0; i < names.Length; ++i)
{
if (ReservedKeywords.Contains(names[i]))
{
builder.Append(At);
}
builder.Append(names[i]);
builder.Append(Dot);
}
builder.Remove(builder.Length - 1, 1);
return(builder.ToString());
}
public string ResolveNameConflict(string tableNameHumanCase)
{
if (!_usedNames.ContainsKey(tableNameHumanCase))
{
_usedNames[tableNameHumanCase] = 0;
}
var toAdd = ReservedKeywords.Contains(tableNameHumanCase) || _usedNames[tableNameHumanCase] > 0;
if (!toAdd)
{
return(tableNameHumanCase);
}
var c = _usedNames[tableNameHumanCase];
_usedNames[tableNameHumanCase] = c + 1;
return(tableNameHumanCase + c.ToString());
}
private Pattern ParseBracketedPatternWithoutType()
{
var list = new List <Pattern>();
Assert(!ReservedKeywords.Contains(_tokenizer.Token), "Unexpected token: " + _tokenizer.Token);
if (_tokenizer.Token == ")" || _tokenizer.Token == ":")
{
return(new TuplePattern(list));
}
list.Add(ParseNestedPattern());
while (_tokenizer.Token == ",")
{
_tokenizer.Advance();
list.Add(ParsePattern());
}
return(list.Count == 1 ? list[0] : new TuplePattern(list));
}
private DataTypeConstructorDeclaration ParseDataTypeConstructorDeclaration()
{
RequireToken("case");
var name = ParseName();
Assert(Char.IsUpper(name[0]), "Constructor names should start with an uppercase letter");
if (_tokenizer.Token != "of")
{
return(new DataTypeConstructorDeclaration(name, new List <TypeClause>()));
}
RequireToken("of");
var arguments = new List <TypeClause>();
while (_tokenizer.Token != null && !ReservedKeywords.Contains(_tokenizer.Token))
{
arguments.Add(ParseTypeClause());
}
return(new DataTypeConstructorDeclaration(name, arguments));
}
private static string GetIdentifierName(string possibleIdentifier)
{
return(ReservedKeywords.Contains(possibleIdentifier, StringComparer.Ordinal)
? $"@{possibleIdentifier}"
: possibleIdentifier);
}
/*
*
* NOTE WHEN YOU ARE MAPPING THE XML TO C# TYPES
* [SCEHMANAME]:NIL = "TRUE" means that the property is nullable and you should mapping correctly to the nullable type
*
*/
public string Write(IEnumerable <Class> classInfo, string rootName)
{
StringBuilder sb = new StringBuilder();
// Add Top Comment
if (!string.IsNullOrEmpty(Comment))
{
if (!UsePascalCase)
{
if (ReservedKeywords.Contains(rootName)) // Check for reserved words in case no pascal
{
sb.AppendLine(string.Format(Comment, "@" + rootName));
}
else
{
sb.AppendLine(string.Format(Comment, rootName));
}
}
else
{
sb.AppendLine(string.Format(Comment, rootName.ToTitleCase()));
}
}
foreach (var @class in classInfo)
{
if (!RemoveXMLAttributes)
{
if (AddNamespaceAttributes)
{
sb.AppendFormat("[XmlRoot(ElementName=\"{0}\", Namespace=\"{1}\")]{2}", @class.XmlName, @class.Namespace, Environment.NewLine);
}
else
{
sb.AppendFormat("[XmlRoot(ElementName=\"{0}\")]{1}", @class.XmlName, Environment.NewLine);
}
}
if (UsePascalCase)
{
@class.Name = @class.Name.ToTitleCase();
}
if (!UsePascalCase) // Check for reserved words in case no pascal
{
if (ReservedKeywords.Contains(@class.Name))
{
@class.Name = "@" + @class.Name;
}
}
sb.AppendFormat("public class {0} {{ {1}", @class.Name, Environment.NewLine);
foreach (var field in @class.Fields)
{
if (!RemoveXMLAttributes)
{
if (AddNamespaceAttributes)
{
sb.AppendFormat("{3}\t[Xml{0}({0}Name=\"{1}\", Namespace=\"{2}\")] {3}", field.XmlType, field.XmlName, field.Namespace, Environment.NewLine);
}
else
{
sb.AppendFormat("{2}\t[Xml{0}({0}Name=\"{1}\")] {2}", field.XmlType, field.XmlName, Environment.NewLine);
}
}
if (UsePascalCase)
{
field.Name = field.Name.ToTitleCase();
if (field.Type.ToLower() == field.Name.ToLower())
{
field.Type = field.Name;
}
}
if (!UsePascalCase) // Check for reserved words in case no pascal
{
if (ReservedKeywords.Contains(field.Name))
{
field.Name = "@" + field.Name;
}
}
if (UseFields)
{
sb.AppendFormat("\tpublic {0} {1}; {2}", field.Type, field.Name, Environment.NewLine);
}
else
{
sb.AppendFormat("\tpublic {0} {1} {{ get; set; }} {2}", field.Type, field.Name, Environment.NewLine);
}
}
sb.AppendLine("}");
sb.AppendLine("");
}
return(sb.ToString());
}
public bool IsReservedKeyword(string text) => ReservedKeywords.Contains(text);
