public string Generate(LiteralExpressionSyntax literal, SemanticModel semanticModel) { if (literal.IsKind(SyntaxKind.NullLiteralExpression)) { return("null"); } if (literal.IsKind(SyntaxKind.TrueLiteralExpression)) { return("true"); } if (literal.IsKind(SyntaxKind.FalseLiteralExpression)) { return("false"); } if (literal.IsKind(SyntaxKind.NumericLiteralExpression)) { return(literal.ToString()); } if (literal.IsKind(SyntaxKind.StringLiteralExpression)) { return(literal.ToString()); } if (literal.IsKind(SyntaxKind.CharacterLiteralExpression)) { return(literal.ToString()); } throw new NotImplementedException(); }
/// <summary> /// リテラル式構文のTypeScript変換 /// </summary> /// <param name="condition">ExpressionSyntaxインスタンス</param> /// <param name="localDeclarationStatements">ローカル変数リスト</param> /// <returns>TypeScriptに変換した文字列</returns> private string ConvertExpression(LiteralExpressionSyntax condition, List <string> localDeclarationStatements) { if (!IsLocalDeclarationStatement(condition, localDeclarationStatements)) { return("this." + condition.ToString()); } return(condition.ToString()); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() == SyntaxKind.StringLiteralExpression) { cb.Append("std::string(").Append(node.ToString()).Append(")"); } else { cb.Append(node.ToString()); } }
public static string LiteralExpression(LiteralExpressionSyntax expression) { var r = ""; switch (expression.Kind()) { //Swift doesn't use the same 'c' character literal syntax, instead you create a String and type annotate it as a Character case SyntaxKind.CharacterLiteralExpression: //this is sketch, probably shouldn't use char literals o.o r = '"' + expression.Token.ValueText.Replace("\\'", "'").Replace("\"", "\\\"") + '"'; break; case SyntaxKind.NullKeyword: case SyntaxKind.NullLiteralExpression: switch (Builder.Instance.Language) { case Languages.Swift: r = "nil"; break; case Languages.Kotlin: r = "null"; break; case Languages.TypeScript: r = "null"; break; case Languages.Php: r = "null"; break; } break; case SyntaxKind.StringLiteralExpression: r = Builder.Instance.LanguageConvertLiteralExpressionString(expression.ToString()); break; default: r = expression.ToString(); break; } r = expression.ToFullString().Replace(expression.ToString(), r); return(r); }
public static void Go(HaxeWriter writer, LiteralExpressionSyntax expression) { var str = expression.ToString(); if (str.StartsWith("@")) str = "\"" + str.RemoveFromStartOfString("@\"").RemoveFromEndOfString("\"").Replace("\\", "\\\\").Replace("\"\"", "\\\"") + "\""; if (str.StartsWith("'") && str.EndsWith("'")) { //chars just get written as integers str = str.Substring(1, str.Length - 2); if (str.StartsWith("\\")) str = str.Substring(1); if (str.Length != 1) throw new Exception("Unexpected char string: " + str); str = ((int)str[0]).ToString(); } if (str.EndsWith("f") && !str.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) str = str.Substring(0, str.Length - 1); writer.Write(str); }
private LiteralExpression convertLiteralExpressionValue(LiteralExpressionSyntax literalExpressionSyntax) { var le = new LiteralExpression(); var str = literalExpressionSyntax.ToString(); int i; double d; if (int.TryParse(str, out i)) { le.LiteralValue = i; le.LiteType = TypeReference.Parse("int"); } else if (double.TryParse(str, out d)) { le.LiteralValue = d; le.LiteType = TypeReference.Parse("double"); } else { le.LiteralValue = str; le.LiteType = TypeReference.Parse("string"); } return(le); }
public static void Go(HaxeWriter writer, LiteralExpressionSyntax expression) { var str = expression.ToString(); if (str.StartsWith("@")) { str = "\"" + str.RemoveFromStartOfString("@\"").RemoveFromEndOfString("\"").Replace("\\", "\\\\").Replace("\"\"", "\\\"") + "\""; } if (expression.Token.Kind() == SyntaxKind.CharacterLiteralToken) { //chars just get written as integers str = ((int)(char)expression.Token.Value).ToString(); } if (str.EndsWith("f") && !str.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) { str = str.Substring(0, str.Length - 1); } if (str.EndsWith("L")) { str = str.Substring(0, str.Length - 1); } writer.Write(str); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.StringLiteralExpression) && node.ToString().IndexOf('\n') >= 0) { node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation); } return(base.VisitLiteralExpression(node)); }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.IsKind(SyntaxKind.StringLiteralExpression) && node.ToString().IndexOf('\n') >= 0) { node = node.WithAdditionalAnnotations(LayoutAnnotations.MultiLineConstructAnnotation); } return base.VisitLiteralExpression(node); }
public static string LiteralExpression(LiteralExpressionSyntax node) { switch (node.CSharpKind()) { case SyntaxKind.CharacterLiteralExpression: //this is sketch, probably shouldn't use char literals o.o return('"' + node.Token.ValueText.Replace("\\'", "'").Replace("\"", "\\\"") + '"'); default: return(node.ToString()); } }
public static void Go(ScalaWriter writer, LiteralExpressionSyntax expression, bool isConst) { var str = expression.ToString(); if (str.StartsWith("@")) { str = "\"" + str.RemoveFromStartOfString("@\"").RemoveFromEndOfString("\"").Replace("\\", "\\\\").Replace("\"\"", "\\\"").Replace("\n", "\\n").Replace("\r", "") + "\""; } if (str.Length > 65000) { //Big strings have to be broken up, scala can't render big string constants, even when concatenated. So we have to pass them to a function to concat at runtime writer.Write("System.CsScala.JoinConstants("); var raw = str.RemoveFromStartOfString("\"").RemoveFromEndOfString("\""); var subLength = 65000; for (int i = 0; i < raw.Length; i += subLength) { var sub = raw.SubstringSafe(i, subLength); //Make sure we never break in the middle of a backslash sequence. TODO: This assumes backslash sequences are only ever two characters long, we could break on longer ones. if (sub[sub.Length - 1] == '\\' && sub[sub.Length - 2] != '\\') { sub += raw[i + subLength]; i++; } writer.Write("\""); writer.Write(sub); writer.Write("\""); if (i + subLength < raw.Length) { writer.Write(", "); } } writer.Write(")"); } else { writer.Write(str); } var typeInfo = Program.GetModel(expression).GetTypeInfo(expression); if (typeInfo.Type != null && typeInfo.ConvertedType != null) { if (isConst == false && typeInfo.ConvertedType.SpecialType == SpecialType.System_Byte && typeInfo.Type.SpecialType == SpecialType.System_Int32) { writer.Write(".toByte"); } } }
public static string LiteralExpression(LiteralExpressionSyntax expression) { switch (expression.CSharpKind()) { //Swift doesn't use the same 'c' character literal syntax, instead you create a String and type annotate it as a Character case SyntaxKind.CharacterLiteralExpression: //this is sketch, probably shouldn't use char literals o.o return('"' + expression.Token.ValueText.Replace("\\'", "'").Replace("\"", "\\\"") + '"'); default: return(expression.ToString()); } }
public override int VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() != SyntaxKind.NumericLiteralExpression) { throw new InvalidOperationException($"Invalid literal type: {node}"); } var value = node.ToString(); if (value.StartsWith("0x")) { return(Convert.ToInt32(value.Substring(2), 16)); } return(int.Parse(value)); }
public static void SetAnnotations(List <VariableDeclarationStatementSyntax> annotations) { if (annotations == null || !_varValid) { return; } _activeVar.Annotations = new Dictionary <string, string>(); foreach (VariableDeclarationStatementSyntax vdsSyntax in annotations) { SeparatedSyntaxList <VariableDeclaratorSyntax> sSyntaxList = vdsSyntax.Declaration.Variables; if (sSyntaxList.Count != 1) { _varValid = false; return; } VariableDeclaratorSyntax vdSyntax = sSyntaxList[0]; string key = vdSyntax.Identifier.ValueText; EqualsValueClauseSyntax evcSyntax = (EqualsValueClauseSyntax)vdSyntax.Initializer; string value = ""; if (evcSyntax.Value is StringLiteralExpressionSyntax) { StringLiteralExpressionSyntax sleSyntax = (StringLiteralExpressionSyntax)evcSyntax.Value; List <SyntaxToken> tokens = sleSyntax.Tokens; if (tokens.Count > 0) { value = tokens[0].ValueText; } } else if (evcSyntax.Value is PrefixUnaryExpressionSyntax) { PrefixUnaryExpressionSyntax ueSyntax = (PrefixUnaryExpressionSyntax)evcSyntax.Value; value = ueSyntax.ToString(); } else if (evcSyntax.Value is LiteralExpressionSyntax) { LiteralExpressionSyntax ueSyntax = (LiteralExpressionSyntax)evcSyntax.Value; value = ueSyntax.ToString(); } else { throw new Exception("Unsupported annontation"); } _activeVar.Annotations.Add(key, value); } }
public static string GetLiteral(this ExpressionSyntax expression, SemanticModel semanticModel) { Contract.Requires(expression != null); Contract.Requires(semanticModel != null); if (expression is LiteralExpressionSyntax) { return(expression.ToString()); } IdentifierNameSyntax identifier = expression as IdentifierNameSyntax; if (identifier != null) { var referencedIdentifier = semanticModel.GetSymbolInfo(identifier); if (referencedIdentifier.Symbol != null) { IFieldSymbol fieldReference = referencedIdentifier.Symbol as IFieldSymbol; if (fieldReference == null) { ILocalSymbol localSymbol = referencedIdentifier.Symbol as ILocalSymbol; return(localSymbol?.ConstantValue?.ToString()); } // Checking if the field is a constant string value = fieldReference.ConstantValue?.ToString(); if (value != null) { return(value); } // Checking if the field is static readonly with literal initializer if (fieldReference.IsStatic && fieldReference.IsReadOnly) { var referencedSyntax = fieldReference.DeclaringSyntaxReferences.FirstOrDefault(); VariableDeclaratorSyntax declarator = referencedSyntax?.GetSyntax() as VariableDeclaratorSyntax; LiteralExpressionSyntax literal = declarator?.Initializer.Value as LiteralExpressionSyntax; if (literal != null) { return(literal.ToString()); } } } } return(null); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.NumericLiteralExpression: var v = decimal.Parse(node.ToString(), CultureInfo.InvariantCulture); if (_TupleValues == null) { Values.Push(new BidAsk(v)); } else { _TupleValues.Push(v); } break; } }
public override Tristate VisitLiteralExpression(LiteralExpressionSyntax node) { Tristate state; if (_symbolStates.TryGetValue(node.ToString(), out state)) { return(state); } switch (node.Kind()) { case SyntaxKind.TrueLiteralExpression: return(Tristate.True); case SyntaxKind.FalseLiteralExpression: return(Tristate.False); default: throw new InvalidPreprocessorExpressionException("Expected true or false literal expression"); } }
public static void Go(ScalaWriter writer, LiteralExpressionSyntax expression, bool isConst) { var str = expression.ToString(); if (str.StartsWith("@")) { str = "\"" + str.RemoveFromStartOfString("@\"").RemoveFromEndOfString("\"").Replace("\\", "\\\\").Replace("\"\"", "\\\"").Replace("\r\n", "\\n") + "\""; } var typeInfo = Program.GetModel(expression).GetTypeInfo(expression); writer.Write(str); if (typeInfo.Type != null && typeInfo.ConvertedType != null) { if (isConst == false && typeInfo.ConvertedType.SpecialType == SpecialType.System_Byte && typeInfo.Type.SpecialType == SpecialType.System_Int32) { writer.Write(".toByte"); } } }
public static void Go(OutputWriter writer, LiteralExpressionSyntax expression, bool isConst) { var str = expression.ToString(); if (str.StartsWith("@")) { str = "\"" + str.RemoveFromStartOfString("@\"") .RemoveFromEndOfString("\"") .Replace("\\", "\\\\") .Replace("\"\"", "\\\"") .Replace("\r\n", "\\n") + "\""; } var typeInfo = TypeProcessor.GetTypeInfo(expression); var type = typeInfo.Type; if (type == null) { type = typeInfo.ConvertedType; } if (type != null && type.SpecialType == SpecialType.System_String) { writer.Write("_S(" + str + ")"); } else { writer.Write(str); } //TODO: will handle these separately // if (typeInfo.Type != null && typeInfo.ConvertedType != null) // { // if (isConst == false && typeInfo.ConvertedType.SpecialType ==SpecialType.System_Byte && typeInfo.Type.SpecialType == SpecialType.System_Int32) // writer.Write(".toByte"); // } }
private static bool IsNoCandidateDiagnostic(LiteralExpressionSyntax literal) { return literal.ToString() != "\"\"" || literal.Ancestors().OfType<AttributeArgumentSyntax>().Any() || literal.Ancestors().OfType<ParameterListSyntax>().Any(); }
private static bool IsNoCandidateDiagnostic(LiteralExpressionSyntax literal) { return(literal.ToString() != "\"\"" || literal.Ancestors().OfType <AttributeArgumentSyntax>().Any() || literal.Ancestors().OfType <ParameterListSyntax>().Any()); }
public static bool Qualifies(LiteralExpressionSyntax node) => EnvironmentVariableInterpolation.Qualifies(node.ToString());
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { if (node.Kind() == SyntaxKind.StringLiteralExpression) cb.Append("std::string(").Append(node.ToString()).Append(")"); else cb.Append(node.ToString()); }
public static void Go(OutputWriter writer, LiteralExpressionSyntax expression, bool isConst, bool inSwitch = false) { var str = expression.ToString(); if (str.Trim() == "null") { writer.Write("null"); return; } if (str.StartsWith("@\"")) { str = "r" + FixUpLiterals(EncodeNonAsciiCharacters(FixUpLiterals(str.Substring(1)))); /*str = "\"" + * str.RemoveFromStartOfString("@\"") * .RemoveFromEndOfString("\"") * .Replace("\\", "\\\\") * .Replace("\"\"", "\\\"") * .Replace("\r\n", "\\n") + "\"";*/ } var typeInfo = TypeProcessor.GetTypeInfo(expression); var type = typeInfo.Type; if (type == null) { type = typeInfo.ConvertedType; } if (type != null && type.SpecialType == SpecialType.System_String) { if (str.Contains("\\u") || str.Contains("\\x")) { str = FixUpLiterals(EncodeNonAsciiCharacters(FixUpLiterals(str))); } if (str == "null") { if (inSwitch) { writer.Write("-1"); } else { writer.Write("null"); } } else if (inSwitch) { writer.Write(str); } else { } writer.Write("_S(" + str + ")"); } else if (type != null && type.Name == "Nullable")//Nullable Support { var atype = TypeProcessor.ConvertType(type); writer.Write(atype + "()"); } else { if (type.SpecialType == SpecialType.System_Boolean) { writer.Write(str); } else if (type.SpecialType == SpecialType.System_Char) { if (str.Contains("\\u") || str.Contains("\\x")) { writer.Write("cast(wchar)" + FixUpCharacterLiteral(str)); } else { writer.Write(str); } } else { //No need to convert these ... lets just put the correct suffix ourselves if (typeInfo.ConvertedType != typeInfo.Type && typeInfo.ConvertedType.IsPrimitiveInteger() && typeInfo.Type.IsPrimitiveInteger()) { writer.Write("cast({0})", TypeProcessor.ConvertType(typeInfo.ConvertedType)); //TODO: add better, less clumsy conversion } // //Number literals //TODO: make these convert to D Literal Suffixes // var suffix = realTypeSuffixes.FirstOrDefault (j => str.EndsWith (j)); // if (suffix != null) // str = str.Replace(suffix,drealTypeSuffixes[Array.IndexOf(realTypeSuffixes,suffix)]); // else // { // suffix = integerTypeSuffixes.FirstOrDefault (j => str.EndsWith (j)); // if (suffix != null) // str = str.Replace(suffix,dintegerTypeSuffixes[Array.IndexOf(integerTypeSuffixes,suffix)]); // } writer.Write(str); } } }
private async Task <Document> ReplaceStringWithLocalizerFormat(Document document, LiteralExpressionSyntax litDecl, CancellationToken cancellationToken) { try { //Get the details of the ID to use currentProject = ProjectsManager.projects[document.Project.Name]; newIDKey = currentProject.LocalizerSettings.NextTag; newValue = litDecl.ToString(); if (newValue.StartsWith("\"")) { newValue = newValue.Substring(1); } if (newValue.EndsWith("\"")) { newValue = newValue.Substring(0, newValue.Length - 1); } //Get the document var root = await document.GetSyntaxRootAsync(cancellationToken); CompilationUnitSyntax newroot = (CompilationUnitSyntax)root; SyntaxNode replacedNode; try { //Set up the call to Localizer.Format IdentifierNameSyntax localizer = SyntaxFactory.IdentifierName("Localizer"); IdentifierNameSyntax format = SyntaxFactory.IdentifierName("Format"); MemberAccessExpressionSyntax memberaccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, localizer, format); ArgumentSyntax arg = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(newIDKey))); SeparatedSyntaxList <ArgumentSyntax> argList = SyntaxFactory.SeparatedList(new[] { arg }); SyntaxAnnotation syntaxAnnotation = new SyntaxAnnotation("LocalizerFormat"); SyntaxNode writecall = SyntaxFactory.InvocationExpression(memberaccess, SyntaxFactory.ArgumentList(argList) ).WithAdditionalAnnotations(syntaxAnnotation).WithTriviaFrom(litDecl); newroot = newroot.ReplaceNode(litDecl, (SyntaxNode)writecall); //get the changed node back from teh updated document root replacedNode = newroot.GetAnnotatedNodes(syntaxAnnotation).Single(); } catch (Exception ex) { OutputManager.WriteErrorEx(ex, "Unable to compile the Localizer call. Refactor cancelled."); return(null); } try { //find the Trivial that marks the end of this line bool foundEOL = false; SyntaxNode objToCheck = replacedNode; SyntaxTrivia objEOL = SyntaxFactory.Comment(" "); //This look works upwards through the structure by parent to get bigger bits of the // syntax tree to find the first EOL after the replaced Node while (!foundEOL) { //Go up one level objToCheck = objToCheck.Parent; //If we found it get out if (FindEOLAfter(objToCheck, replacedNode.FullSpan.End, ref objEOL)) { foundEOL = true; } //If we just checked the whole document then stop looping if (objToCheck == root) { break; } } //If we found the EOL Trivia then insert the new comment before it if (foundEOL) { var tabs = SyntaxFactory.Whitespace("\t\t"); var comment = SyntaxFactory.Comment("// " + newIDKey + " = " + newValue); List <SyntaxTrivia> lineComment = new List <SyntaxTrivia>(); lineComment.Add(tabs); lineComment.Add(comment); newroot = newroot.InsertTriviaBefore(objEOL, lineComment); } } catch (Exception ex) { OutputManager.WriteErrorEx(ex, "Unable to add comment to end of line. Add it manually if you like."); } try { //Make sure the file has a usings so the short name works if (!newroot.Usings.Any(u => u.Name.GetText().ToString() == "KSP.Localization")) { newroot = newroot.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName("KSP"), SyntaxFactory.IdentifierName("Localization")))); } } catch (Exception ex) { OutputManager.WriteErrorEx(ex, "Unable to add usings line to head of file. Add it manually."); } //Now convert it to the document to send it back try { var result = document.WithSyntaxRoot(newroot); return(result); } catch (Exception ex) { OutputManager.WriteErrorEx(ex, "Unable to rewrite the document. Refactor cancelled."); return(null); } } catch (Exception ex) { OutputManager.WriteErrorEx(ex, "General error refactoring the token. Refactor cancelled."); } return(null); }
public static string LiteralExpression(LiteralExpressionSyntax expression) { switch (expression.CSharpKind()) { //Swift doesn't use the same 'c' character literal syntax, instead you create a String and type annotate it as a Character case SyntaxKind.CharacterLiteralExpression: //this is sketch, probably shouldn't use char literals o.o return '"' + expression.Token.ValueText.Replace("\\'", "'").Replace("\"", "\\\"") + '"'; default: return expression.ToString(); } }
public LiteralMessage(LiteralExpressionSyntax originalExpression) : base(originalExpression) { Contract.Requires(originalExpression != null); Literal = originalExpression.ToString(); }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { switch (node.Kind()) { case SyntaxKind.NullLiteralExpression: AddCilInstruction(ilVar, OpCodes.Ldnull); break; case SyntaxKind.StringLiteralExpression: AddCilInstruction(ilVar, OpCodes.Ldstr, node.ToFullString()); break; case SyntaxKind.CharacterLiteralExpression: case SyntaxKind.NumericLiteralExpression: AddLocalVariableAndHandleCallOnValueTypeLiterals(node, "assembly.MainModule.TypeSystem.Int32", node.ToString()); break; case SyntaxKind.TrueLiteralExpression: case SyntaxKind.FalseLiteralExpression: AddLocalVariableAndHandleCallOnValueTypeLiterals(node, "assembly.MainModule.TypeSystem.Boolean", bool.Parse(node.ToString()) ? 1 : 0); break; default: throw new ArgumentException($"Literal ( {node}) of type {node.Kind()} not supported yet."); } void AddLocalVariableAndHandleCallOnValueTypeLiterals(LiteralExpressionSyntax literalNode, string cecilTypeSystemReference, object literalValue) { AddCilInstruction(ilVar, LoadOpCodeFor(literalNode), literalValue); var localVarParent = (CSharpSyntaxNode)literalNode.Parent; if (localVarParent.Accept(new UsageVisitor()) == UsageKind.CallTarget) { var tempLocalName = MethodExtensions.LocalVariableNameFor("tmp_", "tmp_".UniqueId().ToString()); AddCecilExpression("var {0} = new VariableDefinition({1});", tempLocalName, cecilTypeSystemReference); AddCecilExpression("{0}.Body.Variables.Add({1});", Context.DefinitionVariables.GetLastOf(MemberKind.Method).VariableName, tempLocalName); AddCilInstruction(ilVar, OpCodes.Stloc, $"{tempLocalName}"); AddCilInstruction(ilVar, OpCodes.Ldloca_S, $"{tempLocalName}"); } } }
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node) { var kind = node.Kind(); if ((kind != SyntaxKind.NumericLiteralExpression) && (kind != SyntaxKind.StringLiteralExpression) && (kind != SyntaxKind.FalseLiteralExpression) && (kind != SyntaxKind.TrueLiteralExpression) && (kind != SyntaxKind.CharacterLiteralExpression) ) { return(node); } CheckCastContex(node); string value = node.ToString(); bool found = false; VirtualData constant = null; string requiredType = GetRequiredType(node); //in the case of return statements if (requiredType.Equals("void")) { requiredType = ""; // return statement was added as a refactoring "hack" } var typeInfo = _virtualizationContext.semanticModel.GetTypeInfo(node); var declaredType = typeInfo.Type.ToString(); foreach (var data in _virtualizationContext.data) { if (value.Equals(data.Name)) { if (requiredType.Equals("") && declaredType.Equals(data.Type)) { found = true; constant = data; requiredType = declaredType; break; } if (requiredType.Equals(data.Type)) { found = true; constant = data; break; } } } if (!found) { if (requiredType.Equals("")) { requiredType = declaredType; } int index = _virtualizationContext.DataIndex; string name = value; SyntaxAnnotation dataIndexMarker = new SyntaxAnnotation("index", index + ""); SyntaxAnnotation nameMarker = new SyntaxAnnotation("name", name); SyntaxAnnotation constantMarker = new SyntaxAnnotation("type", "constant"); SyntaxAnnotation codeIndexMarker = new SyntaxAnnotation("code", "undefined"); SyntaxAnnotation uniqueMarker = new SyntaxAnnotation("unique", "" + VirtualizationContext.UniqueId); constant = new VirtualData(); constant.Index = index; constant.Name = name; var info = requiredType; constant.Type = info; constant.Node = node; constant.DefaultValue = node; constant.Annotations.Add(dataIndexMarker); constant.Annotations.Add(nameMarker); constant.Annotations.Add(constantMarker); constant.Annotations.Add(codeIndexMarker); constant.Annotations.Add(uniqueMarker); _virtualizationContext.data.Add(constant); } ExpressionSyntax newNode = SyntaxFactoryExtensions.DataCodeVirtualAccess(); newNode = newNode.WithAdditionalAnnotations(constant.Annotations); ExpressionSyntax newExpression; if (CastEnabled) { newExpression = SyntaxFactory.CastExpression(SyntaxFactory.IdentifierName ( @"" + constant.Type ), newNode ); } else { newExpression = newNode; } //TODO: add annotations + comments newExpression = newExpression.WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()) ; return(newExpression); }
public static void Go(OutputWriter writer, LiteralExpressionSyntax expression, bool isConst, bool inSwitch=false) { var str = expression.ToString(); if (str.Trim() == "null") { writer.Write("null"); return; } if (str.StartsWith("@\"")) { str = "r" + FixUpLiterals(EncodeNonAsciiCharacters(FixUpLiterals(str.Substring(1)))); /*str = "\"" + str.RemoveFromStartOfString("@\"") .RemoveFromEndOfString("\"") .Replace("\\", "\\\\") .Replace("\"\"", "\\\"") .Replace("\r\n", "\\n") + "\"";*/ } var typeInfo = TypeProcessor.GetTypeInfo(expression); var type = typeInfo.Type; if (type == null) type = typeInfo.ConvertedType; if (type != null && type.SpecialType == SpecialType.System_String) { if (str.Contains("\\u") || str.Contains("\\x")) str = FixUpLiterals(EncodeNonAsciiCharacters(FixUpLiterals(str))); if (str == "null") { if (inSwitch) writer.Write("-1"); else writer.Write("null"); } else if (inSwitch) { writer.Write(str); } else { } writer.Write("_S(" + str + ")"); } else if (type != null && type.Name == "Nullable")//Nullable Support { var atype = TypeProcessor.ConvertType(type); writer.Write(atype + "()"); } else { if(type.SpecialType==SpecialType.System_Boolean) writer.Write(str); else if (type.SpecialType == SpecialType.System_Char) { if(str.Contains("\\u") || str.Contains("\\x")) writer.Write("cast(wchar)"+FixUpCharacterLiteral(str)); else { writer.Write(str); } } else { //No need to convert these ... lets just put the correct suffix ourselves if (typeInfo.ConvertedType != typeInfo.Type && typeInfo.ConvertedType.IsPrimitiveInteger() && typeInfo.Type.IsPrimitiveInteger()) { writer.Write("cast({0})",TypeProcessor.ConvertType(typeInfo.ConvertedType)); //TODO: add better, less clumsy conversion } // //Number literals //TODO: make these convert to D Literal Suffixes // var suffix = realTypeSuffixes.FirstOrDefault (j => str.EndsWith (j)); // if (suffix != null) // str = str.Replace(suffix,drealTypeSuffixes[Array.IndexOf(realTypeSuffixes,suffix)]); // else // { // suffix = integerTypeSuffixes.FirstOrDefault (j => str.EndsWith (j)); // if (suffix != null) // str = str.Replace(suffix,dintegerTypeSuffixes[Array.IndexOf(integerTypeSuffixes,suffix)]); // } writer.Write(str); } } }
public override void VisitLiteralExpression(LiteralExpressionSyntax node) { Value = node.ToString(); base.VisitLiteralExpression(node); }