protected override void VisitClassDefinition(ClassDefinitionNode classDefinitionNode)
{
string className = classDefinitionNode.NameNode.Value;
ClassSymbol classSymbol = new ClassSymbol(className, classDefinitionNode);
AddSymbol(classSymbol);
Visit(classDefinitionNode.AttributeNodes);
}
public BoundVariableExpression(VariableSymbol variable, BoundExpression index, TypeSymbol baseType, ClassSymbol inClass = null)
{
Variable = variable;
Index = index;
isArray = true;
Type = baseType;
InClass = inClass;
}
//TODO: Investigate removing these.
private void ImportPseudoMembers(PseudoClassMembers memberSet, ClassSymbol classSymbol)
{
// Import pseudo members that go on the class but aren't defined in mscorlib.dll
// These are meant to be used by internal compiler-generated transformations etc.
// and aren't meant to be referenced directly in C# code.
if (memberSet == PseudoClassMembers.Script)
{
AddScriptSymbolPseudoMembers(classSymbol);
return;
}
if (memberSet == PseudoClassMembers.Arguments)
{
TypeSymbol objectType =
(TypeSymbol)((ISymbolTable)symbols.SystemNamespace).FindSymbol(nameof(Object), null,
SymbolFilter.Types);
Debug.Assert(objectType != null);
IndexerSymbol indexer = new IndexerSymbol(classSymbol, objectType,
MemberVisibility.Public | MemberVisibility.Static);
indexer.SetScriptIndexer();
classSymbol.AddMember(indexer);
return;
}
if (memberSet == PseudoClassMembers.Dictionary)
{
TypeSymbol intType =
(TypeSymbol)((ISymbolTable)symbols.SystemNamespace).FindSymbol(nameof(Int32), null, SymbolFilter.Types);
Debug.Assert(intType != null);
TypeSymbol stringType =
(TypeSymbol)((ISymbolTable)symbols.SystemNamespace).FindSymbol(nameof(String), null,
SymbolFilter.Types);
Debug.Assert(stringType != null);
// Define Dictionary.Keys
MethodSymbol getKeysMethod = new MethodSymbol("GetKeys", classSymbol,
symbols.CreateArrayTypeSymbol(stringType), MemberVisibility.Public | MemberVisibility.Static);
getKeysMethod.SetTransformName(DSharpStringResources.ScriptExportMember("keys"));
classSymbol.AddMember(getKeysMethod);
// Define Dictionary.Values
MethodSymbol getValuesMethod = new MethodSymbol("GetValues", classSymbol,
symbols.CreateArrayTypeSymbol(stringType), MemberVisibility.Public | MemberVisibility.Static);
getValuesMethod.SetTransformName(DSharpStringResources.ScriptExportMember("values"));
classSymbol.AddMember(getValuesMethod);
// Define Dictionary.GetCount
MethodSymbol countMethod = new MethodSymbol("GetKeyCount", classSymbol, intType,
MemberVisibility.Public | MemberVisibility.Static);
countMethod.SetTransformName(DSharpStringResources.ScriptExportMember("keyCount"));
classSymbol.AddMember(countMethod);
}
}
private static void GenerateDelegateExpression(ScriptGenerator generator, MemberSymbol symbol, DelegateExpression expression)
{
ScriptTextWriter writer = generator.Writer;
AnonymousMethodSymbol anonymousMethod = expression.Method as AnonymousMethodSymbol;
if (anonymousMethod != null)
{
writer.Write("function(");
if ((anonymousMethod.Parameters != null) && (anonymousMethod.Parameters.Count != 0))
{
int paramIndex = 0;
foreach (ParameterSymbol parameterSymbol in anonymousMethod.Parameters)
{
if (paramIndex > 0)
{
writer.Write(", ");
}
writer.Write(parameterSymbol.GeneratedName);
paramIndex++;
}
}
writer.WriteLine(") {");
writer.Indent++;
CodeGenerator.GenerateScript(generator, anonymousMethod);
writer.Indent--;
writer.Write("}");
}
else if ((expression.Method.Visibility & MemberVisibility.Static) != 0)
{
if (expression.Method.IsExtension)
{
Debug.Assert(expression.Method.Parent.Type == SymbolType.Class);
ClassSymbol classSymbol = (ClassSymbol)expression.Method.Parent;
Debug.Assert(classSymbol.IsExtenderClass);
writer.Write(classSymbol.Extendee);
writer.Write(".");
writer.Write(expression.Method.GeneratedName);
}
else
{
ExpressionGenerator.GenerateExpression(generator, symbol, expression.ObjectReference);
writer.Write(".");
writer.Write(expression.Method.GeneratedName);
}
}
else
{
writer.Write("ss.bind('");
writer.Write(expression.Method.GeneratedName);
writer.Write("', ");
ExpressionGenerator.GenerateExpression(generator, symbol, expression.ObjectReference);
writer.Write(")");
}
}
private static void GenerateGlobalMethods(ScriptGenerator generator, ClassSymbol classSymbol)
{
foreach (MemberSymbol memberSymbol in classSymbol.Members)
{
Debug.Assert(memberSymbol.Type == SymbolType.Method);
Debug.Assert((memberSymbol.Visibility & MemberVisibility.Static) != 0);
MemberGenerator.GenerateScript(generator, memberSymbol);
}
}
private static void GenerateClass(ScriptGenerator generator, ClassSymbol classSymbol)
{
ScriptTextWriter writer = generator.Writer;
string name = classSymbol.FullGeneratedName;
GenerateClassConstructor(generator, classSymbol, writer, name);
GenerateClassStaticMembers(generator, classSymbol);
GenerateClassMembers(generator, classSymbol, writer, name);
}
private static void GenerateClassStaticMembers(ScriptGenerator generator, ClassSymbol classSymbol)
{
foreach (MemberSymbol memberSymbol in classSymbol.Members)
{
if (memberSymbol.Type != SymbolType.Field && memberSymbol.Visibility.HasFlag(MemberVisibility.Static))
{
MemberGenerator.GenerateScript(generator, memberSymbol);
}
}
}
private static CompletionItemKind GetCompletionKind(ISymbol symbol)
{
return(symbol switch {
ClassSymbol _ => CompletionItemKind.Class,
MethodSymbol _ => CompletionItemKind.Method,
FunctionSymbol _ => CompletionItemKind.Function,
VariableSymbol _ => CompletionItemKind.Variable,
FieldSymbol _ => CompletionItemKind.Field,
_ => CompletionItemKind.Reference
});
public EditClassCommand(ClassSymbol symbol, string name, Size size, Color color, Drawing drawing)
{
this.Symbol = symbol;
this.OldName = symbol.label;
this.OldSize = symbol.Size;
this.OldColor = symbol.ClassColor;
this.EditedName = name;
this.EditedSize = size;
this.EditedColor = color;
this.TargetDrawing = drawing;
}
public void genericEnterClass(String name, ParserRuleContext ctx, String superClass)
{
ClassSymbol classS = new ClassSymbol(name, currentScope, new ClassSymbol(superClass, null, null));
currentScope.define(classS);
saveScope(ctx, classS);
currentScope = classS;
allScopes.Add(currentScope);
treesByScopes.Add(currentScope, ctx);
m_classInSource.Add(name.ToUpper(), classS);
}
public MethodSymbol(string name, ClassSymbol returnType, ScopeWithMethods enclosingScope)
{
this.name = name;
this.returnType = returnType;
this.enclosingScope = enclosingScope;
this.memory = new Memory(START_ADDRESS, MAX_ADDRESS);
variables = new Dictionary<string, VariableSymbol>();
parametros = new LinkedList<VariableSymbol>();
localVariables = new LinkedList<VariableSymbol>();
defineThisImplicitParameter();
}
public void genericEnterClass(string name, ParserRuleContext ctx)
{
//String name = ctx.identifier().getText();
ClassSymbol classS = new ClassSymbol(name, currentScope, null);
currentScope.define(classS);
saveScope(ctx, classS);
currentScope = classS;
allScopes.Add(currentScope);
treesByScopes.Add(currentScope, ctx);
m_classInSource.Add(name.ToUpper(), classS);
}
private BoundClassType BindClassDeclaration(ClassTypeSyntax declaration, Symbol parent)
{
ClassSymbol baseClass = null;
var baseInterfaces = new List <InterfaceSymbol>();
if (declaration.BaseList != null)
{
var baseType = Bind(declaration.BaseList.BaseType, x => BindType(x, parent));
switch (baseType.TypeSymbol.Kind)
{
case SymbolKind.Class:
baseClass = (ClassSymbol)baseType.TypeSymbol;
break;
case SymbolKind.Interface:
baseInterfaces.Add((InterfaceSymbol)baseType.TypeSymbol);
break;
}
}
var classBinder = new Binder(_sharedBinderState, this);
var classSymbol = new ClassSymbol(declaration, parent, baseClass, baseInterfaces.ToImmutableArray(), classBinder);
AddSymbol(classSymbol, declaration.Name.Span);
var members = new List <BoundNode>();
foreach (var memberSyntax in declaration.Members)
{
switch (memberSyntax.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
members.Add(classBinder.Bind((VariableDeclarationStatementSyntax)memberSyntax, x => classBinder.BindVariableDeclarationStatement(x, classSymbol)));
break;
case SyntaxKind.FunctionDeclaration:
members.Add(classBinder.Bind((FunctionDeclarationSyntax)memberSyntax, x => classBinder.BindFunctionDeclaration(x, classSymbol)));
break;
case SyntaxKind.FunctionDefinition:
members.Add(classBinder.Bind((FunctionDefinitionSyntax)memberSyntax, x => classBinder.BindFunctionDefinition(x, classSymbol)));
break;
}
}
foreach (var member in classBinder.LocalSymbols.Values.SelectMany(x => x))
{
classSymbol.AddMember(member);
}
return(new BoundClassType(classSymbol, members.ToImmutableArray()));
}
public EditClass(ClassSymbol Symbol, Drawing targetDrawing, Invoker invoker)
{
InitializeComponent();
_invoker = invoker;
EditedSymbol = Symbol;
NameTextBox.Text = Symbol.label;
string widthText = Symbol.Size.Width.ToString();
string heightText = Symbol.Size.Height.ToString();
WidthTextBox.Text = widthText;
HeightTextBox1.Text = heightText;
TargetDrawing = targetDrawing;
receivedColor = Symbol.ClassColor;
}
public static void GenerateClassConstructorScript(ScriptGenerator generator, ClassSymbol classSymbol)
{
// NOTE: This is emitted last in the script file, and separate from the initial class definition
// because it needs to be emitted after the class registration.
foreach (MemberSymbol memberSymbol in classSymbol.Members)
{
if (memberSymbol.Type == SymbolType.Field &&
(memberSymbol.Visibility & MemberVisibility.Static) != 0)
{
FieldSymbol fieldSymbol = (FieldSymbol)memberSymbol;
if (fieldSymbol.IsConstant &&
(memberSymbol.Visibility & (MemberVisibility.Public | MemberVisibility.Protected)) == 0)
{
// PrivateInstance/Internal constant fields are omitted since they have been inlined
continue;
}
if (fieldSymbol.HasInitializer)
{
MemberGenerator.GenerateScript(generator, memberSymbol);
}
}
}
if (classSymbol.StaticConstructor != null)
{
ScriptTextWriter writer = generator.Writer;
SymbolImplementation implementation = classSymbol.StaticConstructor.Implementation;
bool requiresFunctionScope = implementation.DeclaresVariables;
if (requiresFunctionScope)
{
writer.WriteLine("(function() {");
writer.Indent++;
}
CodeGenerator.GenerateScript(generator, classSymbol.StaticConstructor);
if (requiresFunctionScope)
{
writer.Indent--;
writer.Write("})();");
writer.WriteLine();
}
}
}
public ClassSymbol(string name, ClassSymbol superClass)
{
this.name = name;
methods = new Dictionary<string, MethodSymbol>();
variables = new Dictionary<string, VariableSymbol>();
this.memory = new Memory(START_ADDRESS, MAX_ADDRESS);
this.superClass = superClass;
if (superClass != null)
{
for (int i = 1; i <= superClass.countVariables(); i++)
{
this.memory.nextAddress();
}
}
}
private void ImportBaseType(ClassSymbol classSymbol)
{
TypeDefinition type = (TypeDefinition)classSymbol.MetadataReference;
TypeReference baseType = type.BaseType;
if (baseType != null)
{
ClassSymbol baseClassSymbol = ResolveType(baseType) as ClassSymbol;
if ((baseClassSymbol != null) &&
(String.CompareOrdinal(baseClassSymbol.FullName, "Object") != 0))
{
classSymbol.SetInheritance(baseClassSymbol, /* interfaces */ null);
}
}
}
public BoundObjectAccessExpression(VariableSymbol variable, ObjectAccessExpression.AccessType accessType, FunctionSymbol function, ImmutableArray <BoundExpression> arguments, VariableSymbol property, TypeSymbol type, BoundExpression value, Package.Package package, ClassSymbol _class, BoundTypeCallExpression typeCall, BoundExpression expression, TypeSymbol innerType)
{
Variable = variable;
AccessType = accessType;
Function = function;
Arguments = arguments;
Property = property;
_type = type;
Value = value;
Package = package;
Class = _class;
TypeCall = typeCall;
Expression = expression;
InnerType = innerType;
}
protected virtual ClassSymbol VisitClassSymbol(ClassSymbol classSymbol)
{
foreach (var extendedInterfaceSymbol in classSymbol?.Interfaces ?? Enumerable.Empty <InterfaceSymbol>())
{
Visit(extendedInterfaceSymbol);
}
TypeSymbol baseType = classSymbol.GetBaseType();
if (baseType != null)
{
Visit(baseType);
}
return(classSymbol);
}
public RandomizeCommand(Drawing drawing)
{
TargetDrawing = drawing;
OldSymbols = new List <ClassSymbol>();
foreach (ClassSymbol symbol in TargetDrawing._ClassSymbols)
{
ClassSymbol oldSymbol = new ClassSymbol(symbol.Location, symbol.Size, symbol.ClassColor, symbol.ForegroundColor);
OldSymbols.Add(oldSymbol);
}
OldLines = new List <Relationship>();
foreach (Relationship line in TargetDrawing._RelationShipLines)
{
Relationship oldLine = RelationshipFactory.Instance.Create(line.type, line.Location1, line.Location2, TargetDrawing);
OldLines.Add(oldLine);
}
}
private ClassSymbol ProcessClass(Symbol scope, ClassDecl classDeclaration)
{
_cancellationToken.ThrowIfCancellationRequested();
var classSymbol = new ClassSymbol(scope, classDeclaration);
foreach (var member in classDeclaration.Members)
{
var memberSymbol = ProcessClassMember(classSymbol, member);
if (memberSymbol != null)
{
// TODO When respecting all possible class members, this should never be null.
classSymbol.Members.Add(memberSymbol);
}
}
return(classSymbol);
}
private static void GenerateClassMembers(ScriptGenerator generator, ClassSymbol classSymbol, ScriptTextWriter writer, string name)
{
if (classSymbol.IsStaticClass)
{
return;
}
writer.Write("var ");
writer.Write(name);
writer.WriteLine("$ = {");
writer.Indent++;
bool firstMember = true;
foreach (MemberSymbol memberSymbol in classSymbol.Members.Where(member => !member.Visibility.HasFlag(MemberVisibility.Static)))
{
if (memberSymbol.Type == SymbolType.Field ||
(memberSymbol is CodeMemberSymbol codeMemberSymbol && codeMemberSymbol.IsAbstract) ||
(memberSymbol is PropertySymbol propertySymbol && propertySymbol.IsAutoProperty()))
{
continue;
}
if (firstMember == false)
{
writer.WriteLine(",");
}
MemberGenerator.GenerateScript(generator, memberSymbol);
firstMember = false;
}
if (classSymbol.Indexer != null)
{
if (firstMember == false)
{
writer.WriteLine(",");
}
MemberGenerator.GenerateScript(generator, classSymbol.Indexer);
}
writer.Indent--;
writer.WriteLine();
writer.Write("};");
writer.WriteLine();
}
public SymbolTable()
{
directory = new Dictionary<string, ScopeWithMethods>();
ClassSymbol integers = new ClassSymbol(integerName, null);
directory.Add(integers.name, integers);
ClassSymbol chars = new ClassSymbol(charName, null);
directory.Add(chars.name, chars);
ClassSymbol doubles = new ClassSymbol(doubleName, null);
directory.Add(doubles.name, doubles);
ClassSymbol bools = new ClassSymbol(boolName, null);
directory.Add(bools.name, bools);
directory.Add(arrayClassSymbol.name, arrayClassSymbol);
ClassSymbol tipoVoid = new ClassSymbol(voidName, null);
directory.Add(tipoVoid.name, tipoVoid);
}
public void MoveClassTest() //tests moving a class
{
_testInvoker.Start();
Point Location1 = new Point(100, 102);
AddCommand command1 = new AddCommand("Class", Location1, Location1, testDrawing);
_testInvoker.EnqueueCommandForExecution(command1);
System.Threading.Thread.Sleep(1000);
Symbol symbol = testDrawing.FindSymbolAtPosition(Location1);
Point newLocation = new Point(0, 0);
ClassSymbol classSymbol = symbol as ClassSymbol;
MoveClassCommand cmd = new MoveClassCommand(classSymbol, newLocation, testDrawing);
_testInvoker.EnqueueCommandForExecution(cmd);
System.Threading.Thread.Sleep(1000);
Assert.AreEqual(newLocation, testDrawing._ClassSymbols[0].Location);
}
private static void GenerateBaseInitializerExpression(ScriptGenerator generator, MemberSymbol symbol, BaseInitializerExpression expression)
{
ScriptTextWriter writer = generator.Writer;
Debug.Assert(symbol.Parent is ClassSymbol);
ClassSymbol baseClass = ((ClassSymbol)symbol.Parent).BaseClass;
Debug.Assert(baseClass != null);
writer.Write(baseClass.FullGeneratedName);
writer.Write(".call(this");
if (expression.Parameters != null)
{
writer.Write(", ");
GenerateExpressionList(generator, symbol, expression.Parameters);
}
writer.Write(")");
}
private void GenerateClassRegistration(ClassSymbol classSymbol, List <ClassSymbol> generatedClasses)
{
Debug.Assert(classSymbol != null);
if (generatedClasses.Contains(classSymbol))
{
return;
}
ClassSymbol baseClass = classSymbol.BaseClass;
if ((baseClass != null) && baseClass.IsApplicationType)
{
GenerateClassRegistration(baseClass, generatedClasses);
}
TypeGenerator.GenerateClassRegistrationScript(this, classSymbol);
generatedClasses.Add(classSymbol);
}
private void BuildTypeInheritance(ClassSymbol classSymbol)
{
if (classSymbol.PrimaryPartialClass != classSymbol)
{
// Don't build type inheritance for non-primary partial classes.
return;
}
CustomTypeNode customTypeNode = (CustomTypeNode)classSymbol.ParseContext;
if ((customTypeNode.BaseTypes != null) && (customTypeNode.BaseTypes.Count != 0))
{
ClassSymbol baseClass = null;
List <InterfaceSymbol> interfaces = null;
foreach (NameNode node in customTypeNode.BaseTypes)
{
TypeSymbol baseTypeSymbol = (TypeSymbol)_symbolTable.FindSymbol(node.Name, classSymbol, SymbolFilter.Types);
Debug.Assert(baseTypeSymbol != null);
if (baseTypeSymbol.Type == SymbolType.Class)
{
Debug.Assert(baseClass == null);
baseClass = (ClassSymbol)baseTypeSymbol;
}
else
{
Debug.Assert(baseTypeSymbol.Type == SymbolType.Interface);
if (interfaces == null)
{
interfaces = new List <InterfaceSymbol>();
}
interfaces.Add((InterfaceSymbol)baseTypeSymbol);
}
}
if ((baseClass != null) || (interfaces != null))
{
classSymbol.SetInheritance(baseClass, interfaces);
}
}
}
private void BuildCode(ClassSymbol classSymbol)
{
if (classSymbol.Constructor != null)
{
BuildCode(classSymbol.Constructor);
}
if (classSymbol.StaticConstructor != null)
{
BuildCode(classSymbol.StaticConstructor);
}
if (classSymbol.Indexer != null)
{
BuildCode(classSymbol.Indexer);
}
foreach (MemberSymbol memberSymbol in classSymbol.Members)
{
switch (memberSymbol.Type)
{
case SymbolType.Event:
BuildCode((EventSymbol)memberSymbol);
break;
case SymbolType.Field:
BuildCode((FieldSymbol)memberSymbol);
break;
case SymbolType.Method:
BuildCode((MethodSymbol)memberSymbol);
break;
case SymbolType.Property:
BuildCode((PropertySymbol)memberSymbol);
break;
}
}
}
private void ImportBaseType(ClassSymbol classSymbol)
{
TypeDefinition type = (TypeDefinition)classSymbol.MetadataReference;
ICollection <InterfaceSymbol> interfaces = GetInterfaceSymbols(type.Interfaces);
TypeReference baseType = type.BaseType;
if (baseType != null)
{
if (ResolveType(baseType) is ClassSymbol baseClassSymbol &&
string.CompareOrdinal(baseClassSymbol.FullName, "Object") != 0)
{
classSymbol.SetInheritance(baseClassSymbol, interfaces);
}
}
else
{
classSymbol.SetInheritance(null, interfaces);
}
}
private static bool IsDomElement(TypeSymbol typeSymbol)
{
ClassSymbol classSymbol = typeSymbol as ClassSymbol;
while (classSymbol != null)
{
// TODO: This is a dependency on Script.Web.dll that we should remove.
// For now, changed SymbolSet.FindSymbol to handle the case
// where a namespace being looked up might not be defined.
if (IsSymbol(classSymbol, "System.Html.Element"))
{
return(true);
}
classSymbol = classSymbol.BaseClass;
}
return(false);
}
private static void GenerateClassComment(ScriptTextWriter writer, ClassSymbol classSymbol)
{
GenerateSummaryComment(writer, classSymbol);
if (classSymbol.Constructor != null &&
classSymbol.Constructor.Parameters != null)
{
foreach (ParameterSymbol parameterSymbol in classSymbol.Constructor.Parameters)
{
GenerateParameterComment(writer, parameterSymbol);
}
}
foreach (MemberSymbol memberSymbol in classSymbol.Members)
{
if (memberSymbol is FieldSymbol fieldSymbol)
{
GenerateFieldComment(writer, fieldSymbol);
}
}
}
private BoundClassType BindClassDeclaration(ClassTypeSyntax declaration, Symbol parent)
{
ClassOrStructSymbol baseType;
List <InterfaceSymbol> baseInterfaces;
BindBaseList(declaration.BaseList, parent, out baseType, out baseInterfaces);
var classBinder = new Binder(_sharedBinderState, this);
var classSymbol = new ClassSymbol(declaration, parent, baseType, baseInterfaces.ToImmutableArray(), classBinder);
AddSymbol(classSymbol, declaration.Name.SourceRange);
var members = new List <BoundNode>();
foreach (var memberSyntax in declaration.Members)
{
switch (memberSyntax.Kind)
{
case SyntaxKind.VariableDeclarationStatement:
members.Add(classBinder.Bind((VariableDeclarationStatementSyntax)memberSyntax, x => classBinder.BindField(x, classSymbol)));
break;
case SyntaxKind.FunctionDeclaration:
members.Add(classBinder.Bind((FunctionDeclarationSyntax)memberSyntax, x => classBinder.BindFunctionDeclaration(x, classSymbol)));
break;
case SyntaxKind.FunctionDefinition:
members.Add(classBinder.Bind((FunctionDefinitionSyntax)memberSyntax, x => classBinder.BindFunctionDefinition(x, classSymbol)));
break;
}
}
foreach (var member in classBinder.LocalSymbols.Values.SelectMany(x => x))
{
classSymbol.AddMember(member);
}
return(new BoundClassType(classSymbol, members.ToImmutableArray()));
}
/// <summary>
/// Gets all command methods from this command class.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Result<ImmutableDictionary<string, CommandMethod>, Diagnostic> GetCommandMethods(CancellationToken cancellationToken = default)
{
var dictionaryBuilder =
ImmutableDictionary.CreateBuilder<string, CommandMethod>();
foreach (var methodSymbol in ClassSymbol.GetMembers()
.OfType<IMethodSymbol>()
.Where(method => method.GetAttributes()
.Any(attr => CommandManager.IsCommandAttributeSymbol(attr.AttributeClass!))))
{
cancellationToken.ThrowIfCancellationRequested();
foreach (var attrData in methodSymbol.GetAttributes()
.Where(attr => CommandManager.IsCommandAttributeSymbol(attr.AttributeClass!)))
{
cancellationToken.ThrowIfCancellationRequested();
var attr = Utilities.AttributeFromAttributeData<CommandAttribute>(attrData);
if (Utilities.IsValidCommandName(attr.Name))
{
return Result.Err<ImmutableDictionary<string, CommandMethod>, Diagnostic>(Diagnostic.Create(
DiagnosticDescriptors.InvalidNamePassedToCommandAttribute,
AttributeSyntax.GetLocation(),
methodSymbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat)));
}
if (!dictionaryBuilder.ContainsKey(attr.Name)
|| attr.Overwrite)
{
var commandMethod = CommandMethod.Create(attr, this, methodSymbol);
if (commandMethod.IsErr)
return Result.Err<ImmutableDictionary<string, CommandMethod>, Diagnostic>(commandMethod.Err.Value);
else
dictionaryBuilder[attr.Name] = commandMethod.Ok.Value;
}
}
}
return Result.Ok<ImmutableDictionary<string, CommandMethod>, Diagnostic>(dictionaryBuilder.ToImmutable());
}
private bool isIntOrDouble(ClassSymbol tipo)
{
return tipo.name.Equals(integerName) || tipo.name.
Equals(doubleName);
}
public bool validAssignment(ClassSymbol left, ClassSymbol right)
{
//not allowed to assign a void to anything nor to assign anything to a void
if (left.name.Equals(voidName) || right.name.Equals(voidName))
{
return false;
}
//not allowed to assign an array to anything nor to to assign anything to an array
if (left.name.Equals(arrayName) || right.name.Equals(arrayName))
{
return false;
}
if (left.name.Equals(doubleName))
{
return right.name.Equals(doubleName) || right.name.Equals(integerName);
}
else if (isPrimitiveType(left.name))
{
return left.name.Equals(right.name);
}
else
{
return right.isChildOf(left);
}
}
public ClassSymbol resultType(ClassSymbol left, ClassSymbol right, string op)
{
ClassSymbol resultType = findType(voidName);
//no operator works with void type
if (left.name.Equals(voidName) || right.name.Equals(voidName))
{
return resultType;
}
//no operator works with arrays
if (left.name.Equals(arrayName) || right.name.Equals(arrayName))
{
return resultType;
}
if (isAndOrOperator(op)) //and, or
{
if (left.name.Equals(boolName) && right.name.Equals(boolName))
{
resultType = findType(boolName);
}
}
else if (isEqOrDifOperator(op)) // ==, !=
{
if (SymbolTable.isPrimitiveType(left.name) || SymbolTable.isPrimitiveType(right.name))
{
if (validAssignment(left, right) || validAssignment(right, left))
{
resultType = findType(boolName);
}
}
else
{
resultType = findType(boolName); //reference types can always be compared
}
}
else if (isArithmeticOperator(op)) //+, -, *, /
{
if (isIntOrDouble(left) && isIntOrDouble(right))
{
if (left.name.Equals(doubleName) || right.name.Equals(doubleName))
{
resultType = findType(doubleName);
}
else
{
resultType = findType(integerName);
}
}
}
else if (isRelationalOperator(op)) // >, >=, <, <=
{
if (isIntOrDouble(left) && isIntOrDouble(right))
{
resultType = findType(boolName);
}
}
else
{
ReptileParser.manageException(new Exception("Operador desconocido: " + op));
}
return resultType;
}
public VariableSymbol(string name, ClassSymbol type)
{
this.name = name;
this.type = type;
}
public bool isChildOf(ClassSymbol sup)
{
if (name == sup.name)
{
return true;
}
if (superClass == null)
{
return false;
}
return superClass.isChildOf(sup);
}
public ArrayVariableSymbol(string name, ClassSymbol parameterizedType)
: base(name, SymbolTable.arrayClassSymbol)
{
this.parameterizedType = parameterizedType;
}
public VariableSymbol getNewTemporal(ClassSymbol type)
{
int addressTemp = memory.nextAddress();
VariableSymbol temp = new VariableSymbol("@_" + addressTemp, type);
temp.address = addressTemp;
return temp;
//al parecer no sera necesario definir (registrar) la var temporal en el metodo
}
