void AddRelation(Entity a, Entity b, Hashtable h) {
ResSet r = (ResSet)h[a];
if (r == null) {
r = new ResSet();
h[a] = r;
}
r.Add(b);
}
private Hashtable setupTable (Type type, RdpPattern p)
{
if (patternPool == null) // could be null for RdpElement etc.
patternPool = new Hashtable ();
Hashtable typePool = (Hashtable) patternPool [type];
if (typePool == null) {
typePool = new Hashtable ();
patternPool [type] = typePool;
}
Hashtable pTable = (Hashtable) typePool [p];
if (pTable == null) {
pTable = new Hashtable ();
typePool [p] = pTable;
}
return pTable;
}
public LiteralDTMap(Hashtable t, StatementSink s) { ranges = t; sink = s; }
// over 4.5, Hash define is Dictionary.
// below Unity 4.5, WWW only supports Hashtable.
// Unity 4.5, 4.6 WWW supports Dictionary and [Obsolete]Hashtable but WWWForm.content is Hashtable.
// Unity 5.0 WWW only supports Dictionary and WWWForm.content is also Dictionary.
#if !(UNITY_METRO || UNITY_WP8) && (UNITY_4_5 || UNITY_4_6 || UNITY_4_7)
static Hash MergeHash(Hashtable wwwFormHeaders, Hash externalHeaders)
{
var newHeaders = new Hash();
foreach (DictionaryEntry item in wwwFormHeaders)
{
newHeaders[item.Key.ToString()] = item.Value.ToString();
}
foreach (HashEntry item in externalHeaders)
{
newHeaders[item.Key] = item.Value;
}
return newHeaders;
}
public static void Generate(String[] args,IFileCreationObserver fileCreationObserver)
{
//this has to change... dirty things during porting
ClassMapping.ResetComponents();
nsmgr = new XmlNamespaceManager(new NameTable());
nsmgr.AddNamespace("urn", "urn:nhibernate-mapping-2.2");
children = new ArrayList();
allMaps = new MultiMap();
ArrayList mappingFiles = new ArrayList();
string outputDir = null;
SupportClass.ListCollectionSupport generators = new SupportClass.ListCollectionSupport();
MultiMap globalMetas = new MultiHashMap();
// parse command line parameters
cmdLine = new Hbm2NetParameters(args);
try
{
cmdLine.Parse();
if (0 == cmdLine.FileNames.Count())
{
Console.Error.WriteLine("No input file(s) specified");
throw new NotEnougthParametersException();
}
}
catch (NotEnougthParametersException)
{
Console.Error.WriteLine(string.Format("Use:hbm2net {0} files.hbm.xml ( wildcards allowed )",cmdLine.GetShortHelp()));
Console.Error.WriteLine(cmdLine.GetHelp());
Environment.Exit(-1);
}
if (!string.IsNullOrEmpty(cmdLine.ConfigFile))
{
if (File.Exists(cmdLine.ConfigFile))
{
try
{
FileInfo configFile = new FileInfo(cmdLine.ConfigFile);
// parse config xml file
Document document = new XmlDocument();
document.Load(configFile.FullName);
var cfgValidator = new ConfigurationValidator();
cfgValidator.Validate(document);
if (!string.IsNullOrEmpty(cfgValidator.WarningMessage))
{
log.Warn("Configuration:" + cfgValidator.WarningMessage);
}
globalMetas = MetaAttributeHelper.LoadAndMergeMetaMap((document["codegen"]), null);
IEnumerator generateElements = document["codegen"].SelectNodes("generate").GetEnumerator();
while (generateElements.MoveNext())
{
generators.Add(new Generator(configFile.Directory, (Element)generateElements.Current));
}
}
catch (ConfigurationValidationException validationException)
{
Console.Error.WriteLine("Error validating configuration file:" + validationException.Message);
Environment.Exit(-1);
}
catch (Exception genericException)
{
Console.Error.WriteLine("Error reading configuration file:" + genericException.Message);
Environment.Exit(-1);
}
}
else
{
log.Error("Configuration file:" + cmdLine.ConfigFile + " does not exist");
Environment.Exit(-1);
}
}
if (generators.Count == 0)
{
log.Info("No configuration file specified: using T4 generator with default template.");
T4Render t4 = new T4Render();
t4.Configure(new DirectoryInfo(Directory.GetCurrentDirectory()), new NameValueCollection());
generators.Add(new Generator(t4));
}
if (!string.IsNullOrEmpty(cmdLine.OutputDir))
{
outputDir = cmdLine.OutputDir;
}
foreach (string inFile in cmdLine.FileNames)
{
if (inFile.IndexOf("*") > -1)
{
mappingFiles.AddRange(GetFiles(inFile));
}
else
{
mappingFiles.Add(inFile);
}
}
Hashtable classMappings = new Hashtable();
for (IEnumerator iter = mappingFiles.GetEnumerator(); iter.MoveNext(); )
{
log.Info(iter.Current.ToString());
string mappingFile = (string)iter.Current;
if (!Path.IsPathRooted(mappingFile))
{
mappingFile = Path.Combine(Environment.CurrentDirectory, mappingFile);
}
if (!File.Exists(mappingFile))
throw new FileNotFoundException("Mapping file does not exist.", mappingFile);
// parse the mapping file
NameTable nt = new NameTable();
nt.Add("urn:nhibernate-mapping-2.2");
Document document = new XmlDocument(nt);
document.Load(mappingFile);
FileInfo mappingFileInfo = new FileInfo(mappingFile);
SourceFileInfoMap.Instance.Add(document, mappingFileInfo);
Element rootElement = document["hibernate-mapping"];
if (rootElement == null)
continue;
XmlAttribute a = rootElement.Attributes["namespace"];
string pkg = null;
if (a != null)
{
pkg = a.Value;
}
MappingElement me = new MappingElement(rootElement, null);
IEnumerator classElements = rootElement.SelectNodes("urn:class", nsmgr).GetEnumerator();
MultiMap mm = MetaAttributeHelper.LoadAndMergeMetaMap(rootElement, globalMetas);
HandleClass(pkg, me, classMappings, classElements, mm, false);
classElements = rootElement.SelectNodes("urn:subclass", nsmgr).GetEnumerator();
HandleClass(pkg, me, classMappings, classElements, mm, true);
classElements = rootElement.SelectNodes("urn:joined-subclass", nsmgr).GetEnumerator();
HandleClass(pkg, me, classMappings, classElements, mm, true);
// Ok, pickup subclasses that we found before their superclasses
ProcessChildren(classMappings);
}
// generate source files
for (IEnumerator iterator = generators.GetEnumerator(); iterator.MoveNext(); )
{
Generator g = (Generator)iterator.Current;
g.BaseDirName = outputDir ?? ".\\";
g.Generate(classMappings,fileCreationObserver,cmdLine.CheckTime!=null);
}
}
private static void HandleClass(string classPackage, MappingElement me, Hashtable classMappings,
IEnumerator classElements, MultiMap mm, bool extendz)
{
while (classElements.MoveNext())
{
Element clazz = (Element) classElements.Current;
if (!extendz)
{
ClassMapping cmap = new ClassMapping(classPackage, clazz, me, mm);
SupportClass.PutElement(classMappings, cmap.FullyQualifiedName, cmap);
SupportClass.PutElement(allMaps, cmap.FullyQualifiedName, cmap);
}
else
{
string ex = clazz.Attributes["extends"] == null ? null : clazz.Attributes["extends"].Value;
if ((object) ex == null)
{
throw new MappingException("Missing extends attribute on <" + clazz.LocalName + " name=" +
clazz.Attributes["name"].Value + ">");
}
int commaIndex = ex.IndexOf(',');
if (commaIndex > -1)
{
//suppress the leading AssemblyName
ex = ex.Substring(0, commaIndex).Trim();
}
ClassMapping superclass = (ClassMapping) allMaps[ex];
if (superclass == null)
{
// Haven't seen the superclass yet, so record this and process at the end
SubclassMapping orphan = new SubclassMapping(classPackage, me, ex, clazz, mm);
children.Add(orphan);
}
else
{
ClassMapping subclassMapping = new ClassMapping(classPackage, me, superclass.ClassName, superclass, clazz, mm);
superclass.AddSubClass(subclassMapping);
SupportClass.PutElement(allMaps, subclassMapping.FullyQualifiedName, subclassMapping);
}
}
}
}
internal RdpFlip MakeFlip (RdpBinaryFunction func, RdpPattern p)
{
if (patternPool == null) // could be null for RdpElement etc.
patternPool = new Hashtable ();
// Though this method takes function argument, all
// p1 callers have different pattern types, so we don't
// have to distinguish tables by func.
Hashtable table = patternPool [func] as Hashtable;
if (table == null) {
table = new Hashtable ();
patternPool [func] = table;
}
RdpFlip f = table [p] as RdpFlip;
if (f != null)
return f;
f = new RdpFlip (func, p);
table [p] = f;
return f;
}
internal override RdpPattern ExpandRef (Hashtable defs)
{
if (!expanded) {
l = l.ExpandRef (defs);
r = r.ExpandRef (defs);
}
return this;
}
internal virtual RdpPattern ReduceEmptyAndNotAllowed (ref bool result, Hashtable visited)
{
return this;
}
public RdpChoice MakeChoiceLeaf (RdpPattern p)
{
if (patternPool == null) // could be null for RdpElement etc.
patternPool = new Hashtable ();
Hashtable leaves = (Hashtable) patternPool [typeof (RdpEmpty)];
if (leaves == null) {
leaves = new Hashtable ();
patternPool [typeof (RdpEmpty)] = leaves;
}
RdpChoice leaf = leaves [p] as RdpChoice;
if (leaf == null) {
leaf = new RdpChoice (RdpEmpty.Instance, p);
leaf.setInternTable (patternPool);
leaves [p] = leaf;
}
return leaf;
}
public static void Main(String[] args)
{
nsmgr = new XmlNamespaceManager(new NameTable());
nsmgr.AddNamespace("urn", "urn:nhibernate-mapping-2.2");
children = new ArrayList();
allMaps = new MultiMap();
File.Delete("error-log.txt");
// DOMConfigurator is deprecated in the latest log4net, but we are using an earlier
// version that comes with NVelocity.
XmlConfigurator.Configure(new FileInfo("NHibernate.Tool.hbm2net.exe.config"));
if (args.Length == 0)
{
Console.Error.WriteLine("No arguments provided. Nothing to do. Exit.");
Environment.Exit(- 1);
}
ArrayList mappingFiles = new ArrayList();
string outputDir = null;
SupportClass.ListCollectionSupport generators = new SupportClass.ListCollectionSupport();
MultiMap globalMetas = new MultiHashMap();
// parse command line parameters
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("--"))
{
if (args[i].StartsWith("--config="))
{
FileInfo configFile = new FileInfo(args[i].Substring(9));
// parse config xml file
Document document = new XmlDocument();
document.Load(configFile.FullName);
globalMetas = MetaAttributeHelper.LoadAndMergeMetaMap((document["codegen"]), null);
IEnumerator generateElements = document["codegen"].SelectNodes("generate").GetEnumerator();
while (generateElements.MoveNext())
{
generators.Add(new Generator(configFile.Directory, (Element) generateElements.Current));
}
}
else if (args[i].StartsWith("--output="))
{
outputDir = args[i].Substring(9);
}
}
else if (args[i].IndexOf("*") > -1)
{
// Handle wildcards
mappingFiles.AddRange(GetFiles(args[i]));
}
else
{
mappingFiles.Add(args[i]);
}
}
// if no config xml file, add a default generator
if (generators.Count == 0)
{
generators.Add(new Generator(new DirectoryInfo(Environment.CurrentDirectory)));
}
Hashtable classMappings = new Hashtable();
for (IEnumerator iter = mappingFiles.GetEnumerator(); iter.MoveNext(); )
{
log.Info(iter.Current.ToString());
string mappingFile = (string)iter.Current;
if (!Path.IsPathRooted(mappingFile))
{
mappingFile = Path.Combine(Environment.CurrentDirectory, mappingFile);
}
if (!File.Exists(mappingFile))
throw new FileNotFoundException("Mapping file does not exist.", mappingFile);
// parse the mapping file
NameTable nt = new NameTable();
nt.Add("urn:nhibernate-mapping-2.2");
Document document = new XmlDocument(nt);
document.Load(mappingFile);
Element rootElement = document["hibernate-mapping"];
if (rootElement == null)
continue;
XmlAttribute a = rootElement.Attributes["namespace"];
string pkg = null;
if (a != null)
{
pkg = a.Value;
}
MappingElement me = new MappingElement(rootElement, null);
IEnumerator classElements = rootElement.SelectNodes("urn:class", nsmgr).GetEnumerator();
MultiMap mm = MetaAttributeHelper.LoadAndMergeMetaMap(rootElement, globalMetas);
HandleClass(pkg, me, classMappings, classElements, mm, false);
classElements = rootElement.SelectNodes("urn:subclass", nsmgr).GetEnumerator();
HandleClass(pkg, me, classMappings, classElements, mm, true);
classElements = rootElement.SelectNodes("urn:joined-subclass", nsmgr).GetEnumerator();
HandleClass(pkg, me, classMappings, classElements, mm, true);
// Ok, pickup subclasses that we found before their superclasses
ProcessChildren(classMappings);
// generate source files
for (IEnumerator iterator = generators.GetEnumerator(); iterator.MoveNext(); )
{
Generator g = (Generator)iterator.Current;
g.BaseDirName = outputDir;
g.Generate(classMappings);
}
}
}
private void initialize()
{
caseSensitiveLiterals = true;
setCaseSensitive(true);
literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
literals.Add("const", 25);
literals.Add("enum", 20);
literals.Add("import", 30);
literals.Add("DeclareInterface", 8);
literals.Add("DeclareCoClass", 16);
literals.Add("typedef", 5);
literals.Add("DeclareDualInterface2", 18);
literals.Add("interface", 19);
literals.Add("DeclareDualInterface", 17);
literals.Add("struct", 21);
}
private void initialize()
{
caseSensitiveLiterals = true;
setCaseSensitive(true);
literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
literals.Add("raise", 73);
literals.Add("class", 4);
literals.Add("redo", 66);
literals.Add("final", 41);
literals.Add("internal", 45);
literals.Add("self", 37);
literals.Add("base", 94);
literals.Add("require", 51);
literals.Add("and", 77);
literals.Add("def", 7);
literals.Add("retry", 69);
literals.Add("private", 43);
literals.Add("end", 6);
literals.Add("override", 38);
literals.Add("next", 68);
literals.Add("until", 65);
literals.Add("initialize", 48);
literals.Add("begin", 9);
literals.Add("do", 5);
literals.Add("nil?", 97);
literals.Add("namespace", 35);
literals.Add("operator", 8);
literals.Add("lambda", 70);
literals.Add("while", 10);
literals.Add("or", 76);
literals.Add("abstract", 39);
literals.Add("is", 85);
literals.Add("protected", 44);
literals.Add("break", 67);
literals.Add("new", 40);
literals.Add("if", 63);
literals.Add("yield", 74);
literals.Add("public", 42);
literals.Add("unless", 64);
literals.Add("not", 78);
}
private void initialize()
{
caseSensitiveLiterals = true;
setCaseSensitive(true);
literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
literals.Add("local", 22);
literals.Add("size_is", 143);
literals.Add("optional", 139);
literals.Add("proxy", 28);
literals.Add("last_is", 147);
literals.Add("byte", 96);
literals.Add("public", 89);
literals.Add("represent_as", 87);
literals.Add("case", 116);
literals.Add("message", 52);
literals.Add("short", 105);
literals.Add("uidefault", 132);
literals.Add("raises", 150);
literals.Add("defaultbind", 35);
literals.Add("object", 23);
literals.Add("ignore", 128);
literals.Add("readonly", 123);
literals.Add("lcid", 50);
literals.Add("propputref", 131);
literals.Add("octet", 93);
literals.Add("wire_marshal", 86);
literals.Add("licensed", 51);
literals.Add("module", 10);
literals.Add("unsigned", 92);
literals.Add("const", 63);
literals.Add("float", 110);
literals.Add("context_handle", 82);
literals.Add("context", 151);
literals.Add("length_is", 145);
literals.Add("source", 149);
literals.Add("retval", 137);
literals.Add("defaultvalue", 138);
literals.Add("ptr", 103);
literals.Add("appobject", 30);
literals.Add("first_is", 146);
literals.Add("noncreatable", 54);
literals.Add("control", 32);
literals.Add("handle", 83);
literals.Add("optimize", 27);
literals.Add("importlib", 58);
literals.Add("small", 104);
literals.Add("ref", 101);
literals.Add("handle_t", 98);
literals.Add("cpp_quote", 159);
literals.Add("custom", 33);
literals.Add("range", 142);
literals.Add("out", 136);
literals.Add("callback", 126);
literals.Add("library", 15);
literals.Add("displaybind", 38);
literals.Add("native", 81);
literals.Add("iid_is", 141);
literals.Add("hyper", 108);
literals.Add("L", 154);
literals.Add("entry", 41);
literals.Add("FALSE", 78);
literals.Add("usesgetlasterror", 133);
literals.Add("oleautomation", 56);
literals.Add("propput", 130);
literals.Add("version", 18);
literals.Add("typedef", 80);
literals.Add("nonbrowsable", 53);
literals.Add("interface", 59);
literals.Add("sequence", 118);
literals.Add("uuid", 17);
literals.Add("switch_type", 90);
literals.Add("pointer_default", 24);
literals.Add("broadcast", 127);
literals.Add("immediatebind", 49);
literals.Add("coclass", 16);
literals.Add("aggregatable", 29);
literals.Add("midl_pragma_warning", 160);
literals.Add("dispinterface", 60);
literals.Add("any", 94);
literals.Add("double", 111);
literals.Add("SAFEARRAY", 152);
literals.Add("nonextensible", 55);
literals.Add("union", 114);
literals.Add("__int3264", 5);
literals.Add("enum", 117);
literals.Add("pipe", 84);
literals.Add("propget", 129);
literals.Add("int", 107);
literals.Add("exception", 125);
literals.Add("switch_is", 148);
literals.Add("boolean", 112);
literals.Add("max_is", 144);
literals.Add("requestedit", 140);
literals.Add("char", 109);
literals.Add("defaultvtable", 37);
literals.Add("string", 121);
literals.Add("default", 34);
literals.Add("odl", 26);
literals.Add("id", 47);
literals.Add("dual", 40);
literals.Add("helpstringdll", 45);
literals.Add("false", 79);
literals.Add("user_marshal", 88);
literals.Add("restricted", 57);
literals.Add("helpfile", 43);
literals.Add("bindable", 31);
literals.Add("dllname", 39);
literals.Add("attribute", 124);
literals.Add("v1_enum", 4);
literals.Add("async_uuid", 21);
literals.Add("struct", 113);
literals.Add("__int64", 6);
literals.Add("helpcontext", 42);
literals.Add("signed", 91);
literals.Add("import", 13);
literals.Add("endpoint", 25);
literals.Add("in", 135);
literals.Add("TRUE", 76);
literals.Add("void", 95);
literals.Add("wchar_t", 97);
literals.Add("transmit_as", 85);
literals.Add("switch", 115);
literals.Add("defaultcollelem", 36);
literals.Add("helpstring", 44);
literals.Add("true", 77);
literals.Add("long", 106);
literals.Add("hidden", 46);
literals.Add("unique", 102);
literals.Add("idempotent", 48);
literals.Add("vararg", 134);
}
void AddRelation(Entity a, Entity b, Hashtable supers, Hashtable subs) {
AddRelation(a, b, supers);
AddRelation(b, a, subs);
}
internal void setInternTable (Hashtable ht)
{
if (this.patternPool != null)
return;
this.patternPool = ht;
Hashtable pt = ht [GetType ()] as Hashtable;
if (pt == null) {
pt = new Hashtable ();
ht [GetType ()] = pt;
}
RdpAbstractSingleContent single =
this as RdpAbstractSingleContent;
if (single != null) {
if (pt [single.Child] == null) {
pt [single.Child] = this;
single.Child.setInternTable (ht);
}
return;
}
RdpAbstractBinary binary =
this as RdpAbstractBinary;
if (binary != null) {
Hashtable lTable = setupTable (GetType (), binary.LValue);
if (lTable [binary.RValue] == null) {
lTable [binary.RValue] = this;
binary.LValue.setInternTable (ht);
binary.RValue.setInternTable (ht);
}
return;
}
// For rest patterns, only check recursively, without pooling.
RdpAttribute attr = this as RdpAttribute;
if (attr != null) {
attr.Children.setInternTable (ht);
return;
}
RdpElement el = this as RdpElement;
if (el != null) {
el.Children.setInternTable (ht);
return;
}
RdpDataExcept dex= this as RdpDataExcept;
if (dex != null) {
dex.Except.setInternTable (ht);
return;
}
switch (PatternType) {
case RelaxngPatternType.Empty:
case RelaxngPatternType.NotAllowed:
case RelaxngPatternType.Text:
case RelaxngPatternType.Data:
case RelaxngPatternType.Value:
return;
}
#if REPLACE_IN_ADVANCE
throw new InvalidOperationException ();
#endif
}
internal virtual RdpPattern ExpandRef (Hashtable defs)
{
return this;
}
internal override RdpPattern ExpandRef (Hashtable defs)
{
if (!isExpanded)
child = child.ExpandRef (defs);
return this;
}
internal override RdpPattern ReduceEmptyAndNotAllowed (ref bool result, Hashtable visited)
{
if (visited.Contains (this))
return this;
visited.Add (this, this);
if (except.PatternType == RelaxngPatternType.NotAllowed) {
result = true;
return new RdpData (this.Datatype);
} else {
except = except.ReduceEmptyAndNotAllowed (ref result, visited);
return this;
}
}
internal override RdpPattern ExpandRef (Hashtable defs)
{
if (!isExpanded) {
isExpanded = true;
children = children.ExpandRef (defs);
}
return this;
}
internal override RdpPattern ReduceEmptyAndNotAllowed (ref bool result, Hashtable visited)
{
if (visited.Contains (this))
return this;
visited.Add (this, this);
if (LValue.PatternType == RelaxngPatternType.NotAllowed &&
RValue.PatternType == RelaxngPatternType.NotAllowed) {
result = true;
return RdpNotAllowed.Instance;
} else if (LValue.PatternType == RelaxngPatternType.NotAllowed) {
result = true;
return RValue.ReduceEmptyAndNotAllowed (ref result, visited);
} else if (RValue.PatternType == RelaxngPatternType.NotAllowed) {
result = true;
return LValue.ReduceEmptyAndNotAllowed (ref result, visited);
} else if (LValue.PatternType == RelaxngPatternType.Empty &&
RValue.PatternType == RelaxngPatternType.Empty) {
result = true;
return RdpEmpty.Instance;
} else if (RValue.PatternType == RelaxngPatternType.Empty) {
result = true;
RValue = LValue.ReduceEmptyAndNotAllowed (ref result, visited);
LValue = RdpEmpty.Instance;
return this;
} else {
LValue = LValue.ReduceEmptyAndNotAllowed (ref result, visited);
RValue = RValue.ReduceEmptyAndNotAllowed (ref result, visited);
return this;
}
}
internal override RdpPattern ReduceEmptyAndNotAllowed (ref bool result, Hashtable visited)
{
if (visited.Contains (this))
return this;
visited.Add (this, this);
if (children.PatternType == RelaxngPatternType.NotAllowed) {
result = true;
return RdpNotAllowed.Instance;
} else {
children = children.ReduceEmptyAndNotAllowed (ref result, visited);
return this;
}
}
/// <summary>
/// Find parents for any orphans
/// </summary>
/// <returns></returns>
private static bool FindParents(Hashtable classMappings)
{
if (children.Count == 0)
{
// No parents to find
return false;
}
else
{
bool found = false;
foreach (SubclassMapping child in children)
{
if (child.Orphaned)
{
ClassMapping superclass = (ClassMapping) allMaps[child.SuperClass];
if (superclass != null)
{
ClassMapping subclassMapping =
new ClassMapping(child.ClassPackage, child.MappingElement, superclass.ClassName, superclass, child.Clazz,
child.MultiMap);
superclass.AddSubClass(subclassMapping);
// NB Can't remove it from the iterator, so record that we've found the parent.
child.Orphaned = false;
found = true;
}
}
}
// Tell them if we found any
return found;
}
}
public RdpOneOrMore MakeOneOrMore (RdpPattern p)
{
if (patternPool == null) // could be null for RdpElement etc.
patternPool = new Hashtable ();
Hashtable pTable = (Hashtable) patternPool [typeof (RdpOneOrMore)];
if (pTable == null) {
pTable = new Hashtable ();
patternPool [typeof (RdpOneOrMore)] = pTable;
}
if (pTable [p] == null) {
RdpOneOrMore oom = new RdpOneOrMore (p);
oom.setInternTable (patternPool);
pTable [p] = oom;
}
return (RdpOneOrMore) pTable [p];
}
/// <summary>
/// Try to locate superclasses for any orphans we have
/// </summary>
private static void ProcessChildren(Hashtable classMappings)
{
while (FindParents(classMappings))
{
}
foreach (SubclassMapping child in children)
{
if (child.Orphaned)
{
// Log that we had an orphan
log.Warn(string.Format("Cannot extend {0} child of unmapped class {1} ", child.Name, child.SuperClass));
}
}
}
short expanding; // FIXME: It is totally not required, but there is
// some bugs in simplification and without it it causes infinite loop.
internal override RdpPattern ExpandRef (Hashtable defs)
{
if (!isExpanded) {
isExpanded = true;
if (expanding == 100)
throw new RelaxngException (String.Format ("Invalid recursion was found. Name is {0}", nameClass));
expanding++;
children = children.ExpandRef (defs);
expanding--;
}
return this;
}
private void initialize()
{
caseSensitiveLiterals = true;
setCaseSensitive(true);
literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
literals.Add("VCALENDAR", 6);
literals.Add("BEGIN", 4);
literals.Add("METHOD", 15);
literals.Add("END", 8);
literals.Add("PRODID", 11);
literals.Add("CALSCALE", 14);
literals.Add("VERSION", 13);
}
internal override RdpPattern ReduceEmptyAndNotAllowed (ref bool result, Hashtable visited)
{
if (visited.Contains (this))
return this;
visited.Add (this, this);
children = children.ReduceEmptyAndNotAllowed (ref result, visited);
return this;
}
private void initialize()
{
caseSensitiveLiterals = true;
setCaseSensitive(true);
literals = new Hashtable(100, (float) 0.4, null, Comparer.Default);
}
public PredMap(Hashtable t, StatementSink s) { table = t; sink = s; }
