/// <returns>A SwumDataRecord containing <paramref name="swumNode"/> and various data extracted from it.</returns> protected SwumDataRecord ProcessSwumNode(FieldDeclarationNode swumNode) { var record = new SwumDataRecord(); record.SwumNode = swumNode; return(record); }
protected void AddSwumForFieldDefinitions(XElement file, string fileName) { //compute SWUM on each field foreach (var fieldDecl in (from declStmt in file.Descendants(SRC.DeclarationStatement) where !declStmt.Ancestors().Any(n => functionTypes.Contains(n.Name)) select declStmt.Element(SRC.Declaration))) { int declPos = 1; foreach (var nameElement in fieldDecl.Elements(SRC.Name)) { string fieldName = nameElement.Elements(SRC.Name).Any() ? nameElement.Elements(SRC.Name).Last().Value : nameElement.Value; FieldDeclarationNode fdn = new FieldDeclarationNode(fieldName, ContextBuilder.BuildFieldContext(fieldDecl)); builder.ApplyRules(fdn); //var signature = string.Format("{0}:{1}:{2}", fileName, fieldDecl.Value, declPos); var signature = nameElement.GetXPath(false); var swumData = ProcessSwumNode(fdn); swumData.FileNames.Add(fileName); lock (signaturesToSwum) { signaturesToSwum[signature] = swumData; } declPos++; } } }
/// <summary> /// If <paramref name="node"/> is a <see cref="FieldDeclarationNode"/>, this method selects /// all <see cref="VariableDeclaratorNode"/> children of <paramref name="node"/>. Otherwise, /// this method returns a collection containing <paramref name="node"/> itself. /// </summary> /// <param name="node">The node.</param> /// <returns> /// If <paramref name="node"/> is a <see cref="FieldDeclarationNode"/>, this method returns /// <see cref="FieldDeclarationNode.VariableDeclarators"/>. Otherwise, this method returns /// a collection containing <paramref name="node"/> itself. /// </returns> private static IEnumerable <ParseTreeNode> SelectDeclaratorsFromFields(ParseTreeNode node) { FieldDeclarationNode fieldDeclarationNode = node as FieldDeclarationNode; if (fieldDeclarationNode == null) { return(Enumerable.Repeat(node, 1)); } return(fieldDeclarationNode.VariableDeclarators); }
public void TestConstructSwum() { string testSrcML = "<class>class <name>foo</name> <block>{<private type=\"default\"><decl_stmt><decl><type><name>int</name></type> <name>a</name></decl>;</decl_stmt></private>}</block>;</class>"; XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace); FieldContext fc = ContextBuilder.BuildFieldContext(xml.Descendants(SRC.Declaration).First()); FieldDeclarationNode fdn = new FieldDeclarationNode("a", fc); FieldRule rule = new FieldRule(posData, tagger, splitter); rule.ConstructSwum(fdn); Console.WriteLine(fdn.ToString()); }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { FieldDeclarationNode fieldNode = (FieldDeclarationNode)node; if (fieldNode.Initializers.Count > 1) { errorHandler.ReportError("Field declarations are limited to a single field per declaration.", fieldNode.Token.Location); return(false); } return(true); }
bool IParseNodeValidator.Validate(ParseNode node, CompilerOptions options, IErrorHandler errorHandler) { FieldDeclarationNode fieldNode = (FieldDeclarationNode)node; if (fieldNode.Initializers.Count > 1) { errorHandler.ReportNodeValidationError(DSharpStringResources.DUPLICATE_FIELD_DECLARATION, fieldNode); return(false); } return(true); }
public SymbolImplementation BuildField(FieldSymbol fieldSymbol) { rootScope = new SymbolScope((ISymbolTable)fieldSymbol.Parent); currentScope = rootScope; Expression initializerExpression = null; FieldDeclarationNode fieldDeclarationNode = (FieldDeclarationNode)fieldSymbol.ParseContext; Debug.Assert(fieldDeclarationNode != null); VariableInitializerNode initializerNode = (VariableInitializerNode)fieldDeclarationNode.Initializers[0]; if (initializerNode.Value != null) { ExpressionBuilder expressionBuilder = new ExpressionBuilder(this, fieldSymbol, errorHandler, options); initializerExpression = expressionBuilder.BuildExpression(initializerNode.Value); if (initializerExpression is MemberExpression) { initializerExpression = expressionBuilder.TransformMemberExpression((MemberExpression)initializerExpression); } } else { TypeSymbol fieldType = fieldSymbol.AssociatedType; SymbolSet symbolSet = fieldSymbol.SymbolSet; if (GetDefaultValue(fieldType, symbolSet) is object defaultValue) { initializerExpression = new LiteralExpression(symbolSet.ResolveIntrinsicType(IntrinsicType.Object), defaultValue); fieldSymbol.SetImplementationState(hasInitializer: true); } } if (initializerExpression != null) { List <Statement> statements = new List <Statement>(); statements.Add(new ExpressionStatement(initializerExpression, /* isFragment */ true)); return(new SymbolImplementation(statements, null, "this")); } return(null); }
/// <summary> /// Constructs the Software Word Use Model on the given node, using this Rule. /// </summary> /// <param name="node">The node to construct the SWUM on.</param> public override void ConstructSwum(ProgramElementNode node) { if (node is FieldDeclarationNode) { FieldDeclarationNode fdn = node as FieldDeclarationNode; fdn.Parse(this.Splitter); this.PosTagger.TagNounPhrase(fdn.ParsedName); fdn.AssignStructuralInformation(this.Splitter, this.PosTagger); //TODO: set fdn.Type.IsPrimitive fdn.SwumRuleUsed = this; } else { //TODO: return some sort of error indicator? Console.Error.WriteLine("FieldRule.ConstructSwum expected a FieldDeclarationNode, received a {0}", node.GetType()); } }
private FieldSymbol BuildField(FieldDeclarationNode fieldNode, TypeSymbol typeSymbol) { TypeSymbol fieldType = typeSymbol.SymbolSet.ResolveType(fieldNode.Type, _symbolTable, typeSymbol); Debug.Assert(fieldType != null); if (fieldType != null) { FieldSymbol symbol = new FieldSymbol(fieldNode.Name, typeSymbol, fieldType); BuildMemberDetails(symbol, typeSymbol, fieldNode, fieldNode.Attributes); if (fieldNode.Initializers.Count != 0) { VariableInitializerNode initializer = (VariableInitializerNode)fieldNode.Initializers[0]; if ((initializer.Value != null) && (initializer.Value.NodeType != ParseNodeType.Literal)) { symbol.SetImplementationState(/* hasInitializer */ true); } } if (fieldNode.NodeType == ParseNodeType.ConstFieldDeclaration) { Debug.Assert(fieldNode.Initializers.Count == 1); VariableInitializerNode initializer = (VariableInitializerNode)fieldNode.Initializers[0]; if ((initializer.Value != null) && (initializer.Value.NodeType == ParseNodeType.Literal)) { symbol.SetConstant(); symbol.Value = ((LiteralToken)initializer.Value.Token).LiteralValue; } // TODO: Handle other constant cases that can be evaluated at compile // time (eg. combining enum flags) } return(symbol); } return(null); }
public SymbolImplementation BuildField(FieldSymbol fieldSymbol) { rootScope = new SymbolScope((ISymbolTable)fieldSymbol.Parent); currentScope = rootScope; Expression initializerExpression = null; FieldDeclarationNode fieldDeclarationNode = (FieldDeclarationNode)fieldSymbol.ParseContext; Debug.Assert(fieldDeclarationNode != null); VariableInitializerNode initializerNode = (VariableInitializerNode)fieldDeclarationNode.Initializers[0]; if (initializerNode.Value != null) { ExpressionBuilder expressionBuilder = new ExpressionBuilder(this, fieldSymbol, errorHandler, options); initializerExpression = expressionBuilder.BuildExpression(initializerNode.Value); if (initializerExpression is MemberExpression) { initializerExpression = expressionBuilder.TransformMemberExpression((MemberExpression)initializerExpression); } } else { object defaultValue = null; TypeSymbol fieldType = fieldSymbol.AssociatedType; SymbolSet symbolSet = fieldSymbol.SymbolSet; if (fieldType.Type == SymbolType.Enumeration) { // The default for named values is null, so this only applies to // regular enum types EnumerationSymbol enumType = (EnumerationSymbol)fieldType; if (enumType.UseNamedValues == false) { defaultValue = 0; } } else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Integer) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedInteger) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Long) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedLong) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Short) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.UnsignedShort) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Byte) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.SignedByte) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Double) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Single) || fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Decimal)) { defaultValue = 0; } else if (fieldType == symbolSet.ResolveIntrinsicType(IntrinsicType.Boolean)) { defaultValue = false; } if (defaultValue != null) { initializerExpression = new LiteralExpression(symbolSet.ResolveIntrinsicType(IntrinsicType.Object), defaultValue); fieldSymbol.SetImplementationState(/* hasInitializer */ true); } } if (initializerExpression != null) { List <Statement> statements = new List <Statement>(); statements.Add(new ExpressionStatement(initializerExpression, /* isFragment */ true)); return(new SymbolImplementation(statements, null, "this")); } return(null); }
public override void Execute() { if (Pause) { Console.WriteLine("Ready to begin (press Enter)"); Console.ReadLine(); } Console.WriteLine("Using srcML file {0}", this.File); var builder = new UnigramSwumBuilder(); if (!string.IsNullOrWhiteSpace(CountFile)) { Console.WriteLine("Initializing SamuraiIdSplitter using word count file {0}", this.CountFile); builder.Splitter = new SamuraiIdSplitter(CountFile); } Console.WriteLine("SwumBuilder initialized"); int methodCount = 0, fieldCount = 0; { SrcMLFile testFile = new SrcMLFile(this.File); var functionTypes = new XName[] { SRC.Function, SRC.Constructor, SRC.Destructor }; foreach (XElement file in testFile.FileUnits) { string fileName = file.Attribute("filename").Value; Console.WriteLine("File {0}:", fileName); //compute SWUM on each function foreach (var func in (from func in file.Descendants() where functionTypes.Contains(func.Name) && !func.Ancestors(SRC.Declaration).Any() select func)) { var nameElement = SrcMLElement.GetNameForMethod(func); if (nameElement != null) { string funcName = nameElement.Value; string funcSignature = SrcMLElement.GetMethodSignature(func); if (PrintSwum) { Console.WriteLine("<{0}> {1}", func.Name.LocalName, funcSignature); } MethodDeclarationNode mdn = new MethodDeclarationNode(funcName, ContextBuilder.BuildMethodContext(func)); builder.ApplyRules(mdn); methodSwum[string.Format("{0}:{1}", fileName, funcSignature)] = mdn; if (PrintSwum) { Console.WriteLine(mdn.ToString() + Environment.NewLine); } methodCount++; } } //compute SWUM on each field foreach (var fieldDecl in (from declStmt in file.Descendants(SRC.DeclarationStatement) where !declStmt.Ancestors().Any(n => functionTypes.Contains(n.Name)) select declStmt.Element(SRC.Declaration))) { int declPos = 1; foreach (var nameElement in fieldDecl.Elements(SRC.Name)) { string fieldName = nameElement.Elements(SRC.Name).Any() ? nameElement.Elements(SRC.Name).Last().Value : nameElement.Value; if (PrintSwum) { Console.WriteLine("Field: {0}, Name: {1}", fieldDecl.Value, fieldName); } FieldDeclarationNode fdn = new FieldDeclarationNode(fieldName, ContextBuilder.BuildFieldContext(fieldDecl)); builder.ApplyRules(fdn); fieldSwum[string.Format("{0}:{1}:{2}", fileName, fieldDecl.Value, declPos)] = fdn; if (PrintSwum) { Console.WriteLine(fdn.ToString() + Environment.NewLine); } fieldCount++; declPos++; } } } } GC.Collect(); Console.WriteLine("{0} functions analyzed", methodCount); Console.WriteLine("{0} functions in dictionary", methodSwum.Count); Console.WriteLine("{0} fields analyzed", fieldCount); Console.WriteLine("{0} fields in dictionary", fieldSwum.Count); if (Pause) { Console.WriteLine("Finished building SWUM (press Enter)"); Console.ReadLine(); } }
private void WriteFieldDeclaration(FieldDeclarationNode fieldDeclarationNode) { WriteDeclaration(fieldDeclarationNode.Declaration); _builder.Append(fieldDeclarationNode.PeriodToken); }
/// <inheritdoc/> public override void VisitFieldDeclarationNode(FieldDeclarationNode node) { }
private static SUnit TranslateAssignment(Statement statement) { // action = "Assign" // define left-hand-side (lhs) // theme = right hand side var fieldRule = SetupFieldRule(); // var equalsSign = statement.GetDescendants<OperatorUse>() // .Where(o => o.Text.Equals("=")).First(); // var lhs = equalsSign.GetSiblingsBeforeSelf<VariableUse>().First(); var assignExpression = (VariableDeclaration)statement.GetExpressions().First(); var lhs = assignExpression.Name; var lhsFieldContext = new FieldContext(assignExpression.VariableType.ToString(), false, ""); var lhsDecNode = new FieldDeclarationNode(lhs.ToString(), lhsFieldContext); fieldRule.InClass(lhsDecNode); fieldRule.ConstructSwum(lhsDecNode); var rhsString = ""; var rhsAction = ""; var rhsTheme = ""; Expression rhs = new Expression(); if (assignExpression.Initializer != null) { rhs = assignExpression.Initializer; } if (rhs is VariableUse) { var rhsFieldContext = new FieldContext(rhs.ResolveType().First().ToString(), false, ""); var rhsDecNode = new FieldDeclarationNode(rhs.ToString(), lhsFieldContext); fieldRule.InClass(rhsDecNode); fieldRule.ConstructSwum(rhsDecNode); rhsAction = "Assign"; rhsString = rhsDecNode.ToPlainString(); } else if (rhs is MethodCall) { string type = rhs.ResolveType().ToString(); MethodContext mc = new MethodContext(type); MethodDeclarationNode mdn = new MethodDeclarationNode(rhs.ToString(), mc); var swumRule = SetupBaseVerbRule(); swumRule.InClass(mdn); swumRule.ConstructSwum(mdn); rhsAction = mdn.Action.ToPlainString(); rhsTheme = mdn.Action.ToPlainString(); rhsString = mdn.ToPlainString(); } else { rhsString = rhs.ToString(); } var sunit = new SUnit(); sunit.type = SUnitType.Assignment; sunit.action = rhsString; //sunit.lhs = lhsDecNode.ToPlainString(); sunit.lhs = lhs.ToString(); sunit.theme = rhsString; return(sunit); }