public static bool GenerateCrossAccess(GeneratorSettings settings, SchemaModel schema, SchemaModel remoteSchema)
{
//set the right target namespace for usings
settings.Namespace = settings.OutputPath;
if (!settings.Namespace.StartsWith("Xbim."))
{
settings.Namespace = "Xbim." + settings.Namespace;
}
settings.CrossAccessNamespace = settings.CrossAccessProjectPath + "." + settings.SchemaInterfacesNamespace;
var entityMatches = EntityDefinitionMatch.GetMatches(schema, remoteSchema).ToList();
var templates =
entityMatches.Where(m => m.Target != null)
.Select(m => new EntityInterfaceImplementation(settings, m, entityMatches) as ICodeTemplate);
var selectTemplates =
GetSelectsToImplement(schema, remoteSchema, entityMatches)
.Select(s => new SelectInterfaceImplementation(settings, s.Item1, s.Item2));
var infrastructureTemplates = new ICodeTemplate[] { new CreatorTemplate(settings, entityMatches) };
var toProcess = templates.Concat(selectTemplates); //.Concat(infrastructureTemplates).ToList();
//toProcess.ForEach(t => ProcessTemplate(t, settings.Namespace));
Parallel.ForEach(toProcess, t => ProcessTemplate(t, settings.Namespace));
return(true);
}
public Code(string[] line, ICodeTemplate template, int length, int offset)
{
this.template = template;
this.text = line;
this.length = length;
this.offset = offset;
}
private void AddPointerListCodes(int offset, int[] pointerList, SortedDictionary <int, Code> lines, ILog log)
{
CanCauseError <ICodeTemplate> template = this.codeStorage.FindTemplate("POIN", Priority.pointer);
if (template.CausedError)
{
log.AddError(template.ErrorMessage);
}
else
{
ICodeTemplate result = template.Result;
int index1 = 0;
for (int index2 = 0; index2 < this.pointerList.Length; ++index2)
{
List <string> stringList = new List <string> ();
stringList.Add(result.Name);
int offset1 = offset + 4 * index1;
for (int index3 = 0; index3 < this.pointerList [index2].Length; ++index3)
{
stringList.Add(pointerList [index1].ToHexString("$"));
++index1;
}
lines [offset1] = new Code(stringList.ToArray(), result, this.pointerList [index2].Length * 4, offset1);
}
}
}
private LanguageProcessor.DocCode MakeCode(IList <LanguageProcessor.LanguageElement> elements, ref int index)
{
List <LanguageProcessor.LanguageElement> languageElementList = new List <LanguageProcessor.LanguageElement> ();
do
{
languageElementList.Add(elements [index]);
++index;
} while (index < elements.Count && elements [index].IsParameter);
List <string> stringList = new List <string> ();
Priority priority;
ICodeTemplate code = this.ParseCode((IList <LanguageProcessor.LanguageElement>)languageElementList, (ICollection <string>)stringList, out priority);
LanguageProcessor.DocCode docCode = new LanguageProcessor.DocCode();
docCode.code = code;
docCode.priority = priority;
docCode.languages = stringList.Count <= 0 ? this.languages.Keys.ToArray <string> () : stringList.ToArray();
if (this.collectDocComments)
{
docCode.mainDoc = new List <string> ((IEnumerable <string>)languageElementList [0].GetDocLines());
docCode.parameterDocs = new Dictionary <string, List <string> > ();
for (int index1 = 1; index1 < languageElementList.Count; ++index1)
{
docCode.parameterDocs.GetOldOrSetNew <string, List <string> > (languageElementList [index1].ParsedLine.name).AddRange((IEnumerable <string>)languageElementList [index1].GetDocLines());
}
}
return(docCode);
}
private void AddCode(LanguageProcessor.DocCode doc_, string language)
{
/*var doc = new DocCode();
* doc = doc_;*/
// var doc = Program.DeepCopyWithXmlSerializer<DocCode>(doc_);
var doc = doc_.CopyCode();
FixCode(ref doc, language);
ICodeTemplateStorer codeTemplateStorer;
if (!this.languages.TryGetValue(language, out codeTemplateStorer))
{
this.languages [language] = (ICodeTemplateStorer) new CodeTemplateStorer(this.templateComparer);
}
this.languages [language].AddCode(doc.code, doc.priority);
if (doc.code.ID != 0)
{
ICodeTemplate fourByte = doc.code.CopyWithNewName("_0x" + doc.code.ID.ToString("X4"));
fourByte.CanBeDisassembled = false;
this.languages [language].AddCode(fourByte, doc.priority);
if (doc.code.ID <= 0xFF)
{
ICodeTemplate twoByte = doc.code.CopyWithNewName("_0x" + doc.code.ID.ToString("X2"));
twoByte.CanBeDisassembled = false;
this.languages [language].AddCode(twoByte, doc.priority);
}
}
// Console.WriteLine("{0}: {1} {2}", language, doc.code.Name, doc.code.ID);
}
protected BaseSourceControl(IFileSystemManager fileSystemManager,
ICodeTemplate codeTemplate
, IZipManager zipManager)
{
FileSystemManager = fileSystemManager;
CodeTemplate = codeTemplate;
ZipManager = zipManager;
}
public bool TryGetCodeData(Code <T> code, out int codeOffset, out ICodeTemplate template)
{
CodeData data;
var result = codeOffsets.TryGetValue(code, out data);
codeOffset = data.Offset;
template = data.CodeTemplate;
return(result);
}
public string InvokeTemplate()
{
ICodeTemplate OCodeTemplate = (ICodeTemplate)Activator.CreateInstance(FType);
foreach (KeyValuePair <string, object> pair in FParameters)
{
OCodeTemplate.SetParameter(pair.Key, pair.Value);
}
return(OCodeTemplate.Generate());
}
private FirstPassResult(
bool valid,
Code <T> code,
int offset,
ICodeTemplate template)
{
this.valid = valid;
this.code = code;
this.offset = offset;
this.template = template;
}
public static ICodeTemplate FindDefaultTemplate(TemplateType templateType, Session session, Type codeTemplateType, CodeDomProvider codeDomProvider)
{
const ICodeTemplate template = null;
var binaryOperator = new BinaryOperator(template.GetPropertyName(x => x.TemplateType), templateType);
var isDefault = new BinaryOperator(template.GetPropertyName(x => x.IsDefault), true);
var provider = new BinaryOperator(template.GetPropertyName(x => x.CodeDomProvider), codeDomProvider);
return(session.FindObject(PersistentCriteriaEvaluationBehavior.InTransaction,
codeTemplateType, new GroupOperator(binaryOperator, isDefault, provider))
as ICodeTemplate);
}
public ServiceBiz(IContentManagementContext contentManagementContext
, IFileSystemManager fileSystemManager, ISourceControl sourceControl
, IWebConfigManager webConfigManager, ICodeTemplate codeTemplate
, ISecurityContext securityContext)
{
_contentManagementContext = contentManagementContext;
_fileSystemManager = fileSystemManager;
_sourceControl = sourceControl;
_webConfigManager = webConfigManager;
_codeTemplate = codeTemplate;
_securityContext = securityContext;
}
private static void WriteHeader(ICodeTemplate template)
{
template.WriteLine("// ------------------------------------------------------------------------------");
template.WriteLine("// <auto-generated>");
template.WriteLine("// This code was generated by a tool Xbim.CodeGeneration ");
//this causes source control to pick up ALL the files because they got changed even if they are de-facto the same
//template.WriteLine("// {0}", DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss"));
template.WriteLine("// ");
template.WriteLine("// Changes to this file may cause incorrect behaviour and will be lost if");
template.WriteLine("// the code is regenerated.");
template.WriteLine("// </auto-generated>");
template.WriteLine("// ------------------------------------------------------------------------------");
}
public static void SetDefaultTemplate(this IPersistentTemplatedTypeInfo persistentMemberInfo, TemplateType templateType)
{
var objectSpace = XPObjectSpace.FindObjectSpaceByObject(persistentMemberInfo);
persistentMemberInfo.CodeTemplateInfo = objectSpace.CreateWCObject <ICodeTemplateInfo>();
ICodeTemplate defaultTemplate = CodeTemplateBuilder.CreateDefaultTemplate(templateType, persistentMemberInfo.Session,
WCTypesInfo.Instance.FindBussinessObjectType <ICodeTemplate>(),
GetProvider(persistentMemberInfo));
persistentMemberInfo.CodeTemplateInfo.CodeTemplate = defaultTemplate;
persistentMemberInfo.CodeTemplateInfo.CloneProperties();
}
private static void ProcessTemplate(ICodeTemplate template, ProjectRootElement project)
{
var rootNamespace = GetNamespace(project);
var localNamespace = template.Namespace.Substring(rootNamespace.Length);
var fileName = template.Name + ".cs";
var localPath = Path.Combine(localNamespace.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries));
var projectPath = Path.GetDirectoryName(project.FullPath) ?? "";
var fullPath = Path.Combine(projectPath, localPath);
if (!Directory.Exists(fullPath) && !String.IsNullOrWhiteSpace(fullPath))
{
Directory.CreateDirectory(fullPath);
}
var filePath = Path.Combine(fullPath, fileName);
WriteHeader(template);
var code = template.TransformText();
//it is possible to keep in custom code if there are predefined slots for it
if (code.Contains("//##") && File.Exists(filePath))
{
var oldFile = File.ReadAllText(filePath);
var oldSections = GetSections(oldFile);
var newSections = GetSections(code);
foreach (var section in newSections)
{
var name = section.Key;
string value;
if (oldSections.TryGetValue(name, out value))
{
code = code.Replace(section.Value, value);
}
}
}
using (var file = File.CreateText(filePath))
{
file.Write(code);
file.Close();
}
var projectFilePath = Path.Combine(localPath, fileName);
AddCompilationItem(projectFilePath, project);
}
private CanCauseError <Code> GetCode(byte[] code, int currOffset, IEnumerable <Priority> prioritiesToUse)
{
CanCauseError <ICodeTemplate> template = this.codeStorage.FindTemplate(code, currOffset, prioritiesToUse);
if (template.CausedError)
{
return(template.ConvertError <Code> ());
}
ICodeTemplate result = template.Result;
int lengthBytes = result.GetLengthBytes(code, currOffset);
CanCauseError <string[]> assembly = result.GetAssembly(code, currOffset);
if (assembly.CausedError)
{
return(assembly.ConvertError <Code> ());
}
return((CanCauseError <Code>) new Code(assembly.Result, result, lengthBytes, currOffset));
}
private void AddCode(LanguageProcessor.DocCode doc, string language)
{
ICodeTemplateStorer codeTemplateStorer;
if (!this.languages.TryGetValue(language, out codeTemplateStorer))
{
this.languages [language] = (ICodeTemplateStorer) new CodeTemplateStorer(this.templateComparer);
}
this.languages [language].AddCode(doc.code, doc.priority);
if (doc.code.ID != 0)
{
ICodeTemplate fourByte = doc.code.CopyWithNewName("_0x" + doc.code.ID.ToString("X4"));
fourByte.CanBeDisassembled = false;
this.languages [language].AddCode(fourByte, doc.priority);
if (doc.code.ID <= 0xFF)
{
ICodeTemplate twoByte = doc.code.CopyWithNewName("_0x" + doc.code.ID.ToString("X2"));
twoByte.CanBeDisassembled = false;
this.languages [language].AddCode(twoByte, doc.priority);
}
}
}
private ScopeStructure <int> ExecuteLayoutPass <T>(IExpression <int> expression, ScopeStructure <int> scope, T output)
{
switch (expression.Type)
{
case EAExpressionType.Scope:
{
ScopeStructure <int> newScope = new ScopeStructure <int> (scope);
scopeStructures [(Scope <int>)expression] = newScope;
foreach (IExpression <int> child in expression.GetChildren())
{
ExecuteLayoutPass(child, newScope, output);
}
break;
}
case EAExpressionType.Code:
{
Code <int> code = expression as Code <int>;
if (code.IsEmpty || HandleBuiltInCodeLayout(code, scope))
{
break;
}
if (code.CodeName.Name == "ASMC" && code.Parameters[0].ToString() != "" && !System.Text.RegularExpressions.Regex.IsMatch(code.Parameters[0].ToString(), @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z"))
{
scope.RegisterASMCLabel(code.Parameters[0].ToString());
}
Types.Type[] sig = ((IEnumerable <IExpression <int> >)code.Parameters).Select(new Func <IExpression <int>, Types.Type> (Types.Type.GetType <int>)).ToArray();
CanCauseError <ICodeTemplate> templateError = this.storer.FindTemplate(code.CodeName.Name, sig);
if (templateError.CausedError)
{
AddError <int, ICodeTemplate> ((IExpression <int>)code, templateError);
break;
}
ICodeTemplate template = templateError.Result;
// Checking alignment
if (currentOffset % template.OffsetMod != 0)
{
this.AddError <int> ((IExpression <int>)code, "Code {0}'s offset {1} is not divisible by {2}", (object)code.CodeName.Name, (object)this.currentOffset.ToHexString("$"), (object)template.OffsetMod);
}
// TODO: maybe we want to store the template somewhere to lookup for later?
// May or may not be faster than computing it again in the write pass
this.currentOffset += template.GetLengthBytes(((IEnumerable <IExpression <int> >)code.Parameters).ToArray());
break;
}
case EAExpressionType.Labeled:
{
// record label names
scope.SetLocalLabelAddress(((LabelExpression <int>)expression).LabelName, currentOffset);
CanCauseError err = scope.AddNewSymbol(((LabelExpression <int>)expression).LabelName, new ValueExpression <int> (this.currentOffset, new FilePosition()));
if (err.CausedError)
{
AddWarning(expression, err.ErrorMessage);
}
break;
}
case EAExpressionType.Assignment:
{
Assignment <int> assingment = (Assignment <int>)expression;
CanCauseError <int> value = Folding.Fold(assingment.Value, x => this.GetSymbolValue(scope, x));
CanCauseError err = null;
if (value.CausedError)
{
err = scope.AddNewSymbol(assingment.Name, assingment.Value);
}
else
{
err = scope.AddNewSymbol(assingment.Name, new ValueExpression <int> (value.Result, new FilePosition()));
}
if (err.CausedError)
{
AddWarning(expression, err.ErrorMessage);
}
break;
}
case EAExpressionType.RawData:
{
RawData <int> rawData = (RawData <int>)expression;
this.currentOffset += rawData.Data.Length;
break;
}
default:
throw new ArgumentException("Badly formed tree.");
}
// DeclareExternASMCLabels<T>(scope, output);
return(scope);
}
//public static List<DebugUser> DebugUsers { get; set; }
//public static List<BrowsersCodeInfo> BrowsersCodeInfos { get; set; }
//static SourceControl()
//{
// BrowsersCodeInfos = new List<BrowsersCodeInfo>();
//}
public SourceControl(IFileSystemManager fileSystemManager,
ICodeTemplate codeTemplate
, IZipManager zipManager)
: base(fileSystemManager, codeTemplate, zipManager)
{
}
private void ExecuteWritePass(TextWriter output, IExpression <int> expression, ScopeStructure <int> scope)
{
// This is to be executed *after* the layout pass
switch (expression.Type)
{
case EAExpressionType.Scope:
{
ScopeStructure <int> newScope = scopeStructures [(Scope <int>)expression];
foreach (IExpression <int> child in expression.GetChildren())
{
ExecuteWritePass(output, child, newScope);
}
break;
}
case EAExpressionType.Code:
{
Code <int> code = expression as Code <int>;
// alignment. ALIGN 2^n => .align n
if (!code.IsEmpty && code.CodeName.Name == offsetAligner && code.ParameterCount.IsInRange(1, 1) && !(code.Parameters[0] is ExpressionList <int>))
{
output.WriteLine("\t.align {0}", Math.Ceiling(Math.Log(Folding.Fold(code.Parameters[0], (x => this.GetSymbolValue(scope, x))).Result, 2)));
}
if (code.IsEmpty || HandleBuiltInCodeWrite(code, scope, output))
{
break;
}
bool TFlag = false;
// bool ExtFlag = false;
if (code.CodeName.Name == "ASMC")
{
if (code.Parameters.Length > 0 && code.Parameters[0].ToString() != "" && !scope.IsLocalLabelExisted(code.Parameters[0].ToString()) && !System.Text.RegularExpressions.Regex.IsMatch(code.Parameters[0].ToString(), @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z"))
{
// ExtFlag = true;
}
else
{
TFlag = true;
}
}
// Maybe all of this template lookup up can be made faster by
// storing the found template from the layout pass?
Types.Type[] sig = ((IEnumerable <IExpression <int> >)code.Parameters).Select(new Func <IExpression <int>, Types.Type> (Types.Type.GetType <int>)).ToArray();
CanCauseError <ICodeTemplate> templateError = this.storer.FindTemplate(code.CodeName.Name, sig);
if (templateError.CausedError)
{
AddError <int, ICodeTemplate> ((IExpression <int>)code, templateError);
break;
}
// We won't check for alignment as it should already have been done in the layout pass
ICodeTemplate template = templateError.Result;
/*if (template is CodeTemplate && code.Parameters.Length > 0)
* {
* for (int i = 0; i < code.Parameters.Length; i++)
* {
* if(scope.GetRegisteredASMCLabels().Exists(o => o == code.Parameters[i].ToString()))
* {
* (template as CodeTemplate).AddExternLabel(i, code.Parameters[i].ToString());
* }
* }
* }*/
CanCauseError <byte[]> data = template.GetData(code.Parameters, x => this.GetSymbolValue(scope, x), scope);
Dictionary <int, string> localLabels = template.GetLocalLabels();
Dictionary <int, string> externLabels = template.GetExternLabels();
var labels = localLabels.Union(externLabels).ToList();
if (data.CausedError)
{
// Can't compute code data, so we err
this.AddError <int, byte[]> (expression, data);
}
else
{
// Write data
if (labels.Count == 0)
{
TryWrite(output, expression, currentOffset, data.Result);
}
else
{
int startIndex = 0;
foreach (KeyValuePair <int, string> k in labels)
{
// Console.WriteLine("pos:" + k.Key + " label:" + k.Value);
if (k.Key - startIndex > 0)
{
TryWrite(output, expression, currentOffset, data.Result.Skip(startIndex).Take(k.Key - startIndex).ToArray());
}
startIndex = k.Key + 4;
if (TFlag == true && scope.IsLocalLabelExisted(k.Value))
{
output.WriteLine("\t.word {0}+1", k.Value);
TFlag = false;
}
else
{
output.WriteLine("\t.word {0}", k.Value);
}
}
if (data.Result.Length - startIndex > 4)
{
TryWrite(output, expression, currentOffset, data.Result.Skip(startIndex).Take(data.Result.Length - startIndex).ToArray());
}
}
}
this.currentOffset += data.Result.Length;
/*for (int i = 0; i < code.Parameters.Length; i++)
* {
* // Console.WriteLine(code.Parameters[i]);
* if (scope.IsLabelExisted(code.Parameters[i].ToString()))
* {
* output.WriteLine("\t.word {0}", code.Parameters[i]);
* this.currentOffset += 4;
* }
* else
* {
* IExpression<int>[] parameter = new IExpression<int>[] { code.Parameters[i] };
* CanCauseError<byte[]> data = template.GetDataUnit(parameter, x => this.GetSymbolValue(scope, x));
* if (data.CausedError)
* // Can't compute code data, so we err
* this.AddError<int, byte[]>(expression, data);
* else
* {
* // Write data
* TryWrite(output, expression, currentOffset, data.Result);
* this.currentOffset += data.Result.Length;
* }
* }
* }*/
break;
}
case EAExpressionType.RawData:
{
RawData <int> rawData = (RawData <int>)expression;
TryWrite(output, expression, this.currentOffset, rawData.Data);
this.currentOffset += rawData.Data.Length;
break;
}
case EAExpressionType.Labeled:
//TODO Add label attribute: ".global LabelName"
output.WriteLine(((LabelExpression <int>)expression).LabelName + ":");
break;
case EAExpressionType.Assignment:
//TODO .set/.equ, but it doesn't matter
break;
default:
throw new ArgumentException("Badly formed tree.");
}
}
public static FirstPassResult Valid(Code <T> code,
int offset,
ICodeTemplate template)
{
return(new FirstPassResult(true, code, offset, template));
}
private IEnumerable <KeyValuePair <INamed <string>, string[]> > FirstPass(IPositionableInputStream input,
Context assemblyContext, ILog log)
{
while (true)
{
string line = input.ReadLine();
if (line == null)
{
break;
}
string[] code = Nintenlord.Utility.Parser.SplitToParameters(line);
if (code.Length > 0)
{
if (code[0].EndsWith(":"))
{
code = HandleLabels(input, assemblyContext, log, code);
}
if (code.Length == 0)
{
continue;
}
IBuiltInCode builtIn;
if (buildInCodes.TryGetValue(code[0], out builtIn))
{
string error;
if (builtIn.Matches("Code " + code[0], code.Length - 1, out error))
{
var causedError = builtIn.FirstPass(code, assemblyContext);
if (causedError)
{
log.AddError(input.GetErrorString(causedError.ErrorMessage));
}
yield return(new KeyValuePair <INamed <string>, string[]>(builtIn, code));
}
else
{
log.AddError(input.GetErrorString(error));
}
}
else
{
ICodeTemplate template = codeStorage.FindTemplate(code);
if (template != null)
{
if (assemblyContext.Offset % template.OffsetMod != 0)
{
log.AddError(input.GetErrorString(
string.Format(
"Code {0}'s offset {1} is not divisible by {2}",
template.Name,
assemblyContext.Offset,
template.OffsetMod
)));
}
assemblyContext.Offset += template.GetLengthBytes(code);
yield return(new KeyValuePair <INamed <string>, string[]>(template, code));
}
else
{
log.AddError(input.GetErrorString(string.Format(
"No code named {0} with {1} parameters found",
code[0],
code.Length - 1
)));
}
}
}
}
}
public DataBaseContextManager(ISqlHelper sqlHelper, ICodeTemplate codeTemplate) : base(sqlHelper, codeTemplate)
{
}
protected BaseDataBaseContextManager(ISqlHelper sqlHelper, ICodeTemplate codeTemplate)
{
_sqlHelper = sqlHelper;
_codeTemplate = codeTemplate;
}
private void ExecuteWritePass(BinaryWriter output, IExpression <int> expression, ScopeStructure <int> scope)
{
// This is to be executed *after* the layout pass
switch (expression.Type)
{
case EAExpressionType.Scope:
{
ScopeStructure <int> newScope = scopeStructures [(Scope <int>)expression];
foreach (IExpression <int> child in expression.GetChildren())
{
ExecuteWritePass(output, child, newScope);
}
break;
}
case EAExpressionType.Code:
{
Code <int> code = expression as Code <int>;
if (code.IsEmpty || HandleBuiltInCodeWrite(code, scope))
{
break;
}
// Maybe all of this template lookup up can be made faster by
// storing the found template from the layout pass?
Types.Type[] sig = ((IEnumerable <IExpression <int> >)code.Parameters).Select(new Func <IExpression <int>, Types.Type> (Types.Type.GetType <int>)).ToArray();
CanCauseError <ICodeTemplate> templateError = this.storer.FindTemplate(code.CodeName.Name, sig);
if (templateError.CausedError)
{
AddError <int, ICodeTemplate> ((IExpression <int>)code, templateError);
break;
}
// We won't check for alignment as it should already have been done in the layout pass
ICodeTemplate template = templateError.Result;
CanCauseError <byte[]> data = template.GetData(code.Parameters, x => this.GetSymbolValue(scope, x), scope);
if (data.CausedError)
{
// Can't compute code data, so we err
this.AddError <int, byte[]> (expression, data);
}
else
{
// Write data
TryWrite(output, expression, currentOffset, data.Result);
this.currentOffset += data.Result.Length;
}
break;
}
case EAExpressionType.RawData:
{
RawData <int> rawData = (RawData <int>)expression;
TryWrite(output, expression, this.currentOffset, rawData.Data);
this.currentOffset += rawData.Data.Length;
break;
}
case EAExpressionType.Labeled:
case EAExpressionType.Assignment:
break;
default:
throw new ArgumentException("Badly formed tree.");
}
}
public CodeData(int offset, ICodeTemplate codeTemplate)
{
this.Offset = offset;
this.CodeTemplate = codeTemplate;
}
public void AddCodeData(Code <T> code, int offset, ICodeTemplate template)
{
codeOffsets.Add(code, new CodeData(offset, template));
}
