tiny.chant.parse

1pub const Error = error{2    OutOfMemory,3    NodeCapacityExceeded,4    UnexpectedToken,5    ExpectedType,6    ExpectedIdentifier,7    InvalidConstant,8    StaticAssertionFailed,9    UnsupportedConstruct,10};

1pub fn parseExternal(parser: *Parser) Error![]ast.Decl {2    if (try assertion.consume(parser)) {3        return &.{};4    }5    const specifiers = try ctype.parseSpecifiers(parser);67    var declarations = std.ArrayListUnmanaged(ast.Decl).empty;8    if (cursor.consume(parser, .semicolon)) {9        return declarations.toOwnedSlice(parser.arena);10    }11    if (specifiers.requires_standalone_declaration) {12        return diagnostic.fail(parser, error.UnsupportedConstruct, "fixed enum forward declaration must be standalone");13    }1415    var first = true;16    while (true) {17        try ctype.skipAttributes(parser);18        const declarator = try ctype.parseDeclarator(parser, specifiers.type, expression.parseAssignment);19        try ctype.skipAttributes(parser);20        const name = declarator.name orelse return diagnostic.fail(parser, error.ExpectedIdentifier, "declaration requires a name");2122        if (specifiers.storage == .typedef_storage) {23            try thread.validateTypedef(parser, specifiers.is_thread_local);24            if (specifiers.is_constexpr) {25                return diagnostic.fail(parser, error.UnsupportedConstruct, "typedef cannot be constexpr");26            }27            if (auto_mod.contains(declarator.type)) {28                return diagnostic.fail(parser, error.ExpectedType, "typedef cannot infer auto");29            }30            try typedef.register(parser, name, declarator.type);31        } else if (declarator.type.kind == .function) {32            if (auto_mod.contains(declarator.type)) {33                return diagnostic.fail(parser, error.ExpectedType, "function declarations cannot infer auto");34            }35            if (specifiers.alignment != null) {36                return diagnostic.fail(parser, error.UnsupportedConstruct, "alignas on function declarations is not supported");37            }38            if (specifiers.is_constexpr) {39                return diagnostic.fail(parser, error.UnsupportedConstruct, "function declarations cannot be constexpr");40            }41            try thread.validateFunction(parser, specifiers.is_thread_local);42            try object.register(parser, name, declarator.type);43            if (first and cursor.peek(parser).kind == .lbrace) {44                try object.push(parser);45                defer object.pop(parser);46                for (declarator.type.params) |param| {47                    if (param.name.len != 0) try object.register(parser, param.name, param.type);48                }49                const body = try statement.parseCompound(parser);50                try declarations.append(parser.arena, .{ .function = .{51                    .name = name,52                    .type = declarator.type,53                    .storage = specifiers.storage,54                    .body = body,55                } });56                return declarations.toOwnedSlice(parser.arena);57            }58            try declarations.append(parser.arena, .{ .function = .{59                .name = name,60                .type = declarator.type,61                .storage = specifiers.storage,62                .body = null,63            } });64        } else {65            var initializer: ?*ast.Expr = null;66            if (cursor.consume(parser, .assign)) {67                initializer = try initializer_mod.parse(parser, declarator.type);68            }69            const completed_type = try initializer_mod.completeType(parser, declarator.type, initializer);70            const variable_type = try auto_mod.resolve(parser, completed_type, initializer);71            const constant_value = if (specifiers.is_constexpr)72                try constexpr.validateObject(parser, variable_type, initializer)73            else74                null;75            try thread.validateObject(parser, .file, specifiers.storage, variable_type, initializer, specifiers.is_thread_local);76            try declarations.append(parser.arena, .{ .variable = .{77                .name = name,78                .type = variable_type,79                .storage = specifiers.storage,80                .alignment = specifiers.alignment,81                .is_constexpr = specifiers.is_constexpr,82                .is_thread_local = specifiers.is_thread_local,83                .initializer = initializer,84            } });85            if (specifiers.is_constexpr) {86                try constexpr.registerObject(parser, name, variable_type, constant_value);87            } else {88                try object.register(parser, name, variable_type);89            }90        }9192        first = false;93        if (cursor.consume(parser, .comma)) continue;94        _ = try cursor.expect(parser, .semicolon);95        break;96    }97    return declarations.toOwnedSlice(parser.arena);98}

1pub fn parseStatement(parser: *Parser) Error!*ast.Stmt {2    if (isLabel(parser)) return parseLabel(parser);3    switch (cursor.peek(parser).kind) {4        .lbrace => return parseCompound(parser),5        .semicolon => {6            _ = cursor.advance(parser);7            return memory.create(parser, ast.Stmt, .empty);8        },9        .kw_if => return parseIf(parser),10        .kw_for => return parseFor(parser),11        .kw_while => return parseWhile(parser),12        .kw_do => return parseDo(parser),13        .kw_return => {14            _ = cursor.advance(parser);15            var value: ?*ast.Expr = null;16            if (cursor.peek(parser).kind != .semicolon) {17                value = try expression.parseExpression(parser);18            }19            _ = try cursor.expect(parser, .semicolon);20            return memory.create(parser, ast.Stmt, .{ .return_stmt = value });21        },22        .kw_break => {23            _ = cursor.advance(parser);24            _ = try cursor.expect(parser, .semicolon);25            return memory.create(parser, ast.Stmt, .break_stmt);26        },27        .kw_continue => {28            _ = cursor.advance(parser);29            _ = try cursor.expect(parser, .semicolon);30            return memory.create(parser, ast.Stmt, .continue_stmt);31        },32        else => {33            const value = try expression.parseExpression(parser);34            _ = try cursor.expect(parser, .semicolon);35            return memory.create(parser, ast.Stmt, .{ .expression = value });36        },37    }38}

1pub fn parseTranslationUnit(self: *Parser) Error!ast.TranslationUnit {2    var declarations = std.ArrayListUnmanaged(ast.Decl).empty;3    while (cursor.peek(self).kind != .eof) {4        if (cursor.consume(self, .semicolon)) continue;5        if (try ctype.consumeAttributeDeclaration(self)) continue;6        try ctype.skipAttributes(self);7        if (cursor.consume(self, .semicolon)) continue;8        if (try assertion.consume(self)) continue;9        const parsed = try external.parseExternal(self);10        try declarations.appendSlice(self.arena, parsed);11    }12    return .{ .declarations = try declarations.toOwnedSlice(self.arena) };13}

1const std = @import("std");2const chant = @import("../root.zig");3const ast = @import("../ast/root.zig");4const statement = @import("statement.zig");5const external = @import("external.zig");6const translation = @import("unit.zig");78pub const Error = @import("error.zig").Error;9pub const assertion = @import("assert.zig");10pub const auto = @import("auto.zig");11pub const expression = @import("expression.zig");12pub const initializer = @import("initializer.zig");13pub const thread = @import("thread.zig");14const Token = chant.token.Token;1516pub const state = @import("state/root.zig");17pub const Diagnostic = state.Diagnostic;18pub const Parser = state.Parser;19pub const Storage = state.Storage;20pub const Limits = state.Limits;21pub const Capacity = state.Capacity;22pub const CapacityError = state.CapacityError;23pub const Survey = state.Survey;24pub const Exhaustion = state.Exhaustion;25pub const TypeOrigin = state.TypeOrigin;26pub const TypePlacement = state.TypePlacement;27pub const survey = state.survey;28pub const init = state.init;2930/// Parses `tokens` into a translation unit whose expression, statement and type31/// nodes sit in `nodes` and refer to one another by pointer, so lowering32/// (translating each parsed C function into Choir operations) can consume the33/// result. The call first admits `node_survey` (the record a counting pass34/// produced over the tokens) into `nodes`, which clears the node counts. The35/// call returns `error.SurveyTokensMismatch` when the survey was taken over a36/// different token slice or `error.NodeCapacityExceeded` when it asks for more37/// than the storage holds. The tree borrows `nodes`, parser node storage (a38/// byte buffer the caller allocates). The caller keeps that storage alive, and39/// parses nothing else into it, until it is done with the tree, and the40/// compiler driver finishes lowering before it releases the storage. The name41/// tables, scopes and lists the parser builds along the way come from `arena`.42pub fn parse(43    arena: std.mem.Allocator,44    nodes: *Storage,45    node_survey: Survey,46    tokens: []const Token,47) (Error || Exhaustion)!ast.TranslationUnit {48    var parser = try init(arena, nodes, node_survey, tokens);49    return translation.parseTranslationUnit(&parser);50}5152pub const parseExternal = external.parseExternal;53pub const parseTranslationUnit = translation.parseTranslationUnit;54pub const parseStatement = statement.parseStatement;55pub const parseExpression = expression.parseExpression;

1pub const parse = @import("parse/root.zig");