public LegacyCodeGenerationDriver(LanguageOption language, Version targetEntityFrameworkVersion)
{
Debug.Assert(
EntityFrameworkVersion.IsValidVersion(targetEntityFrameworkVersion),
"invalid targetEntityFrameworkVersion");
_language = language;
_targetEntityFrameworkVersion = targetEntityFrameworkVersion;
}
public static CodeGeneratorBase Create(LanguageOption language, Version targetEntityFrameworkVersion)
{
Debug.Assert(
EntityFrameworkVersion.IsValidVersion(targetEntityFrameworkVersion),
"invalid targetEntityFrameworkVersion");
return targetEntityFrameworkVersion == EntityFrameworkVersion.Version1
? (CodeGeneratorBase)new EntityClassGenerator(language)
: new EntityCodeGenerator(language, targetEntityFrameworkVersion);
}
/// <summary>
/// Generate views from the EDMX file
/// </summary>
/// <param name="edmxFile">File containing EDMX</param>
/// <param name="languageOption">C# or VB</param>
/// <returns>List of errors that occurred while building the mapping or while generating views</returns>
public static IList<EdmSchemaError> GenerateViewsFromEdmx(FileInfo edmxFile, LanguageOption languageOption)
{
TextWriter viewsWriter = null;
var ext = (languageOption == LanguageOption.GenerateCSharpCode) ? ".cs" : ".vb";
var outputFile = GetFileNameWithNewExtension(edmxFile, ".Views" + ext);
viewsWriter = new StreamWriter((string) outputFile);
var edmxReader = new StreamReader(edmxFile.FullName);
var errors = GenerateViewsFromEdmx(edmxReader, languageOption, viewsWriter);
return errors;
}
/// <summary>
/// Generate views from the given EDMX TextReader
/// </summary>
/// <param name="edmxReader">TextReader providing the EDMX XML</param>
/// <param name="languageOption">C# or VB</param>
/// <param name="viewsWriter">TextWriter that the views will be written into. If null, only validation will be performed.</param>
/// <returns>List of errors that occurred while building the mapping or while validating/generating</returns>
public static IList<EdmSchemaError> GenerateViewsFromEdmx(TextReader edmxReader, LanguageOption languageOption, TextWriter viewsWriter)
{
List<EdmSchemaError> allErrors = null;
StorageMappingItemCollection mappingItemCollection = EdmMapping.BuildMapping(edmxReader, out allErrors);
// generate views & write them out to a file
var evg = new EntityViewGenerator(languageOption);
var viewGenerationErrors = evg.GenerateViews(mappingItemCollection, viewsWriter);
if (viewGenerationErrors != null) allErrors.AddRange(viewGenerationErrors);
return allErrors;
}
/// <summary>
/// Gets the LanguageOption value from string.
/// </summary>
/// <param name="key"></param>
/// <param name="defaultValue"></param>
/// <param name="raiseException"></param>
/// <returns></returns>
public static LanguageOption ToLanguageOption(this string key, LanguageOption defaultValue = LanguageOption.En, bool raiseException = false)
{
var lookupLanguage = LookupLanguage;
key = key.ToLowerInvariant();
if (lookupLanguage.Values.Contains(key))
{
var pair = lookupLanguage.First(kvp => kvp.Value == key);
return(pair.Key);
}
if (Enum.TryParse(key, true, out LanguageOption value))
{
return(value);
}
else
{
return(raiseException ? throw new ArgumentException($"{key} is not LanguageOption value.") : defaultValue);
}
}
public override object CreateInstance()
{
if (this.isInternal)
{
Command command = GlobalCommand.GlobalCmdManager.GetCommand((object)this.Id);
if (command == null)
{
return((object)null);
}
return((object)new CommandEntry(command));
}
if (this.label == null)
{
this.label = this.Id;
}
this.label = LanguageOption.GetValueBykey(this.label);
Command command1 = this.CreateCommand();
GlobalCommand.GlobalCmdManager.RegisterCommand(command1);
return((object)new CommandEntry(command1));
}
public static bool CodeGen(String edmxFile, LanguageOption languageOption, out String codeOut, out List<Object> errors)
{
codeOut = String.Empty;
XDocument xdoc = XDocument.Load(edmxFile);
XElement c = GetCsdlFromEdmx(xdoc);
Version v = _namespaceManager.GetVersionFromEDMXDocument(xdoc);
StringWriter sw = new StringWriter();
errors = new List<Object>();
//
// code-gen uses different classes for V1 and V2 of the EF
//
if (v == EntityFrameworkVersions.Version1)
{
// generate code
EntityClassGenerator codeGen = new EntityClassGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw) as List<Object>;
}
else if (v == EntityFrameworkVersions.Version2)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw) as List<Object>;
}
else if (v == EntityFrameworkVersions.Version3)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw) as List<Object>;
}
// output errors
if (errors != null)
return true;
codeOut = sw.ToString();
return false;
}
public static bool TryGetLanguageDeclaration(string line, out LanguageOption option)
{
int posUOSL;
if ((posUOSL = line.IndexOf(" UOSL ")) > 0)
{ // Try to extract language option from line
int j = 0;
for (int i = posUOSL + 6; i < line.Length; i++)
{
if (j == 0 && char.IsLetter(line[i]))
{
j = i;
}
else if (j > posUOSL && !char.IsLetter(line[i]))
{
return(Enum.TryParse <LanguageOption>(line.Substring(j, i - j), true, out option));
}
}
}
option = 0;
return(false);
}
public virtual void AddVar(Field field, ParsingContext context)
{
Field found = null;
if (UOSLGrammar.Keywords.ContainsKey(field.Name) && context.GetOptions() == LanguageOption.Extended)
{
context.AddParserMessage(ParserErrorLevel.Info, field.Node.Span, "{0} is a keyword. It cannot be used as a Field name.", field.Name);
}
if (ScopeVars != null && (found = ScopeVars.FirstOrDefault(var => var.Name == field.Name)) != null)
{
LanguageOption Options = context.GetOptions();
if (Options == LanguageOption.Extended)
{
context.AddParserMessage(ParserErrorLevel.Error, field.Node.Span, "Field {0} is already declared as a different type.", field.Name);
}
else if (found.UoTypeToken != field.UoTypeToken)
{
// This is OK in Native mode, but an warning in Enhanced mode
context.AddParserMessage(Options == LanguageOption.Native ? ParserErrorLevel.Warning : ParserErrorLevel.Error
, field.Node.Span, "Field {0} is already declared as a different type, declaration ignored.", field.Name);
}
else
{
context.AddParserMessage(ParserErrorLevel.Info, field.Node.Span, "Redeclaration of Field {0} ignored.", field.Name);
}
}
if (found == null) // ignore redeclaraions
{
field.Scope = this;
(m_LocalVars ?? (m_LocalVars = new List <Field>())).Add(field);
}
else
{
found.AddReference(this);
}
}
private static void CodeGen(FileInfo edmxFile, LanguageOption languageOption)
{
XDocument xdoc = XDocument.Load(edmxFile.FullName);
XElement c = GetCsdlFromEdmx(xdoc);
Version v = _namespaceManager.GetVersionFromEDMXDocument(xdoc);
StringWriter sw = new StringWriter();
IList <EdmSchemaError> errors = null;
//
// code-gen uses different classes for V1 and V2 of the EF
//
if (v == EntityFrameworkVersions.Version1)
{
// generate code
EntityClassGenerator codeGen = new EntityClassGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
else if (v == EntityFrameworkVersions.Version2)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
else if (v == EntityFrameworkVersions.Version3)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw, EntityFrameworkVersions.Version3);
}
// write out code-file
string outputFileName = GetFileNameWithNewExtension(edmxFile,
GetFileExtensionForLanguageOption(languageOption));
File.WriteAllText(outputFileName, sw.ToString());
// output errors
WriteErrors(errors);
}
private void Awake()
{
dumpMemory = new char[UnityEngine.Random.Range(0, 500)];
if (instance == null)
{
instance = this;
DontDestroyOnLoad(this.gameObject);
}
//backendManager.ServerTimer();
//PlayerPrefs.DeleteAll();
//Current_Language = Application.systemLanguage.ToString();
if (PlayerPrefs.GetInt("localized", 0) == 1)
{
LanguageOption.Initialize(SystemLanguage.English);
Title_Image.sprite = Eng_Title_Image;
}
else if (PlayerPrefs.GetInt("localized", 0) == 2)
{
LanguageOption.Initialize(SystemLanguage.Korean);
Title_Image.sprite = Kor_Title_Image;
}
else
{
if (Application.systemLanguage == SystemLanguage.Korean)
{
Title_Image.sprite = Kor_Title_Image;
}
else
{
Title_Image.sprite = Eng_Title_Image;
}
LanguageOption.Initialize(Application.systemLanguage);
}
User_ID_Text.text = "User ID : " + PlayerPrefs.GetString(DesignConstStorage.PlayerCustomID);
Warning_Text.text = MyLocalization.Exchange("warning");
}
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
LanguageOption Options = context.GetOptions();
field = new Field(this, context, true);
if (!Options.HasOption(LanguageOption.Constants))
{
context.AddParserMessage(ParserErrorLevel.Error, this.Span, "Constants are not valid for this source.");
}
else if (Assign == null || Assign.Expression.UoToken == null || !Assign.Expression.UoToken.IsLiteral)
{
if (Assign != null && Assign.Expression.AsString == "ExpressionList")
{
foreach (ExpressionNode node in Assign.Expression.ChildNodes)
{
if (node.UoToken == null || !node.UoToken.IsLiteral)
{
context.AddParserMessage(ParserErrorLevel.Error, node.Span, "Constant list elements must be compile time constants.");
}
}
field.Value = Assign.Expression.ChildNodes.Select(node => new ConstantListElement(((ExpressionNode)node).UoToken, ((ExpressionNode)node).UoTypeToken));
}
else
{
context.AddParserMessage(ParserErrorLevel.Error, Span, "Constants must be assigned a compile time constant value when declared.");
field.Value = "0";
}
}
else
{
field.Value = Assign.Expression.UoToken.Value;
}
UOSLBase.AddMember(field, context);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="writer"></param>
/// <param name="language"></param>
public void Do(System.IO.TextReader reader, System.IO.TextWriter writer, LanguageOption language, bool hasNamespace)
{
Language = language;
// set up the fix ups for each class.
foreach (FixUp fixUp in this)
{
List <FixUp> fixUps = null;
if (ClassFixUps.ContainsKey(fixUp.Class))
{
fixUps = ClassFixUps[fixUp.Class];
}
else
{
fixUps = new List <FixUp>();
ClassFixUps.Add(fixUp.Class, fixUps);
}
fixUps.Add(fixUp);
}
switch (Language)
{
case LanguageOption.GenerateVBCode:
DoFixUpsForVB(reader, writer);
break;
case LanguageOption.GenerateCSharpCode:
DoFixUpsForCS(reader, writer, hasNamespace);
break;
default:
Debug.Assert(false, "Unexpected language value: " + Language.ToString());
CopyFile(reader, writer);
break;
}
}
/// <summary>
/// Generate views from the given EDMX string.
/// </summary>
/// <param name="edmx">String containing EDMX XML</param>
/// <param name="languageOption">C# or VB</param>
/// <param name="viewsWriter">TextWriter to write the views into.</param>
/// <returns>List of errors that occurred while building the mapping or while generating</returns>
public static IList<EdmSchemaError> GenerateViewsFromEdmx(String edmx, LanguageOption languageOption, TextWriter viewsWriter)
{
var textReader = new StringReader(edmx);
return GenerateViewsFromEdmx(textReader, languageOption, viewsWriter);
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(Indenter(indentationlevel, "{0} {1}", Keyword.Member.Value, base.GenerateScript(options)));
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(string.Format("{0} {1} {2}{3}\n{4}\n", DeclKeyword.Value, UoTypeToken.Value, Name.Text, Parameters.GenerateScript(options), Body.GenerateScript(options)));
}
// protected virtual to allow mocking
protected virtual CodeGeneratorBase CreateCodeGenerator(LanguageOption language, Version targetEntityFrameworkVersion)
{
return(CodeGeneratorBase.Create(language, targetEntityFrameworkVersion));
}
private void OptimizeContextEF5(
LanguageOption languageOption,
string baseFileName,
StorageMappingItemCollection mappingCollection,
SelectedItem selectedItem)
{
DebugCheck.NotEmpty(baseFileName);
DebugCheck.NotNull(mappingCollection);
OptimizeContextCore(
languageOption,
baseFileName,
selectedItem,
viewsPath =>
{
var viewGenerator = new EntityViewGenerator(languageOption);
var errors = viewGenerator.GenerateViews(mappingCollection, viewsPath);
errors.HandleErrors(Strings.Optimize_SchemaError(baseFileName));
});
}
/// <summary>
/// This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="languageOption">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
public EntityClassGenerator(LanguageOption languageOption)
{
_entityClassGenerator = new Sded.EntityClassGenerator((Sded.LanguageOption)languageOption);
}
/// <summary>
///
/// </summary>
/// <param name="language"></param>
/// <param name="line"></param>
/// <returns></returns>
public string Fix(LanguageOption language, string line)
{
FixMethod method = null;
if ( language == LanguageOption.GenerateCSharpCode )
{
method = _CSFixMethods[(int)Type];
}
else if ( language == LanguageOption.GenerateVBCode )
{
method = _VBFixMethods[(int)Type];
}
if ( method != null )
{
line = method( line );
}
return line;
}
public void GetLanguageFromFirstLetterTest(string value, LanguageOption expectedResult)
{
value.GetLanguageFromFirstLetter().Should().Be(expectedResult);
}
/// <summary>
/// This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="languageOption">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
public EntityClassGenerator(LanguageOption languageOption)
{
_entityClassGenerator = new Sded.EntityClassGenerator((Sded.LanguageOption)languageOption);
}
// protected virtual to allow mocking
protected virtual CodeGeneratorBase CreateCodeGenerator(LanguageOption language, Version targetEntityFrameworkVersion)
{
return CodeGeneratorBase.Create(language, targetEntityFrameworkVersion);
}
/// <summary>
/// Parse the string to get the LanguageOption
/// </summary>
/// <param name="ext">String that should be either "cs" or "vb"</param>
/// <param name="langOption">output parameter for returning LanguageOption</param>
/// <returns>True if ext was successfully parsed into a LanguageOption, false otherwise</returns>
public static bool ParseLanguageOption(string ext, out LanguageOption langOption)
{
langOption = LanguageOption.GenerateCSharpCode;
if ("vb".Equals(ext, StringComparison.OrdinalIgnoreCase))
{
langOption = LanguageOption.GenerateVBCode;
return true;
}
else if ("cs".Equals(ext, StringComparison.OrdinalIgnoreCase))
{
langOption = LanguageOption.GenerateCSharpCode;
return true;
}
else
{
return false;
}
}
/// <summary>
/// Write the pre-generated views file.
/// </summary>
/// <param name="viewsFileName">Name of the file to create. If it exists, it is overwritten.</param>
/// <param name="edmx">String containing the EDMX XML</param>
/// <param name="hash">Hash code to put at the top of the views file</param>
/// <param name="languageOption">Language (cs or vb) in which to write the views file</param>
/// <returns>true if the write was successful, false if not.</returns>
public bool WriteViewsFile(string viewsFileName, string edmx, string hash, LanguageOption languageOption)
{
bool result = true;
try
{
var writer = new StreamWriter(viewsFileName, false);
writer.WriteLine(HashPrefix + hash);
var errors = GenerateViewsFromEdmx(edmx, languageOption, writer);
if (Enumerable.Any(errors))
{
var severe = LogErrors(errors);
result = (!severe);
}
writer.Close();
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
result = false;
}
return result;
}
private static void CodeGen(FileInfo edmxFile, LanguageOption languageOption)
{
XElement c = GetCsdlFromEdmx(XDocument.Load(edmxFile.FullName));
// generate code
StringWriter sw = new StringWriter();
EntityClassGenerator codeGen = new EntityClassGenerator(languageOption);
IList<EdmSchemaError> errors = codeGen.GenerateCode(c.CreateReader(), sw);
// write out code-file
string outputFileName = GetFileNameWithNewExtension(edmxFile,
GetFileExtensionForLanguageOption(languageOption));
File.WriteAllText(outputFileName, sw.ToString());
// output errors
WriteErrors(errors);
}
/// <summary>
/// This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="languageOption">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
/// <param name="targetEntityFrameworkVersion">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
public EntityCodeGenerator(LanguageOption languageOption, Version targetEntityFrameworkVersion)
{
_entityCodeGenerator = new Sded.EntityCodeGenerator((Sded.LanguageOption)languageOption);
_targetEntityFrameworkVersion = targetEntityFrameworkVersion;
}
internal static ReflectionAdapter Create(LanguageOption language, Version targetEntityFrameworkVersion)
{
if (language == LanguageOption.GenerateCSharpCode)
{
if (targetEntityFrameworkVersion >= EntityFrameworkVersions.Latest)
{
return new ReflectionAdapter(CreateCSharpCodeGeneratorV3());
}
else
{
return new ReflectionAdapter(CreateCSharpCodeGeneratorV2());
}
}
else
{
Debug.Assert(language == LanguageOption.GenerateVBCode, "Did you add a new option?");
if (targetEntityFrameworkVersion >= EntityFrameworkVersions.Latest)
{
return new ReflectionAdapter(CreateVBCodeGeneratorV3());
}
else
{
return new ReflectionAdapter(CreateVBCodeGeneratorV2());
}
}
}
private static string GetFileExtensionForLanguageOption(
LanguageOption langOption)
{
if (langOption == LanguageOption.GenerateCSharpCode)
{
return ".cs";
}
else
{
return ".vb";
}
}
private EventBox CreateTable(string calegory, List <PropertyItem> propertyItem)
{
EventBox eventBox = new EventBox();
Table table = new Table((uint)(propertyItem.Count + 1), 2u, false);
Label label = new Label();
label.HeightRequest = 16;
table.Attach(label, 1u, 2u, 0u, 1u, AttachOptions.Expand, AttachOptions.Fill, 0u, 0u);
label.Show();
uint num = 1u;
foreach (PropertyItem current in propertyItem)
{
ITypeEditor editor = this.em.GetEditor(current);
Widget widget;
if (editor == null)
{
widget = current.WidgetDate;
}
else
{
current.TypeEditor = editor;
widget = editor.ResolveEditor(current);
}
if (current.DiaplayName == "grid_sudoku_size" || current.DiaplayName == "Fill_color")
{
if (widget == null)
{
num += 1u;
}
else
{
if (widget is Entry)
{
Entry entry = widget as Entry;
table.Add(entry);
entry.Show();
}
else
{
table.Add(widget);
}
widget.Show();
Table.TableChild tableChild = (Table.TableChild)table[widget];
tableChild.LeftAttach = 0u;
tableChild.RightAttach = 2u;
tableChild.TopAttach = num;
tableChild.BottomAttach = num + 1u;
tableChild.XOptions = (AttachOptions.Expand | AttachOptions.Fill);
tableChild.YOptions = AttachOptions.Fill;
num += 1u;
}
}
else
{
ContentLabel contentLabel = new ContentLabel(90);
contentLabel.SetLabelText(LanguageOption.GetValueBykey(current.DiaplayName));
table.Add(contentLabel);
contentLabel.Show();
Table.TableChild tableChild2 = (Table.TableChild)table[contentLabel];
tableChild2.TopAttach = num;
tableChild2.BottomAttach = num + 1u;
tableChild2.XOptions = AttachOptions.Fill;
tableChild2.YOptions = AttachOptions.Fill;
if (widget == null)
{
num += 1u;
}
else
{
Alignment alignment = new Alignment(0.5f, 0.5f, 1f, 1f);
if (widget is Entry)
{
Entry entry = widget as Entry;
alignment.BottomPadding = 16u;
alignment.Add(entry);
entry.Show();
alignment.Show();
table.Add(alignment);
}
else
{
if (widget is INumberEntry)
{
if ((widget as INumberEntry).GetMenuVisble())
{
alignment.BottomPadding = 8u;
}
else
{
alignment.BottomPadding = 16u;
}
}
else
{
alignment.BottomPadding = 16u;
}
alignment.Add(widget);
widget.Show();
alignment.Show();
table.Add(alignment);
}
Table.TableChild tableChild = (Table.TableChild)table[alignment];
tableChild.LeftAttach = 1u;
tableChild.RightAttach = 2u;
tableChild.TopAttach = num;
tableChild.BottomAttach = num + 1u;
tableChild.XOptions = (AttachOptions.Expand | AttachOptions.Fill);
tableChild.YOptions = AttachOptions.Fill;
num += 1u;
}
}
}
table.ColumnSpacing = 10u;
eventBox.Add(table);
table.Show();
eventBox.CanFocus = false;
return(eventBox);
}
private void OptimizeContextCore(
LanguageOption languageOption,
string baseFileName,
SelectedItem selectedItem,
Action<string> generateAction)
{
DebugCheck.NotEmpty(baseFileName);
var progressTimer = new Timer { Interval = 1000 };
try
{
var selectedItemPath = (string)selectedItem.ProjectItem.Properties.Item("FullPath").Value;
var viewsFileName = baseFileName
+ ".Views"
+ ((languageOption == LanguageOption.GenerateCSharpCode)
? FileExtensions.CSharp
: FileExtensions.VisualBasic);
var viewsPath = Path.Combine(
Path.GetDirectoryName(selectedItemPath),
viewsFileName);
_package.DTE2.SourceControl.CheckOutItemIfNeeded(viewsPath);
var progress = 1;
progressTimer.Tick += (sender, e) =>
{
_package.DTE2.StatusBar.Progress(true, string.Empty, progress, 100);
progress = progress == 100 ? 1 : progress + 1;
_package.DTE2.StatusBar.Text = Strings.Optimize_Begin(baseFileName);
};
progressTimer.Start();
Task.Factory.StartNew(
() =>
{
generateAction(viewsPath);
})
.ContinueWith(
t =>
{
progressTimer.Stop();
_package.DTE2.StatusBar.Progress(false);
if (t.IsFaulted)
{
_package.LogError(Strings.Optimize_Error(baseFileName), t.Exception);
return;
}
selectedItem.ProjectItem.ContainingProject.ProjectItems.AddFromFile(viewsPath);
_package.DTE2.ItemOperations.OpenFile(viewsPath);
_package.DTE2.StatusBar.Text = Strings.Optimize_End(baseFileName, Path.GetFileName(viewsPath));
},
TaskScheduler.FromCurrentSynchronizationContext());
}
catch
{
progressTimer.Stop();
_package.DTE2.StatusBar.Progress(false);
throw;
}
}
internal void Populate(object objectItem, List <PropertyItem> itemList, int type = 0, object instance = null)
{
if (itemList.Count == 0 || objectItem == null)
{
this.expandTable = new Table(1u, 1u, false);
}
else
{
itemList.Sort((PropertyItem a, PropertyItem b) => a.Calegory.CompareTo(b.Calegory));
List <string> list = new List <string>();
List <CatagoryAttribute> list2 = new List <CatagoryAttribute>();
Attribute[] customAttributes = Attribute.GetCustomAttributes(objectItem.GetType(), true);
for (int i = 0; i < customAttributes.Length; i++)
{
Attribute attribute = customAttributes[i];
if (attribute is CatagoryAttribute)
{
list2.Add(attribute as CatagoryAttribute);
}
}
list2.Sort((CatagoryAttribute a, CatagoryAttribute b) => a.Order.CompareTo(b.Order));
list2.RemoveAll((CatagoryAttribute w) => w.Group != type);
if (itemList.FirstOrDefault <PropertyItem>().InstanceList.Count > 1)
{
list2.RemoveAll((CatagoryAttribute w) => w.Group == 1);
}
using (List <CatagoryAttribute> .Enumerator enumerator = list2.GetEnumerator())
{
while (enumerator.MoveNext())
{
CatagoryAttribute item = enumerator.Current;
PropertyItem propertyItem = itemList.FirstOrDefault((PropertyItem w) => w.Calegory == item.Catatory);
if (propertyItem != null)
{
list.Add(item.Catatory);
}
}
}
this.expandTable = new Table((uint)list.Count, 1u, false);
uint num = 0u;
using (List <string> .Enumerator enumerator2 = list.GetEnumerator())
{
while (enumerator2.MoveNext())
{
string item = enumerator2.Current;
List <PropertyItem> list3 = (from w in itemList
where w.Calegory == item
select w).ToList <PropertyItem>();
if (list3 != null)
{
list3.Sort((PropertyItem a, PropertyItem b) => (a.PropertyOrder ?? -10).CompareTo(b.PropertyOrder ?? -10));
Widget widget;
if (objectItem is IPropertyTitle)
{
CustomExpender customExpender = this.CreateExpand(LanguageOption.GetValueBykey(item), list3);
customExpender.ExpandCategory = item;
customExpender.ExpandChanged += new EventHandler <ExpandEvent>(this.expand_ExpandChanged);
widget = customExpender;
customExpender.Expanded = (this.category.FirstOrDefault((string w) => w == item) == null);
widget.CanFocus = true;
}
else
{
widget = this.CreateTable(LanguageOption.GetValueBykey(item), list3);
}
this.expandTable.Attach(widget, 0u, 1u, num, num + 1u, AttachOptions.Expand | AttachOptions.Fill, AttachOptions.Fill, 0u, 0u);
widget.Show();
num += 1u;
}
}
}
}
}
private void OptimizeContextEF6(
LanguageOption languageOption,
string baseFileName,
dynamic mappingCollection,
SelectedItem selectedItem,
string contextTypeName)
{
DebugCheck.NotEmpty(baseFileName);
OptimizeContextCore(
languageOption,
baseFileName,
selectedItem,
viewsPath =>
{
var edmSchemaError = ((Type)mappingCollection.GetType()).Assembly
.GetType("System.Data.Entity.Core.Metadata.Edm.EdmSchemaError", true);
var listOfEdmSchemaError = typeof(List<>).MakeGenericType(edmSchemaError);
var errors = Activator.CreateInstance(listOfEdmSchemaError);
var views = ((Type)mappingCollection.GetType())
.GetMethod("GenerateViews", new[] { listOfEdmSchemaError })
.Invoke(mappingCollection, new[] { errors });
foreach (var error in (IEnumerable<dynamic>)errors)
{
if ((int)error.Severity == 1)
{
throw new EdmSchemaErrorException(Strings.Optimize_SchemaError(baseFileName));
}
}
var viewGenerator = languageOption == LanguageOption.GenerateVBCode
? (IViewGenerator)new VBViewGenerator()
: new CSharpViewGenerator();
viewGenerator.ContextTypeName = contextTypeName;
viewGenerator.MappingHashValue = mappingCollection.ComputeMappingHashValue();
viewGenerator.Views = views;
File.WriteAllText(viewsPath, viewGenerator.TransformText());
});
}
public static Grammar GetGrammar(LanguageOption options)
{
return(grammars.ContainsKey(options) ? grammars[options] : new UOSLGrammar(options));
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(TypeToken.ValueString);
}
internal UOSLBase(LanguageOption options = LanguageOption.Native)
{
if (CanCache)
{
grammars[options] = this;
}
Options = options;
this.DefaultNodeType = typeof(ScopedNode);
#region Declare Terminals Here
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
Identifier.AstNodeType = typeof(UoFieldExpressionNode);
_L = ToTerm("L");
MarkReservedWords("L");
#endregion
#region Functions
TypedFunction.Rule = Function_void | Function_int | Function_string | Function_ustring | Function_loc | Function_obj | Function_list;
Function_void.Rule = _void + _functionname_void;
Function_int.Rule = _int + _functionname_int;
Function_string.Rule = _string + _functionname_str;
Function_ustring.Rule = _ustring + _functionname_ustr;
Function_loc.Rule = _loc + _functionname_loc;
Function_obj.Rule = _obj + _functionname_obj;
Function_list.Rule = _list + _functionname_list;
#endregion
#region Externals
_any.SetFlag(TermFlags.IsKeyword);
if (!Keywords.ContainsKey(_any.Text))
{
Keywords[_any.Text] = _any;
}
ExternalParam.Rule = (_int | _string | _ustring | _loc | _obj | _list | _any | _void) + (ToTerm("&").Q()) + (Identifier.Q());
ExternalParams.Rule = MakeStarRule(ExternalParams, _comma, ExternalParam);
Function_any.Rule = _any + _functionname_void; // only valid for Core Commands
ExternalDeclaration.Rule = ToTerm("external") + (Function_any | TypedFunction) + _openparen_punc + ExternalParams + _closeparen_punc + _semicolon;
#endregion
BracePair(_openbracket, _closebracket);
BracePair(_openparen_op, _closeparen_op);
BracePair(_openparen_punc, _closeparen_punc);
BracePair(_openbrace, _closebrace);
BracePair(_openchevron, _closechevron);
this.Delimiters = "{}[](),:;+-*/%&|^!~<>=";
this.MarkPunctuation(_semicolon, _comma, _openparen_punc, _closeparen_punc, _openbrace, _closebrace, _openbracket, _closebracket, _colon);
RegisterOperators(-1, _assignment);
RegisterOperators(1, _logicalnegation, _increment, _decrement);
RegisterOperators(0, _plus, _minus, _multiply, _divide, _remainder, _isequal, _isnotequal, _lowerthen, _greaterthen, _lowerthenorequal,
_greaterthenorequal, _logicaland, _logicalor, _bitwiseexclusiveor);
this.LanguageFlags = LanguageFlags.CreateAst;
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(string.Format("{0}{1}{2}{3}{4}", Indenter(indentationlevel), Name.Text, Punct.LPara.Value, string.Join(",", Arguments.Select(arg => arg.GenerateScript(options))), Punct.RPara.Value));
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(Indenter(indentationlevel, "{0}{1}", Declaration.GenerateScript(options), (Assign == null) ? string.Empty : Assign.GenerateScript(options)));
}
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
LanguageOption Options = context.GetOptions();
ParseTreeNode forBlock = treeNode.ChildNodes[1].FirstChild;
if (forBlock.ChildNodes[0].ChildNodes.Count > 0 && forBlock.ChildNodes[0].FirstChild.ChildNodes.Count > 0)
{
LoopInitializer = StatementNode.GetStatement(forBlock.ChildNodes[0].FirstChild.FirstChild, context) as IStatement;
if (LoopInitializer != null)
{
((ScopedNode)LoopInitializer).Parent = this;
ChildNodes.Add(((ScopedNode)LoopInitializer));
}
}
if (forBlock.ChildNodes[1].ChildNodes.Count > 0 && forBlock.ChildNodes[1].FirstChild.ChildNodes.Count > 0)
{
LoopExpression = ExpressionNode.Reduce(forBlock.ChildNodes[1].FirstChild.FirstChild);
if (LoopExpression is ScopedNode)
{
((ScopedNode)LoopExpression).Parent = this;
ChildNodes.Add(((ScopedNode)LoopExpression));
}
}
if (forBlock.ChildNodes[2].ChildNodes.Count > 0 && forBlock.ChildNodes[2].FirstChild.ChildNodes.Count > 0)
{
LoopStatement = StatementNode.GetStatement(forBlock.ChildNodes[2].FirstChild.FirstChild, context) as IStatement;
if (LoopStatement != null)
{
((ScopedNode)LoopStatement).Parent = this;
ChildNodes.Add(((ScopedNode)LoopStatement));
}
}
ScopedNode LoopNode = StatementNode.GetStatement(treeNode.LastChild, context, false);
Loop = LoopNode as IStatement;
if (Loop != null)
{
((ScopedNode)Loop).Parent = this;
ChildNodes.Add(((ScopedNode)Loop));
}
else
{
context.AddParserMessage(ParserErrorLevel.Error, treeNode.LastChild.Span, "Loop statement is invalid.");
}
if (!Options.HasOption(LanguageOption.UnBracedLoopsIfs) && !(Loop is BlockNode))
{
context.AddParserMessage(ParserErrorLevel.Error, LoopNode.Span, "Statement must be enclosed in a block.");
}
if (LoopExpression == null || !(LoopInitializer is AssignmentNode || LoopInitializer is VariableDeclarationNode))
{
if (Options != LanguageOption.Extended) // Extended will be normalized without error
{
if (!(LoopInitializer is AssignmentNode || LoopInitializer is VariableDeclarationNode || LoopInitializer == null))
{
context.AddParserMessage(ParserErrorLevel.Error, forBlock.ChildNodes[0].Span, "Loop initializer must be empty, or an assignment or declaration.");
}
if (LoopExpression == null)
{
context.AddParserMessage(ParserErrorLevel.Error, forBlock.ChildNodes[1].Span, "Loop expression cannot be empty.");
}
}
else
{
context.AddParserMessage(ParserErrorLevel.Info, forBlock.ChildNodes[0].Span, "Invalid For loop will be converted to a While.");
}
}
}
private static void CodeGen(FileInfo edmxFile, LanguageOption languageOption)
{
XDocument xdoc = XDocument.Load(edmxFile.FullName);
Version v = _namespaceManager.GetVersionFromEDMXDocument(xdoc);
XElement c = GetCsdlFromEdmx(xdoc);
StringWriter sw = new StringWriter();
IList<EdmSchemaError> errors = null;
//
// code-gen uses different classes for V1 and V2 of the EF
//
if (v == EntityFrameworkVersions.Version1)
{
// generate code
EntityClassGenerator codeGen = new EntityClassGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
else if (v == EntityFrameworkVersions.Version2)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
// write out code-file
string outputFileName = GetFileNameWithNewExtension(edmxFile,
GetFileExtensionForLanguageOption(languageOption));
File.WriteAllText(outputFileName, sw.ToString());
// output errors
WriteErrors(errors);
}
public static bool HasOption(this LanguageOption options, LanguageOption option)
{
return((options & option) == option);
}
public string GetBody(MailBodyOption mailBodyOption, LanguageOption language, object content) =>
mailBodyOption switch
{
internal void LoadFile(string path, ScopedNode node, ParsingContext context, IDictionary <string, string> refDepends = null)
{
string curExt = context.CurrentParseTree.FileName == "<Source>" ? null : Path.GetExtension(context.CurrentParseTree.FileName);
string fullpath
= curExt == null ? null : Utils.FindFile(string.Format("{0}.{1}", path, curExt), context.CurrentParseTree.FileName)
?? Utils.FindFile(path, context.CurrentParseTree.FileName)
?? Utils.FindFile(string.Format("{0}.uosl", path), context.CurrentParseTree.FileName)
?? Utils.FindFile(string.Format("{0}.uosl.q", path), context.CurrentParseTree.FileName);
if (fullpath != null)
{
fullpath = (new FileInfo(fullpath)).FullName;
FileInfo fi = new FileInfo(fullpath);
ParseCache cache;
if (!Inherits.TryGetValue(fullpath, out cache) || fi.LastWriteTime > cache.FileDate)
{
Inherits[fullpath] = cache = new ParseCache(fi.LastWriteTime);
LanguageOption options = Utils.DetermineFileLanguage(fullpath, this.Options);
ParsingContext subcontext = new ParsingContext(new Parser(options == this.Options ? this : GetGrammar(options)));
using (StreamReader reader = new StreamReader(fullpath))
{
Inherits[fullpath] = cache = new ParseCache(fi.LastWriteTime, subcontext.Parser.Parse(reader.ReadToEnd(), fullpath));
}
}
if (refDepends != null)
{
refDepends.Add(path, fullpath);
}
if (cache.Tree != null)
{
if (cache.Tree.HasErrors())
{
foreach (ParserMessage error in cache.Tree.ParserMessages)
{
if (error is ExternalErrorMessage)
{
context.AddParserMessage(error);
}
else
{
context.AddParserMessage(new ExternalErrorMessage(fullpath, error.Level, error.Location, error.Message, error.ParserState));
}
}
}
if (cache.Tree.Root != null && cache.Tree.Root.AstNode != null)
{
if (((ScopedNode)cache.Tree.Root.AstNode).ScopeVars != null)
{
foreach (Field field in ((ScopedNode)cache.Tree.Root.AstNode).ScopeVars)
{
node.AddVar(field, context);
}
}
if (((ScopedNode)cache.Tree.Root.AstNode).TreeFuncs != null)
{
foreach (Method method in ((ScopedNode)cache.Tree.Root.AstNode).TreeFuncs)
{
AddFunc(method, context);
}
}
if (refDepends != null && cache.Tree.Root.FirstChild.AstNode is DeclarationsNode)
{
foreach (var kvp in ((DeclarationsNode)cache.Tree.Root.FirstChild.AstNode).Depends)
{
if (refDepends.ContainsKey(kvp.Key))
{
context.AddParserMessage(ParserErrorLevel.Error, node.Span, "A recursion of inheritance detected occurred when parsing {0}.", kvp.Key);
}
else
{
refDepends.Add(kvp.Key, kvp.Value);
}
}
}
}
}
}
else
{
context.AddParserError("{0} Dependancy not found.", path);
}
}
/// <summary>
/// Create the instance of ViewGenerator with the given language option.
/// </summary>
/// <param name="languageOption">Language Option for generated code.</param>
public EntityViewGenerator(LanguageOption languageOption)
{
m_languageOption = EDesignUtil.CheckLanguageOptionArgument(languageOption, "languageOption");
}
public override string GenerateScript(LanguageOption options, int indentationlevel = 0)
{
return(Indenter(indentationlevel, "{0} {1}", UoTypeToken.Value, Name.Text));
}
private static string GetCodeGenerationDisabledComment(LanguageOption languageOption, string inputFileName)
{
if (LanguageOption.GenerateVBCode == languageOption)
{
return string.Format(CultureInfo.CurrentCulture, Strings.CodeGenerationDisabledCommentVB, inputFileName);
}
else
{
return string.Format(CultureInfo.CurrentCulture, Strings.CodeGenerationDisabledCommentCSharp, inputFileName);
}
}
public static bool ValidateAndGenerateViews(String edmxFile, LanguageOption languageOption, bool generateViews, out String viewsOut, out List<Object> errors)
{
viewsOut = String.Empty;
XDocument xdoc = XDocument.Load(edmxFile);
XElement c = GetCsdlFromEdmx(xdoc);
XElement s = GetSsdlFromEdmx(xdoc);
XElement m = GetMslFromEdmx(xdoc);
Version v = _namespaceManager.GetVersionFromEDMXDocument(xdoc);
// load the csdl
XmlReader[] cReaders = { c.CreateReader() };
IList<EdmSchemaError> cErrors = null;
EdmItemCollection edmItemCollection =
MetadataItemCollectionFactory.CreateEdmItemCollection(cReaders, out cErrors);
// load the ssdl
XmlReader[] sReaders = { s.CreateReader() };
IList<EdmSchemaError> sErrors = null;
StoreItemCollection storeItemCollection =
MetadataItemCollectionFactory.CreateStoreItemCollection(sReaders, out sErrors);
// load the msl
XmlReader[] mReaders = { m.CreateReader() };
IList<EdmSchemaError> mErrors = null;
StorageMappingItemCollection mappingItemCollection = MetadataItemCollectionFactory.CreateStorageMappingItemCollection(edmItemCollection, storeItemCollection, mReaders, out mErrors);
// either pre-compile views or validate the mappings
IList<EdmSchemaError> viewGenerationErrors = null;
if (generateViews)
{
// generate views
EntityViewGenerator evg = new EntityViewGenerator(languageOption);
using (var writer = new StringWriter())
{
viewGenerationErrors = evg.GenerateViews(mappingItemCollection, writer, v);
viewsOut = writer.ToString();
}
}
else
{
viewGenerationErrors = EntityViewGenerator.Validate(mappingItemCollection, v);
}
// write errors
errors = new List<Object>();
errors.AddRange(cErrors);
errors.AddRange(sErrors);
errors.AddRange(mErrors);
errors.AddRange(viewGenerationErrors);
if (errors.Count > 0)
return true;
return false;
}
public void SetImage(object current, int num = 1, string rootType = "")
{
string str1 = string.Empty;
if (current != null)
{
str1 = current.GetType().Name;
}
if (string.IsNullOrEmpty(str1))
{
str1 = "MultiObject";
}
this._imageWidget.Image = ImageIcon.GetIcon("CocoStudio.DefaultResource.ComponentResource." + str1.Substring(0, str1.Length - 6) + ".png");
this._imageWidget.ShowAll();
if (num > 1)
{
Label label = new Label();
this.labelTable.Attach((Widget)label, 0U, 1U, 0U, 1U, AttachOptions.Expand, AttachOptions.Fill, 0U, 0U);
label.Show();
label.Text = string.Format("{0}{1}", (object)num, (object)LanguageInfo.ImageText);
}
else
{
foreach (object customAttribute in current.GetType().GetCustomAttributes(false))
{
if (customAttribute is DisplayNameAttribute)
{
string str2 = LanguageOption.GetValueBykey((customAttribute as DisplayNameAttribute).DisplayName);
if (!string.IsNullOrEmpty(rootType))
{
str2 = rootType;
}
if (str2.Length > 8)
{
Label label1 = new Label();
Label label2 = new Label();
this.labelTable.Attach((Widget)label1, 0U, 1U, 0U, 1U, AttachOptions.Expand, AttachOptions.Fill, 0U, 0U);
this.labelTable.Attach((Widget)label2, 0U, 1U, 1U, 2U, AttachOptions.Expand, AttachOptions.Fill, 0U, 0U);
label1.Show();
label2.Show();
int num1 = 0;
for (int index = 1; index < str2.Length; ++index)
{
if ((int)str2[index] >= 65 && (int)str2[index] <= 90)
{
num1 = index;
break;
}
}
label1.Text = str2.Substring(0, num1);
label2.Text = str2.Substring(num1, str2.Length - num1);
break;
}
Label label = new Label();
this.labelTable.Attach((Widget)label, 0U, 1U, 0U, 1U, AttachOptions.Expand, AttachOptions.Fill, 0U, 0U);
label.Show();
label.Text = str2;
break;
}
}
}
}
private static bool ParseLanguageOption(string arg, out LanguageOption langOption)
{
langOption = LanguageOption.GenerateCSharpCode;
if ("vb".Equals(arg, StringComparison.OrdinalIgnoreCase))
{
langOption = LanguageOption.GenerateVBCode;
return true;
}
else if ("cs".Equals(arg, StringComparison.OrdinalIgnoreCase))
{
langOption = LanguageOption.GenerateCSharpCode;
return true;
}
else
{
ShowUsage();
return false;
}
}
private static void ValidateAndGenerateViews(FileInfo edmxFile, LanguageOption languageOption, bool generateViews)
{
XDocument doc = XDocument.Load(edmxFile.FullName);
XElement c = GetCsdlFromEdmx(doc);
XElement s = GetSsdlFromEdmx(doc);
XElement m = GetMslFromEdmx(doc);
// load the csdl
XmlReader[] cReaders = { c.CreateReader() };
IList<EdmSchemaError> cErrors = null;
EdmItemCollection edmItemCollection =
MetadataItemCollectionFactory.CreateEdmItemCollection(cReaders, out cErrors);
// load the ssdl
XmlReader[] sReaders = { s.CreateReader() };
IList<EdmSchemaError> sErrors = null;
StoreItemCollection storeItemCollection =
MetadataItemCollectionFactory.CreateStoreItemCollection(sReaders, out sErrors);
// load the msl
XmlReader[] mReaders = { m.CreateReader() };
IList<EdmSchemaError> mErrors = null;
StorageMappingItemCollection mappingItemCollection =
MetadataItemCollectionFactory.CreateStorageMappingItemCollection(
edmItemCollection, storeItemCollection, mReaders, out mErrors);
// either pre-compile views or validate the mappings
IList<EdmSchemaError> viewGenerationErrors = null;
if (generateViews)
{
// generate views & write them out to a file
string outputFile =
GetFileNameWithNewExtension(edmxFile, ".GeneratedViews" +
GetFileExtensionForLanguageOption(languageOption));
EntityViewGenerator evg = new EntityViewGenerator(languageOption);
viewGenerationErrors =
evg.GenerateViews(mappingItemCollection, outputFile);
}
else
{
viewGenerationErrors = EntityViewGenerator.Validate(mappingItemCollection);
}
// write errors
WriteErrors(cErrors);
WriteErrors(sErrors);
WriteErrors(mErrors);
WriteErrors(viewGenerationErrors);
}
public EntityCodeGenerator(LanguageOption languageOption)
{
_languageOption = EDesignUtil.CheckLanguageOptionArgument(languageOption, "languageOption");
}
public override Task AddGeneratedClientCodeAsync(string metadataUri, string outputDirectory, LanguageOption languageOption, ServiceConfiguration serviceConfiguration)
{
AddedClientCode = true;
return Task.CompletedTask;
}
private void OptimizeContextCore(
LanguageOption languageOption,
string baseFileName,
SelectedItem selectedItem,
Action <string> generateAction)
{
DebugCheck.NotEmpty(baseFileName);
var progressTimer = new Timer {
Interval = 1000
};
try
{
var selectedItemPath = (string)selectedItem.ProjectItem.Properties.Item("FullPath").Value;
var viewsFileName = baseFileName
+ ".Views"
+ ((languageOption == LanguageOption.GenerateCSharpCode)
? FileExtensions.CSharp
: FileExtensions.VisualBasic);
var viewsPath = Path.Combine(
Path.GetDirectoryName(selectedItemPath),
viewsFileName);
_package.DTE2.SourceControl.CheckOutItemIfNeeded(viewsPath);
var progress = 1;
progressTimer.Tick += (sender, e) =>
{
_package.DTE2.StatusBar.Progress(true, string.Empty, progress, 100);
progress = progress == 100 ? 1 : progress + 1;
_package.DTE2.StatusBar.Text = Strings.Optimize_Begin(baseFileName);
};
progressTimer.Start();
Task.Factory.StartNew(
() =>
{
generateAction(viewsPath);
})
.ContinueWith(
t =>
{
progressTimer.Stop();
_package.DTE2.StatusBar.Progress(false);
if (t.IsFaulted)
{
_package.LogError(Strings.Optimize_Error(baseFileName), t.Exception);
return;
}
selectedItem.ProjectItem.ContainingProject.ProjectItems.AddFromFile(viewsPath);
_package.DTE2.ItemOperations.OpenFile(viewsPath);
_package.DTE2.StatusBar.Text = Strings.Optimize_End(baseFileName, Path.GetFileName(viewsPath));
},
TaskScheduler.FromCurrentSynchronizationContext());
}
catch
{
progressTimer.Stop();
_package.DTE2.StatusBar.Progress(false);
throw;
}
}
/// <summary>
/// This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.
/// </summary>
/// <param name="languageOption">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
/// <param name="targetEntityFrameworkVersion">This API supports the Entity Framework infrastructure and is not intended to be used directly from your code.</param>
public EntityCodeGenerator(LanguageOption languageOption, Version targetEntityFrameworkVersion)
{
_entityCodeGenerator = new Sded.EntityCodeGenerator((Sded.LanguageOption)languageOption);
_targetEntityFrameworkVersion = targetEntityFrameworkVersion;
}
