private static TypeReference ParseLiteralType(Parser parser, IAbstractSyntaxTree lexerNode) { switch (lexerNode.Type) { case Lexer.TokenType.Long: return(parser.Int64); case Lexer.TokenType.Integer: return(parser.Int32); case Lexer.TokenType.CharLiteral: return(parser.Char); case Lexer.TokenType.StringLiteral: return(parser.String); case Lexer.TokenType.Float: return(parser.Float); case Lexer.TokenType.True: case Lexer.TokenType.False: return(parser.Bool); case Lexer.TokenType.Double: return(parser.Double); default: ContractsHelper.AssumeUnreachable("Unknown literal type"); return(null); //unreachable } }
private static LiteralNode ParseInteger(ProjectParser parser, string value, TypeReference requestedType, SequencePoint point) { try { var parsed = BigInteger.Parse(value, CultureInfo.InvariantCulture); var type = GetLowestConversion(parser, parsed); if (type == null) { ErrorCode.IntegerOverflow.ReportAndThrow(point, "Cannot fit {0} into an integer, use BigInteger.Parse", value); } else { //return what we parsed, if requested type can't fit if (type.IsAssignableTo(requestedType)) { type = requestedType; } } if (parsed.Sign >= 0) { return(new LiteralNode((ulong)parsed, type, point)); } else { return(new LiteralNode((long)parsed, type, point)); } } catch (FormatException) { ContractsHelper.AssumeUnreachable("Error parsing {0} as integer", value); } return(Utils.Utils.Fail <LiteralNode>()); }
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode, TypeReference expectedType = null) { Contract.Ensures(Contract.Result <ExpressionNode>() != null); ExpressionNode ret = null; switch (lexerNode.Type) { case Lexer.TokenType.FullSymbol: case Lexer.TokenType.Symbol: ret = DotOperatorNode.Parse(context, lexerNode); break; case Lexer.TokenType.LiteralNode: ret = LiteralNode.Parse(context, lexerNode); break; case Lexer.TokenType.Value: ret = ExpressionNode.Parse(context, lexerNode.Children[0], expectedType); break; case Lexer.TokenType.Function: ret = MethodNode.Parse(context, lexerNode); break; case Lexer.TokenType.InfixNode: ret = InfixParser.Parse(context, lexerNode); break; case Lexer.TokenType.PostfixNode: case Lexer.TokenType.PrefixNode: ret = UnaryOperators.Parse(context, lexerNode); break; case Lexer.TokenType.ParenthesesNode: ret = ExpressionNode.Parse(context, lexerNode.Children[1], expectedType); break; case Lexer.TokenType.ArrayLiteral: ret = ArrayCreationNode.Parse(context, lexerNode); break; case Lexer.TokenType.Null: ret = NullNode.Parse(context, lexerNode); break; default: ContractsHelper.AssumeUnreachable("Unknown expression type {0}", lexerNode.Type); break; } if (!(expectedType == null || expectedType.IsAuto())) { var ambiguous = ret as IAmbiguousNode; if (ambiguous != null) { ret = ambiguous.RemoveAmbiguity(context, expectedType); } } return(ret); }
private static LiteralNode ParseValue(ProjectParser parser, string value, TypeReference type, SequencePoint point) { try { switch (type.MetadataType) { case MetadataType.String: case MetadataType.Boolean: return(new LiteralNode(value, type, point)); case MetadataType.SByte: case MetadataType.Byte: case MetadataType.Int16: case MetadataType.UInt16: case MetadataType.Int32: case MetadataType.UInt32: case MetadataType.Int64: case MetadataType.UInt64: return(ParseInteger(parser, value, type, point)); case MetadataType.Char: { if (value.Length > 1) { ErrorCode.MultipleCharacterLiteral.ReportAndThrow(point, "Character literal must not be longer than one character (found: '{0}').", value); } return(new LiteralNode(value, type, point)); } case MetadataType.Single: case MetadataType.Double: return(ParseRational(parser, value, type, point)); default: ContractsHelper.AssumeUnreachable(String.Format("Unexpected literal type {0}", type.FullName)); return(null); //unreachable } } catch (OverflowException) { ErrorCode.InvalidStructure.ReportAndThrow(point, "Could not parse {0} as {1}, overflow", value, type.FullName); return(null);//unreachable } catch (FormatException) { ErrorCode.InvalidStructure.ReportAndThrow(point, "Could not parse {0} as {1}, format error", value, type.FullName); return(null);//unreachable } }
private static ModuleKind ParseModuleKinds(IEnumerable <string> moduleKinds) { Contract.Ensures(Contract.Result <ModuleKind>() != ModuleKind.NetModule); var moduleKindCount = moduleKinds.Count(); if (moduleKindCount > 1) { var errorMessage = new StringBuilder("More than one module kind specified:" + Environment.NewLine); foreach (var moduleKind in moduleKinds) { errorMessage.AppendFormat("\t{0}{1}", moduleKind, Environment.NewLine); } Errors.Report(ErrorCode.MoreThanOneModuleKind, errorMessage.ToString()); return(default(ModuleKind)); } else if (moduleKindCount == 0) { return(ModuleKind.Console); } else { switch (moduleKinds.Single().ToLowerInvariant()) { case "/console": return(ModuleKind.Console); case "/windows": return(ModuleKind.Windows); case "/dll": return(ModuleKind.Dll); default: ContractsHelper.AssumeUnreachable(string.Format("Unknown module kind: \"{0}\".", moduleKinds.First())); return(default(ModuleKind)); } } }
public CodeBlockNode AddNode(ParserNode node) { var returning = node as IReturningNode; if (returning != null && returning.Returns) { Returns = true; } var expression = node as ExpressionNode; if (expression != null) { AddExpression(expression); return(this); } var declaration = node as SymbolDeclarationNode; if (declaration != null) { AddDeclaration(declaration); return(this); } // no special action if (node is CodeBlockNode || node is ConditionBlockNode || node is WhileBlock || node is ReturnNode || node is ForLoopNode || node is ForEachNode) { nodes.Add(node); return(this); } ContractsHelper.AssumeUnreachable("Unexpected node {0} in while parsing code block", node.GetType().FullName); return(Utils.Utils.Fail <CodeBlockNode>()); }