From e7c3aa7f7cfd74b9f5cc6a3c367757d4f7004e4f Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 6 Sep 2017 01:00:42 -0400 Subject: [PATCH] parsec: turn panics into warnings --- src/parsec.cpp | 1182 ++++++++++++++++++++++++++++++++---------------- 1 file changed, 794 insertions(+), 388 deletions(-) diff --git a/src/parsec.cpp b/src/parsec.cpp index fd39c8fc79..742db4e610 100644 --- a/src/parsec.cpp +++ b/src/parsec.cpp @@ -54,8 +54,6 @@ struct Context { static AstNode *resolve_record_decl(Context *c, const RecordDecl *record_decl); static AstNode *resolve_enum_decl(Context *c, const EnumDecl *enum_decl); static AstNode *resolve_typedef_decl(Context *c, const TypedefNameDecl *typedef_decl); -static AstNode *trans_qual_type_with_table(Context *c, QualType qt, const SourceLocation &source_loc); -static AstNode *trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc); __attribute__ ((format (printf, 3, 4))) @@ -362,14 +360,15 @@ static bool c_is_float(Context *c, QualType qt) { } } -static AstNode * trans_stmt(Context *c, AstNode *block, Stmt *stmt); -static AstNode * trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc); +static AstNode *trans_stmt(Context *c, AstNode *block, Stmt *stmt); +static AstNode *trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc); +static AstNode *const skip_add_to_block_node = (AstNode *) 0x2; -static AstNode * trans_expr(Context *c, AstNode *block, Expr *expr) { +static AstNode *trans_expr(Context *c, AstNode *block, Expr *expr) { return trans_stmt(c, block, expr); } -static AstNode *trans_type_with_table(Context *c, const Type *ty, const SourceLocation &source_loc) { +static AstNode *trans_type(Context *c, const Type *ty, const SourceLocation &source_loc) { switch (ty->getTypeClass()) { case Type::Builtin: { @@ -506,9 +505,9 @@ static AstNode *trans_type_with_table(Context *c, const Type *ty, const SourceLo const ElaboratedType *elaborated_ty = static_cast(ty); switch (elaborated_ty->getKeyword()) { case ETK_Struct: - return trans_qual_type_with_table(c, elaborated_ty->getNamedType(), source_loc); + return trans_qual_type(c, elaborated_ty->getNamedType(), source_loc); case ETK_Enum: - return trans_qual_type_with_table(c, elaborated_ty->getNamedType(), source_loc); + return trans_qual_type(c, elaborated_ty->getNamedType(), source_loc); case ETK_Interface: case ETK_Union: case ETK_Class: @@ -703,19 +702,17 @@ static AstNode *trans_type_with_table(Context *c, const Type *ty, const SourceLo zig_unreachable(); } -static AstNode * trans_qual_type_with_table(Context *c, QualType qt, const SourceLocation &source_loc) { - return trans_type_with_table(c, qt.getTypePtr(), source_loc); +static AstNode *trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc) { + return trans_type(c, qt.getTypePtr(), source_loc); } -static AstNode * trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc) { - return trans_qual_type_with_table(c, qt, source_loc); -} - -static AstNode * trans_compound_stmt(Context *c, AstNode *parent, CompoundStmt *stmt) { +static AstNode *trans_compound_stmt(Context *c, AstNode *parent, CompoundStmt *stmt) { AstNode *child_block = trans_create_node(c, NodeTypeBlock); for (CompoundStmt::body_iterator it = stmt->body_begin(), end_it = stmt->body_end(); it != end_it; ++it) { AstNode *child_node = trans_stmt(c, child_block, *it); - if (child_node != nullptr) + if (child_node == nullptr) + return nullptr; + if (child_node != skip_add_to_block_node) child_block->data.block.statements.append(child_node); } return child_block; @@ -724,10 +721,13 @@ static AstNode * trans_compound_stmt(Context *c, AstNode *parent, CompoundStmt * static AstNode *trans_return_stmt(Context *c, AstNode *block, ReturnStmt *stmt) { Expr *value_expr = stmt->getRetValue(); if (value_expr == nullptr) { - zig_panic("TODO handle C return void"); + emit_warning(c, stmt->getLocStart(), "TODO handle C return void"); + return nullptr; } else { AstNode *return_node = trans_create_node(c, NodeTypeReturnExpr); return_node->data.return_expr.expr = trans_expr(c, block, value_expr); + if (return_node->data.return_expr.expr == nullptr) + return nullptr; return return_node; } } @@ -735,7 +735,8 @@ static AstNode *trans_return_stmt(Context *c, AstNode *block, ReturnStmt *stmt) static AstNode *trans_integer_literal(Context *c, IntegerLiteral *stmt) { llvm::APSInt result; if (!stmt->EvaluateAsInt(result, *c->ctx)) { - zig_panic("TODO handle libclang unable to evaluate C integer literal"); + emit_warning(c, stmt->getLocStart(), "invalid integer literal"); + return nullptr; } return trans_create_node_apint(c, result); } @@ -748,40 +749,64 @@ static AstNode *trans_conditional_operator(Context *c, AstNode *block, Condition Expr *false_expr = stmt->getFalseExpr(); node->data.if_bool_expr.condition = trans_expr(c, block, cond_expr); + if (node->data.if_bool_expr.condition == nullptr) + return nullptr; + node->data.if_bool_expr.then_block = trans_expr(c, block, true_expr); + if (node->data.if_bool_expr.then_block == nullptr) + return nullptr; + node->data.if_bool_expr.else_node = trans_expr(c, block, false_expr); + if (node->data.if_bool_expr.else_node == nullptr) + return nullptr; return node; } -static AstNode * trans_create_bin_op(Context *c, AstNode *block, Expr *lhs, BinOpType bin_op, Expr *rhs) { +static AstNode *trans_create_bin_op(Context *c, AstNode *block, Expr *lhs, BinOpType bin_op, Expr *rhs) { AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.bin_op = bin_op; + node->data.bin_op_expr.op1 = trans_expr(c, block, lhs); + if (node->data.bin_op_expr.op1 == nullptr) + return nullptr; + node->data.bin_op_expr.op2 = trans_expr(c, block, rhs); + if (node->data.bin_op_expr.op2 == nullptr) + return nullptr; + return node; } -static AstNode * trans_binary_operator(Context *c, AstNode *block, BinaryOperator *stmt) { +static AstNode *trans_binary_operator(Context *c, AstNode *block, BinaryOperator *stmt) { switch (stmt->getOpcode()) { case BO_PtrMemD: - zig_panic("TODO handle more C binary operators: BO_PtrMemD"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_PtrMemD"); + return nullptr; case BO_PtrMemI: - zig_panic("TODO handle more C binary operators: BO_PtrMemI"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_PtrMemI"); + return nullptr; case BO_Mul: - zig_panic("TODO handle more C binary operators: BO_Mul"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Mul"); + return nullptr; case BO_Div: - zig_panic("TODO handle more C binary operators: BO_Div"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Div"); + return nullptr; case BO_Rem: - zig_panic("TODO handle more C binary operators: BO_Rem"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Rem"); + return nullptr; case BO_Add: - zig_panic("TODO handle more C binary operators: BO_Add"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Add"); + return nullptr; case BO_Sub: - zig_panic("TODO handle more C binary operators: BO_Sub"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Sub"); + return nullptr; case BO_Shl: - zig_panic("TODO handle more C binary operators: BO_Shl"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Shl"); + return nullptr; case BO_Shr: - zig_panic("TODO handle more C binary operators: BO_Shr"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Shr"); + return nullptr; case BO_LT: return trans_create_bin_op(c, block, stmt->getLHS(), BinOpTypeCmpLessThan, stmt->getRHS()); case BO_GT: @@ -791,405 +816,596 @@ static AstNode * trans_binary_operator(Context *c, AstNode *block, BinaryOperato case BO_GE: return trans_create_bin_op(c, block, stmt->getLHS(), BinOpTypeCmpGreaterOrEq, stmt->getRHS()); case BO_EQ: - zig_panic("TODO handle more C binary operators: BO_EQ"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_EQ"); + return nullptr; case BO_NE: - zig_panic("TODO handle more C binary operators: BO_NE"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_NE"); + return nullptr; case BO_And: - zig_panic("TODO handle more C binary operators: BO_And"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_And"); + return nullptr; case BO_Xor: - zig_panic("TODO handle more C binary operators: BO_Xor"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Xor"); + return nullptr; case BO_Or: - zig_panic("TODO handle more C binary operators: BO_Or"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Or"); + return nullptr; case BO_LAnd: - zig_panic("TODO handle more C binary operators: BO_LAnd"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_LAnd"); + return nullptr; case BO_LOr: - zig_panic("TODO handle more C binary operators: BO_LOr"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_LOr"); + return nullptr; case BO_Assign: - zig_panic("TODO handle more C binary operators: BO_Assign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Assign"); + return nullptr; case BO_MulAssign: - zig_panic("TODO handle more C binary operators: BO_MulAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_MulAssign"); + return nullptr; case BO_DivAssign: - zig_panic("TODO handle more C binary operators: BO_DivAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_DivAssign"); + return nullptr; case BO_RemAssign: - zig_panic("TODO handle more C binary operators: BO_RemAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_RemAssign"); + return nullptr; case BO_AddAssign: - zig_panic("TODO handle more C binary operators: BO_AddAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_AddAssign"); + return nullptr; case BO_SubAssign: - zig_panic("TODO handle more C binary operators: BO_SubAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_SubAssign"); + return nullptr; case BO_ShlAssign: - zig_panic("TODO handle more C binary operators: BO_ShlAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_ShlAssign"); + return nullptr; case BO_ShrAssign: - zig_panic("TODO handle more C binary operators: BO_ShrAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_ShrAssign"); + return nullptr; case BO_AndAssign: - zig_panic("TODO handle more C binary operators: BO_AndAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_AndAssign"); + return nullptr; case BO_XorAssign: - zig_panic("TODO handle more C binary operators: BO_XorAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_XorAssign"); + return nullptr; case BO_OrAssign: - zig_panic("TODO handle more C binary operators: BO_OrAssign"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_OrAssign"); + return nullptr; case BO_Comma: - zig_panic("TODO handle more C binary operators: BO_Comma"); + emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Comma"); + return nullptr; } zig_unreachable(); } -static AstNode * trans_implicit_cast_expr(Context *c, AstNode *block, ImplicitCastExpr *stmt) { +static AstNode *trans_implicit_cast_expr(Context *c, AstNode *block, ImplicitCastExpr *stmt) { switch (stmt->getCastKind()) { case CK_LValueToRValue: return trans_expr(c, block, stmt->getSubExpr()); case CK_IntegralCast: { AstNode *node = trans_create_node_builtin_fn_call_str(c, "bitCast"); - node->data.fn_call_expr.params.append(trans_qual_type(c, stmt->getType(), stmt->getExprLoc())); - node->data.fn_call_expr.params.append(trans_expr(c, block, stmt->getSubExpr())); + + AstNode *result_type_node = trans_qual_type(c, stmt->getType(), stmt->getExprLoc()); + if (result_type_node == nullptr) + return nullptr; + + AstNode *target_node = trans_expr(c, block, stmt->getSubExpr()); + if (target_node == nullptr) + return nullptr; + + node->data.fn_call_expr.params.append(result_type_node); + node->data.fn_call_expr.params.append(target_node); return node; } case CK_Dependent: - zig_panic("TODO handle C translation cast CK_Dependent"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_Dependent"); + return nullptr; case CK_BitCast: - zig_panic("TODO handle C translation cast CK_BitCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BitCast"); + return nullptr; case CK_LValueBitCast: - zig_panic("TODO handle C translation cast CK_LValueBitCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_LValueBitCast"); + return nullptr; case CK_NoOp: - zig_panic("TODO handle C translation cast CK_NoOp"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_NoOp"); + return nullptr; case CK_BaseToDerived: - zig_panic("TODO handle C translation cast CK_BaseToDerived"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BaseToDerived"); + return nullptr; case CK_DerivedToBase: - zig_panic("TODO handle C translation cast CK_DerivedToBase"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_DerivedToBase"); + return nullptr; case CK_UncheckedDerivedToBase: - zig_panic("TODO handle C translation cast CK_UncheckedDerivedToBase"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_UncheckedDerivedToBase"); + return nullptr; case CK_Dynamic: - zig_panic("TODO handle C translation cast CK_Dynamic"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_Dynamic"); + return nullptr; case CK_ToUnion: - zig_panic("TODO handle C translation cast CK_ToUnion"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ToUnion"); + return nullptr; case CK_ArrayToPointerDecay: - zig_panic("TODO handle C translation cast CK_ArrayToPointerDecay"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ArrayToPointerDecay"); + return nullptr; case CK_FunctionToPointerDecay: - zig_panic("TODO handle C translation cast CK_FunctionToPointerDecay"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FunctionToPointerDecay"); + return nullptr; case CK_NullToPointer: - zig_panic("TODO handle C translation cast CK_NullToPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_NullToPointer"); + return nullptr; case CK_NullToMemberPointer: - zig_panic("TODO handle C translation cast CK_NullToMemberPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_NullToMemberPointer"); + return nullptr; case CK_BaseToDerivedMemberPointer: - zig_panic("TODO handle C translation cast CK_BaseToDerivedMemberPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BaseToDerivedMemberPointer"); + return nullptr; case CK_DerivedToBaseMemberPointer: - zig_panic("TODO handle C translation cast CK_DerivedToBaseMemberPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_DerivedToBaseMemberPointer"); + return nullptr; case CK_MemberPointerToBoolean: - zig_panic("TODO handle C translation cast CK_MemberPointerToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_MemberPointerToBoolean"); + return nullptr; case CK_ReinterpretMemberPointer: - zig_panic("TODO handle C translation cast CK_ReinterpretMemberPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ReinterpretMemberPointer"); + return nullptr; case CK_UserDefinedConversion: - zig_panic("TODO handle C translation cast CK_UserDefinedConversion"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_UserDefinedConversion"); + return nullptr; case CK_ConstructorConversion: - zig_panic("TODO handle C translation cast CK_ConstructorConversion"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ConstructorConversion"); + return nullptr; case CK_IntegralToPointer: - zig_panic("TODO handle C translation cast CK_IntegralToPointer"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralToPointer"); + return nullptr; case CK_PointerToIntegral: - zig_panic("TODO handle C translation cast CK_PointerToIntegral"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_PointerToIntegral"); + return nullptr; case CK_PointerToBoolean: - zig_panic("TODO handle C translation cast CK_PointerToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_PointerToBoolean"); + return nullptr; case CK_ToVoid: - zig_panic("TODO handle C translation cast CK_ToVoid"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ToVoid"); + return nullptr; case CK_VectorSplat: - zig_panic("TODO handle C translation cast CK_VectorSplat"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_VectorSplat"); + return nullptr; case CK_IntegralToBoolean: - zig_panic("TODO handle C translation cast CK_IntegralToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralToBoolean"); + return nullptr; case CK_IntegralToFloating: - zig_panic("TODO handle C translation cast CK_IntegralToFloating"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralToFloating"); + return nullptr; case CK_FloatingToIntegral: - zig_panic("TODO handle C translation cast CK_FloatingToIntegral"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingToIntegral"); + return nullptr; case CK_FloatingToBoolean: - zig_panic("TODO handle C translation cast CK_FloatingToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingToBoolean"); + return nullptr; case CK_BooleanToSignedIntegral: - zig_panic("TODO handle C translation cast CK_BooleanToSignedIntegral"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BooleanToSignedIntegral"); + return nullptr; case CK_FloatingCast: - zig_panic("TODO handle C translation cast CK_FloatingCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingCast"); + return nullptr; case CK_CPointerToObjCPointerCast: - zig_panic("TODO handle C translation cast CK_CPointerToObjCPointerCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_CPointerToObjCPointerCast"); + return nullptr; case CK_BlockPointerToObjCPointerCast: - zig_panic("TODO handle C translation cast CK_BlockPointerToObjCPointerCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BlockPointerToObjCPointerCast"); + return nullptr; case CK_AnyPointerToBlockPointerCast: - zig_panic("TODO handle C translation cast CK_AnyPointerToBlockPointerCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_AnyPointerToBlockPointerCast"); + return nullptr; case CK_ObjCObjectLValueCast: - zig_panic("TODO handle C translation cast CK_ObjCObjectLValueCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ObjCObjectLValueCast"); + return nullptr; case CK_FloatingRealToComplex: - zig_panic("TODO handle C translation cast CK_FloatingRealToComplex"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingRealToComplex"); + return nullptr; case CK_FloatingComplexToReal: - zig_panic("TODO handle C translation cast CK_FloatingComplexToReal"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingComplexToReal"); + return nullptr; case CK_FloatingComplexToBoolean: - zig_panic("TODO handle C translation cast CK_FloatingComplexToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingComplexToBoolean"); + return nullptr; case CK_FloatingComplexCast: - zig_panic("TODO handle C translation cast CK_FloatingComplexCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingComplexCast"); + return nullptr; case CK_FloatingComplexToIntegralComplex: - zig_panic("TODO handle C translation cast CK_FloatingComplexToIntegralComplex"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_FloatingComplexToIntegralComplex"); + return nullptr; case CK_IntegralRealToComplex: - zig_panic("TODO handle C translation cast CK_IntegralRealToComplex"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralRealToComplex"); + return nullptr; case CK_IntegralComplexToReal: - zig_panic("TODO handle C translation cast CK_IntegralComplexToReal"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralComplexToReal"); + return nullptr; case CK_IntegralComplexToBoolean: - zig_panic("TODO handle C translation cast CK_IntegralComplexToBoolean"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralComplexToBoolean"); + return nullptr; case CK_IntegralComplexCast: - zig_panic("TODO handle C translation cast CK_IntegralComplexCast"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralComplexCast"); + return nullptr; case CK_IntegralComplexToFloatingComplex: - zig_panic("TODO handle C translation cast CK_IntegralComplexToFloatingComplex"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntegralComplexToFloatingComplex"); + return nullptr; case CK_ARCProduceObject: - zig_panic("TODO handle C translation cast CK_ARCProduceObject"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ARCProduceObject"); + return nullptr; case CK_ARCConsumeObject: - zig_panic("TODO handle C translation cast CK_ARCConsumeObject"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ARCConsumeObject"); + return nullptr; case CK_ARCReclaimReturnedObject: - zig_panic("TODO handle C translation cast CK_ARCReclaimReturnedObject"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ARCReclaimReturnedObject"); + return nullptr; case CK_ARCExtendBlockObject: - zig_panic("TODO handle C translation cast CK_ARCExtendBlockObject"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ARCExtendBlockObject"); + return nullptr; case CK_AtomicToNonAtomic: - zig_panic("TODO handle C translation cast CK_AtomicToNonAtomic"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_AtomicToNonAtomic"); + return nullptr; case CK_NonAtomicToAtomic: - zig_panic("TODO handle C translation cast CK_NonAtomicToAtomic"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_NonAtomicToAtomic"); + return nullptr; case CK_CopyAndAutoreleaseBlockObject: - zig_panic("TODO handle C translation cast CK_CopyAndAutoreleaseBlockObject"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_CopyAndAutoreleaseBlockObject"); + return nullptr; case CK_BuiltinFnToFnPtr: - zig_panic("TODO handle C translation cast CK_BuiltinFnToFnPtr"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_BuiltinFnToFnPtr"); + return nullptr; case CK_ZeroToOCLEvent: - zig_panic("TODO handle C translation cast CK_ZeroToOCLEvent"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ZeroToOCLEvent"); + return nullptr; case CK_ZeroToOCLQueue: - zig_panic("TODO handle C translation cast CK_ZeroToOCLQueue"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_ZeroToOCLQueue"); + return nullptr; case CK_AddressSpaceConversion: - zig_panic("TODO handle C translation cast CK_AddressSpaceConversion"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_AddressSpaceConversion"); + return nullptr; case CK_IntToOCLSampler: - zig_panic("TODO handle C translation cast CK_IntToOCLSampler"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_IntToOCLSampler"); + return nullptr; } zig_unreachable(); } -static AstNode * trans_decl_ref_expr(Context *c, DeclRefExpr *stmt) { +static AstNode *trans_decl_ref_expr(Context *c, DeclRefExpr *stmt) { ValueDecl *value_decl = stmt->getDecl(); const char *name = decl_name(value_decl); - - AstNode *node = trans_create_node(c, NodeTypeSymbol); - node->data.symbol_expr.symbol = buf_create_from_str(name); - return node; + return trans_create_node_symbol_str(c, name); } -static AstNode * trans_unary_operator(Context *c, AstNode *block, UnaryOperator *stmt) { +static AstNode *trans_unary_operator(Context *c, AstNode *block, UnaryOperator *stmt) { switch (stmt->getOpcode()) { case UO_PostInc: - zig_panic("TODO handle C translation UO_PostInc"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_PostInc"); + return nullptr; case UO_PostDec: - zig_panic("TODO handle C translation UO_PostDec"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_PostDec"); + return nullptr; case UO_PreInc: - zig_panic("TODO handle C translation UO_PreInc"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_PreInc"); + return nullptr; case UO_PreDec: - zig_panic("TODO handle C translation UO_PreDec"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_PreDec"); + return nullptr; case UO_AddrOf: - zig_panic("TODO handle C translation UO_AddrOf"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_AddrOf"); + return nullptr; case UO_Deref: - zig_panic("TODO handle C translation UO_Deref"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Deref"); + return nullptr; case UO_Plus: - zig_panic("TODO handle C translation UO_Plus"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Plus"); + return nullptr; case UO_Minus: { Expr *op_expr = stmt->getSubExpr(); if (c_is_signed_integer(c, op_expr->getType()) || c_is_float(c, op_expr->getType())) { AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr); node->data.prefix_op_expr.prefix_op = PrefixOpNegation; + node->data.prefix_op_expr.primary_expr = trans_expr(c, block, op_expr); + if (node->data.prefix_op_expr.primary_expr == nullptr) + return nullptr; + return node; } else if (c_is_unsigned_integer(c, op_expr->getType())) { // we gotta emit 0 -% x AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.op1 = trans_create_node_unsigned(c, 0); + node->data.bin_op_expr.op2 = trans_expr(c, block, op_expr); + if (node->data.bin_op_expr.op2 == nullptr) + return nullptr; + node->data.bin_op_expr.bin_op = BinOpTypeSubWrap; return node; } else { - zig_panic("TODO translate C negation with non float non integer"); + emit_warning(c, stmt->getLocStart(), "C negation with non float non integer"); + return nullptr; } } case UO_Not: - zig_panic("TODO handle C translation UO_Not"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Not"); + return nullptr; case UO_LNot: - zig_panic("TODO handle C translation UO_LNot"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_LNot"); + return nullptr; case UO_Real: - zig_panic("TODO handle C translation UO_Real"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Real"); + return nullptr; case UO_Imag: - zig_panic("TODO handle C translation UO_Imag"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Imag"); + return nullptr; case UO_Extension: - zig_panic("TODO handle C translation UO_Extension"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Extension"); + return nullptr; case UO_Coawait: - zig_panic("TODO handle C translation UO_Coawait"); + emit_warning(c, stmt->getLocStart(), "TODO handle C translation UO_Coawait"); + return nullptr; } zig_unreachable(); } -static AstNode * trans_local_declaration(Context *c, AstNode *block, DeclStmt *stmt) { +static AstNode *trans_local_declaration(Context *c, AstNode *block, DeclStmt *stmt) { for (auto iter = stmt->decl_begin(); iter != stmt->decl_end(); iter++) { Decl *decl = *iter; switch (decl->getKind()) { case Decl::Var: { VarDecl *var_decl = (VarDecl *)decl; QualType qual_type = var_decl->getTypeSourceInfo()->getType(); - AstNode *init_node = var_decl->hasInit() ? trans_expr(c, block, var_decl->getInit()) : nullptr; - AstNode *type_node = trans_qual_type(c, qual_type, stmt->getStartLoc()); + AstNode *init_node = nullptr; + if (var_decl->hasInit()) { + init_node = trans_expr(c, block, var_decl->getInit()); + if (init_node == nullptr) + return nullptr; + + } + AstNode *type_node = trans_qual_type(c, qual_type, stmt->getLocStart()); + if (type_node == nullptr) + return nullptr; + AstNode *node = trans_create_node_var_decl(c, qual_type.isConstQualified(), buf_create_from_str(decl_name(var_decl)), type_node, init_node); block->data.block.statements.append(node); continue; } case Decl::AccessSpec: - zig_panic("TODO handle decl kind AccessSpec"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind AccessSpec"); + return nullptr; case Decl::Block: - zig_panic("TODO handle decl kind Block"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Block"); + return nullptr; case Decl::Captured: - zig_panic("TODO handle decl kind Captured"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Captured"); + return nullptr; case Decl::ClassScopeFunctionSpecialization: - zig_panic("TODO handle decl kind ClassScopeFunctionSpecialization"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ClassScopeFunctionSpecialization"); + return nullptr; case Decl::Empty: - zig_panic("TODO handle decl kind Empty"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Empty"); + return nullptr; case Decl::Export: - zig_panic("TODO handle decl kind Export"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Export"); + return nullptr; case Decl::ExternCContext: - zig_panic("TODO handle decl kind ExternCContext"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ExternCContext"); + return nullptr; case Decl::FileScopeAsm: - zig_panic("TODO handle decl kind FileScopeAsm"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind FileScopeAsm"); + return nullptr; case Decl::Friend: - zig_panic("TODO handle decl kind Friend"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Friend"); + return nullptr; case Decl::FriendTemplate: - zig_panic("TODO handle decl kind FriendTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind FriendTemplate"); + return nullptr; case Decl::Import: - zig_panic("TODO handle decl kind Import"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Import"); + return nullptr; case Decl::LinkageSpec: - zig_panic("TODO handle decl kind LinkageSpec"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind LinkageSpec"); + return nullptr; case Decl::Label: - zig_panic("TODO handle decl kind Label"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Label"); + return nullptr; case Decl::Namespace: - zig_panic("TODO handle decl kind Namespace"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Namespace"); + return nullptr; case Decl::NamespaceAlias: - zig_panic("TODO handle decl kind NamespaceAlias"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind NamespaceAlias"); + return nullptr; case Decl::ObjCCompatibleAlias: - zig_panic("TODO handle decl kind ObjCCompatibleAlias"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCCompatibleAlias"); + return nullptr; case Decl::ObjCCategory: - zig_panic("TODO handle decl kind ObjCCategory"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCCategory"); + return nullptr; case Decl::ObjCCategoryImpl: - zig_panic("TODO handle decl kind ObjCCategoryImpl"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCCategoryImpl"); + return nullptr; case Decl::ObjCImplementation: - zig_panic("TODO handle decl kind ObjCImplementation"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCImplementation"); + return nullptr; case Decl::ObjCInterface: - zig_panic("TODO handle decl kind ObjCInterface"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCInterface"); + return nullptr; case Decl::ObjCProtocol: - zig_panic("TODO handle decl kind ObjCProtocol"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCProtocol"); + return nullptr; case Decl::ObjCMethod: - zig_panic("TODO handle decl kind ObjCMethod"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCMethod"); + return nullptr; case Decl::ObjCProperty: - zig_panic("TODO handle decl kind ObjCProperty"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCProperty"); + return nullptr; case Decl::BuiltinTemplate: - zig_panic("TODO handle decl kind BuiltinTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind BuiltinTemplate"); + return nullptr; case Decl::ClassTemplate: - zig_panic("TODO handle decl kind ClassTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ClassTemplate"); + return nullptr; case Decl::FunctionTemplate: - zig_panic("TODO handle decl kind FunctionTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind FunctionTemplate"); + return nullptr; case Decl::TypeAliasTemplate: - zig_panic("TODO handle decl kind TypeAliasTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind TypeAliasTemplate"); + return nullptr; case Decl::VarTemplate: - zig_panic("TODO handle decl kind VarTemplate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind VarTemplate"); + return nullptr; case Decl::TemplateTemplateParm: - zig_panic("TODO handle decl kind TemplateTemplateParm"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind TemplateTemplateParm"); + return nullptr; case Decl::Enum: - zig_panic("TODO handle decl kind Enum"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Enum"); + return nullptr; case Decl::Record: - zig_panic("TODO handle decl kind Record"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Record"); + return nullptr; case Decl::CXXRecord: - zig_panic("TODO handle decl kind CXXRecord"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXRecord"); + return nullptr; case Decl::ClassTemplateSpecialization: - zig_panic("TODO handle decl kind ClassTemplateSpecialization"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ClassTemplateSpecialization"); + return nullptr; case Decl::ClassTemplatePartialSpecialization: - zig_panic("TODO handle decl kind ClassTemplatePartialSpecialization"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ClassTemplatePartialSpecialization"); + return nullptr; case Decl::TemplateTypeParm: - zig_panic("TODO handle decl kind TemplateTypeParm"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind TemplateTypeParm"); + return nullptr; case Decl::ObjCTypeParam: - zig_panic("TODO handle decl kind ObjCTypeParam"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCTypeParam"); + return nullptr; case Decl::TypeAlias: - zig_panic("TODO handle decl kind TypeAlias"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind TypeAlias"); + return nullptr; case Decl::Typedef: - zig_panic("TODO handle decl kind Typedef"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Typedef"); + return nullptr; case Decl::UnresolvedUsingTypename: - zig_panic("TODO handle decl kind UnresolvedUsingTypename"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind UnresolvedUsingTypename"); + return nullptr; case Decl::Using: - zig_panic("TODO handle decl kind Using"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Using"); + return nullptr; case Decl::UsingDirective: - zig_panic("TODO handle decl kind UsingDirective"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind UsingDirective"); + return nullptr; case Decl::UsingPack: - zig_panic("TODO handle decl kind UsingPack"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind UsingPack"); + return nullptr; case Decl::UsingShadow: - zig_panic("TODO handle decl kind UsingShadow"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind UsingShadow"); + return nullptr; case Decl::ConstructorUsingShadow: - zig_panic("TODO handle decl kind ConstructorUsingShadow"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ConstructorUsingShadow"); + return nullptr; case Decl::Binding: - zig_panic("TODO handle decl kind Binding"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Binding"); + return nullptr; case Decl::Field: - zig_panic("TODO handle decl kind Field"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Field"); + return nullptr; case Decl::ObjCAtDefsField: - zig_panic("TODO handle decl kind ObjCAtDefsField"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCAtDefsField"); + return nullptr; case Decl::ObjCIvar: - zig_panic("TODO handle decl kind ObjCIvar"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCIvar"); + return nullptr; case Decl::Function: - zig_panic("TODO handle decl kind Function"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Function"); + return nullptr; case Decl::CXXDeductionGuide: - zig_panic("TODO handle decl kind CXXDeductionGuide"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXDeductionGuide"); + return nullptr; case Decl::CXXMethod: - zig_panic("TODO handle decl kind CXXMethod"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXMethod"); + return nullptr; case Decl::CXXConstructor: - zig_panic("TODO handle decl kind CXXConstructor"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXConstructor"); + return nullptr; case Decl::CXXConversion: - zig_panic("TODO handle decl kind CXXConversion"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXConversion"); + return nullptr; case Decl::CXXDestructor: - zig_panic("TODO handle decl kind CXXDestructor"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind CXXDestructor"); + return nullptr; case Decl::MSProperty: - zig_panic("TODO handle decl kind MSProperty"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind MSProperty"); + return nullptr; case Decl::NonTypeTemplateParm: - zig_panic("TODO handle decl kind NonTypeTemplateParm"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind NonTypeTemplateParm"); + return nullptr; case Decl::Decomposition: - zig_panic("TODO handle decl kind Decomposition"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind Decomposition"); + return nullptr; case Decl::ImplicitParam: - zig_panic("TODO handle decl kind ImplicitParam"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ImplicitParam"); + return nullptr; case Decl::OMPCapturedExpr: - zig_panic("TODO handle decl kind OMPCapturedExpr"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind OMPCapturedExpr"); + return nullptr; case Decl::ParmVar: - zig_panic("TODO handle decl kind ParmVar"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ParmVar"); + return nullptr; case Decl::VarTemplateSpecialization: - zig_panic("TODO handle decl kind VarTemplateSpecialization"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind VarTemplateSpecialization"); + return nullptr; case Decl::VarTemplatePartialSpecialization: - zig_panic("TODO handle decl kind VarTemplatePartialSpecialization"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind VarTemplatePartialSpecialization"); + return nullptr; case Decl::EnumConstant: - zig_panic("TODO handle decl kind EnumConstant"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind EnumConstant"); + return nullptr; case Decl::IndirectField: - zig_panic("TODO handle decl kind IndirectField"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind IndirectField"); + return nullptr; case Decl::OMPDeclareReduction: - zig_panic("TODO handle decl kind OMPDeclareReduction"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind OMPDeclareReduction"); + return nullptr; case Decl::UnresolvedUsingValue: - zig_panic("TODO handle decl kind UnresolvedUsingValue"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind UnresolvedUsingValue"); + return nullptr; case Decl::OMPThreadPrivate: - zig_panic("TODO handle decl kind OMPThreadPrivate"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind OMPThreadPrivate"); + return nullptr; case Decl::ObjCPropertyImpl: - zig_panic("TODO handle decl kind ObjCPropertyImpl"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind ObjCPropertyImpl"); + return nullptr; case Decl::PragmaComment: - zig_panic("TODO handle decl kind PragmaComment"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind PragmaComment"); + return nullptr; case Decl::PragmaDetectMismatch: - zig_panic("TODO handle decl kind PragmaDetectMismatch"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind PragmaDetectMismatch"); + return nullptr; case Decl::StaticAssert: - zig_panic("TODO handle decl kind StaticAssert"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind StaticAssert"); + return nullptr; case Decl::TranslationUnit: - zig_panic("TODO handle decl kind TranslationUnit"); + emit_warning(c, stmt->getLocStart(), "TODO handle decl kind TranslationUnit"); + return nullptr; } zig_unreachable(); } // declarations were already added - return nullptr; + return skip_add_to_block_node; } static AstNode *trans_while_loop(Context *c, AstNode *block, WhileStmt *stmt) { AstNode *while_node = trans_create_node(c, NodeTypeWhileExpr); + while_node->data.while_expr.condition = trans_expr(c, block, stmt->getCond()); + if (while_node->data.while_expr.condition == nullptr) + return nullptr; + while_node->data.while_expr.body = trans_stmt(c, block, stmt->getBody()); + if (while_node->data.while_expr.body == nullptr) + return nullptr; + return while_node; } @@ -1217,375 +1433,560 @@ static AstNode *trans_stmt(Context *c, AstNode *block, Stmt *stmt) { case Stmt::WhileStmtClass: return trans_while_loop(c, block, (WhileStmt *)stmt); case Stmt::CaseStmtClass: - zig_panic("TODO handle C CaseStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CaseStmtClass"); + return nullptr; case Stmt::DefaultStmtClass: - zig_panic("TODO handle C DefaultStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DefaultStmtClass"); + return nullptr; case Stmt::SwitchStmtClass: - zig_panic("TODO handle C SwitchStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SwitchStmtClass"); + return nullptr; case Stmt::NoStmtClass: - zig_panic("TODO handle C NoStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C NoStmtClass"); + return nullptr; case Stmt::GCCAsmStmtClass: - zig_panic("TODO handle C GCCAsmStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C GCCAsmStmtClass"); + return nullptr; case Stmt::MSAsmStmtClass: - zig_panic("TODO handle C MSAsmStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MSAsmStmtClass"); + return nullptr; case Stmt::AttributedStmtClass: - zig_panic("TODO handle C AttributedStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C AttributedStmtClass"); + return nullptr; case Stmt::BreakStmtClass: - zig_panic("TODO handle C BreakStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C BreakStmtClass"); + return nullptr; case Stmt::CXXCatchStmtClass: - zig_panic("TODO handle C CXXCatchStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXCatchStmtClass"); + return nullptr; case Stmt::CXXForRangeStmtClass: - zig_panic("TODO handle C CXXForRangeStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXForRangeStmtClass"); + return nullptr; case Stmt::CXXTryStmtClass: - zig_panic("TODO handle C CXXTryStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXTryStmtClass"); + return nullptr; case Stmt::CapturedStmtClass: - zig_panic("TODO handle C CapturedStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CapturedStmtClass"); + return nullptr; case Stmt::ContinueStmtClass: - zig_panic("TODO handle C ContinueStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ContinueStmtClass"); + return nullptr; case Stmt::CoreturnStmtClass: - zig_panic("TODO handle C CoreturnStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CoreturnStmtClass"); + return nullptr; case Stmt::CoroutineBodyStmtClass: - zig_panic("TODO handle C CoroutineBodyStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CoroutineBodyStmtClass"); + return nullptr; case Stmt::DoStmtClass: - zig_panic("TODO handle C DoStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DoStmtClass"); + return nullptr; case Stmt::BinaryConditionalOperatorClass: - zig_panic("TODO handle C BinaryConditionalOperatorClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C BinaryConditionalOperatorClass"); + return nullptr; case Stmt::AddrLabelExprClass: - zig_panic("TODO handle C AddrLabelExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C AddrLabelExprClass"); + return nullptr; case Stmt::ArrayInitIndexExprClass: - zig_panic("TODO handle C ArrayInitIndexExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ArrayInitIndexExprClass"); + return nullptr; case Stmt::ArrayInitLoopExprClass: - zig_panic("TODO handle C ArrayInitLoopExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ArrayInitLoopExprClass"); + return nullptr; case Stmt::ArraySubscriptExprClass: - zig_panic("TODO handle C ArraySubscriptExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ArraySubscriptExprClass"); + return nullptr; case Stmt::ArrayTypeTraitExprClass: - zig_panic("TODO handle C ArrayTypeTraitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ArrayTypeTraitExprClass"); + return nullptr; case Stmt::AsTypeExprClass: - zig_panic("TODO handle C AsTypeExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C AsTypeExprClass"); + return nullptr; case Stmt::AtomicExprClass: - zig_panic("TODO handle C AtomicExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C AtomicExprClass"); + return nullptr; case Stmt::CompoundAssignOperatorClass: - zig_panic("TODO handle C CompoundAssignOperatorClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CompoundAssignOperatorClass"); + return nullptr; case Stmt::BlockExprClass: - zig_panic("TODO handle C BlockExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C BlockExprClass"); + return nullptr; case Stmt::CXXBindTemporaryExprClass: - zig_panic("TODO handle C CXXBindTemporaryExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXBindTemporaryExprClass"); + return nullptr; case Stmt::CXXBoolLiteralExprClass: - zig_panic("TODO handle C CXXBoolLiteralExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXBoolLiteralExprClass"); + return nullptr; case Stmt::CXXConstructExprClass: - zig_panic("TODO handle C CXXConstructExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXConstructExprClass"); + return nullptr; case Stmt::CXXTemporaryObjectExprClass: - zig_panic("TODO handle C CXXTemporaryObjectExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXTemporaryObjectExprClass"); + return nullptr; case Stmt::CXXDefaultArgExprClass: - zig_panic("TODO handle C CXXDefaultArgExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXDefaultArgExprClass"); + return nullptr; case Stmt::CXXDefaultInitExprClass: - zig_panic("TODO handle C CXXDefaultInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXDefaultInitExprClass"); + return nullptr; case Stmt::CXXDeleteExprClass: - zig_panic("TODO handle C CXXDeleteExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXDeleteExprClass"); + return nullptr; case Stmt::CXXDependentScopeMemberExprClass: - zig_panic("TODO handle C CXXDependentScopeMemberExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXDependentScopeMemberExprClass"); + return nullptr; case Stmt::CXXFoldExprClass: - zig_panic("TODO handle C CXXFoldExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXFoldExprClass"); + return nullptr; case Stmt::CXXInheritedCtorInitExprClass: - zig_panic("TODO handle C CXXInheritedCtorInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXInheritedCtorInitExprClass"); + return nullptr; case Stmt::CXXNewExprClass: - zig_panic("TODO handle C CXXNewExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXNewExprClass"); + return nullptr; case Stmt::CXXNoexceptExprClass: - zig_panic("TODO handle C CXXNoexceptExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXNoexceptExprClass"); + return nullptr; case Stmt::CXXNullPtrLiteralExprClass: - zig_panic("TODO handle C CXXNullPtrLiteralExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXNullPtrLiteralExprClass"); + return nullptr; case Stmt::CXXPseudoDestructorExprClass: - zig_panic("TODO handle C CXXPseudoDestructorExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXPseudoDestructorExprClass"); + return nullptr; case Stmt::CXXScalarValueInitExprClass: - zig_panic("TODO handle C CXXScalarValueInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXScalarValueInitExprClass"); + return nullptr; case Stmt::CXXStdInitializerListExprClass: - zig_panic("TODO handle C CXXStdInitializerListExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXStdInitializerListExprClass"); + return nullptr; case Stmt::CXXThisExprClass: - zig_panic("TODO handle C CXXThisExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXThisExprClass"); + return nullptr; case Stmt::CXXThrowExprClass: - zig_panic("TODO handle C CXXThrowExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXThrowExprClass"); + return nullptr; case Stmt::CXXTypeidExprClass: - zig_panic("TODO handle C CXXTypeidExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXTypeidExprClass"); + return nullptr; case Stmt::CXXUnresolvedConstructExprClass: - zig_panic("TODO handle C CXXUnresolvedConstructExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXUnresolvedConstructExprClass"); + return nullptr; case Stmt::CXXUuidofExprClass: - zig_panic("TODO handle C CXXUuidofExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXUuidofExprClass"); + return nullptr; case Stmt::CallExprClass: - zig_panic("TODO handle C CallExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CallExprClass"); + return nullptr; case Stmt::CUDAKernelCallExprClass: - zig_panic("TODO handle C CUDAKernelCallExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CUDAKernelCallExprClass"); + return nullptr; case Stmt::CXXMemberCallExprClass: - zig_panic("TODO handle C CXXMemberCallExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXMemberCallExprClass"); + return nullptr; case Stmt::CXXOperatorCallExprClass: - zig_panic("TODO handle C CXXOperatorCallExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXOperatorCallExprClass"); + return nullptr; case Stmt::UserDefinedLiteralClass: - zig_panic("TODO handle C UserDefinedLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C UserDefinedLiteralClass"); + return nullptr; case Stmt::CStyleCastExprClass: - zig_panic("TODO handle C CStyleCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CStyleCastExprClass"); + return nullptr; case Stmt::CXXFunctionalCastExprClass: - zig_panic("TODO handle C CXXFunctionalCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXFunctionalCastExprClass"); + return nullptr; case Stmt::CXXConstCastExprClass: - zig_panic("TODO handle C CXXConstCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXConstCastExprClass"); + return nullptr; case Stmt::CXXDynamicCastExprClass: - zig_panic("TODO handle C CXXDynamicCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXDynamicCastExprClass"); + return nullptr; case Stmt::CXXReinterpretCastExprClass: - zig_panic("TODO handle C CXXReinterpretCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXReinterpretCastExprClass"); + return nullptr; case Stmt::CXXStaticCastExprClass: - zig_panic("TODO handle C CXXStaticCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CXXStaticCastExprClass"); + return nullptr; case Stmt::ObjCBridgedCastExprClass: - zig_panic("TODO handle C ObjCBridgedCastExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCBridgedCastExprClass"); + return nullptr; case Stmt::CharacterLiteralClass: - zig_panic("TODO handle C CharacterLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CharacterLiteralClass"); + return nullptr; case Stmt::ChooseExprClass: - zig_panic("TODO handle C ChooseExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ChooseExprClass"); + return nullptr; case Stmt::CompoundLiteralExprClass: - zig_panic("TODO handle C CompoundLiteralExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CompoundLiteralExprClass"); + return nullptr; case Stmt::ConvertVectorExprClass: - zig_panic("TODO handle C ConvertVectorExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ConvertVectorExprClass"); + return nullptr; case Stmt::CoawaitExprClass: - zig_panic("TODO handle C CoawaitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CoawaitExprClass"); + return nullptr; case Stmt::CoyieldExprClass: - zig_panic("TODO handle C CoyieldExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C CoyieldExprClass"); + return nullptr; case Stmt::DependentCoawaitExprClass: - zig_panic("TODO handle C DependentCoawaitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DependentCoawaitExprClass"); + return nullptr; case Stmt::DependentScopeDeclRefExprClass: - zig_panic("TODO handle C DependentScopeDeclRefExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DependentScopeDeclRefExprClass"); + return nullptr; case Stmt::DesignatedInitExprClass: - zig_panic("TODO handle C DesignatedInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DesignatedInitExprClass"); + return nullptr; case Stmt::DesignatedInitUpdateExprClass: - zig_panic("TODO handle C DesignatedInitUpdateExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C DesignatedInitUpdateExprClass"); + return nullptr; case Stmt::ExprWithCleanupsClass: - zig_panic("TODO handle C ExprWithCleanupsClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ExprWithCleanupsClass"); + return nullptr; case Stmt::ExpressionTraitExprClass: - zig_panic("TODO handle C ExpressionTraitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ExpressionTraitExprClass"); + return nullptr; case Stmt::ExtVectorElementExprClass: - zig_panic("TODO handle C ExtVectorElementExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ExtVectorElementExprClass"); + return nullptr; case Stmt::FloatingLiteralClass: - zig_panic("TODO handle C FloatingLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C FloatingLiteralClass"); + return nullptr; case Stmt::FunctionParmPackExprClass: - zig_panic("TODO handle C FunctionParmPackExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C FunctionParmPackExprClass"); + return nullptr; case Stmt::GNUNullExprClass: - zig_panic("TODO handle C GNUNullExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C GNUNullExprClass"); + return nullptr; case Stmt::GenericSelectionExprClass: - zig_panic("TODO handle C GenericSelectionExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C GenericSelectionExprClass"); + return nullptr; case Stmt::ImaginaryLiteralClass: - zig_panic("TODO handle C ImaginaryLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ImaginaryLiteralClass"); + return nullptr; case Stmt::ImplicitValueInitExprClass: - zig_panic("TODO handle C ImplicitValueInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ImplicitValueInitExprClass"); + return nullptr; case Stmt::InitListExprClass: - zig_panic("TODO handle C InitListExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C InitListExprClass"); + return nullptr; case Stmt::LambdaExprClass: - zig_panic("TODO handle C LambdaExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C LambdaExprClass"); + return nullptr; case Stmt::MSPropertyRefExprClass: - zig_panic("TODO handle C MSPropertyRefExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MSPropertyRefExprClass"); + return nullptr; case Stmt::MSPropertySubscriptExprClass: - zig_panic("TODO handle C MSPropertySubscriptExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MSPropertySubscriptExprClass"); + return nullptr; case Stmt::MaterializeTemporaryExprClass: - zig_panic("TODO handle C MaterializeTemporaryExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MaterializeTemporaryExprClass"); + return nullptr; case Stmt::MemberExprClass: - zig_panic("TODO handle C MemberExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MemberExprClass"); + return nullptr; case Stmt::NoInitExprClass: - zig_panic("TODO handle C NoInitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C NoInitExprClass"); + return nullptr; case Stmt::OMPArraySectionExprClass: - zig_panic("TODO handle C OMPArraySectionExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPArraySectionExprClass"); + return nullptr; case Stmt::ObjCArrayLiteralClass: - zig_panic("TODO handle C ObjCArrayLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCArrayLiteralClass"); + return nullptr; case Stmt::ObjCAvailabilityCheckExprClass: - zig_panic("TODO handle C ObjCAvailabilityCheckExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAvailabilityCheckExprClass"); + return nullptr; case Stmt::ObjCBoolLiteralExprClass: - zig_panic("TODO handle C ObjCBoolLiteralExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCBoolLiteralExprClass"); + return nullptr; case Stmt::ObjCBoxedExprClass: - zig_panic("TODO handle C ObjCBoxedExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCBoxedExprClass"); + return nullptr; case Stmt::ObjCDictionaryLiteralClass: - zig_panic("TODO handle C ObjCDictionaryLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCDictionaryLiteralClass"); + return nullptr; case Stmt::ObjCEncodeExprClass: - zig_panic("TODO handle C ObjCEncodeExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCEncodeExprClass"); + return nullptr; case Stmt::ObjCIndirectCopyRestoreExprClass: - zig_panic("TODO handle C ObjCIndirectCopyRestoreExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCIndirectCopyRestoreExprClass"); + return nullptr; case Stmt::ObjCIsaExprClass: - zig_panic("TODO handle C ObjCIsaExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCIsaExprClass"); + return nullptr; case Stmt::ObjCIvarRefExprClass: - zig_panic("TODO handle C ObjCIvarRefExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCIvarRefExprClass"); + return nullptr; case Stmt::ObjCMessageExprClass: - zig_panic("TODO handle C ObjCMessageExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCMessageExprClass"); + return nullptr; case Stmt::ObjCPropertyRefExprClass: - zig_panic("TODO handle C ObjCPropertyRefExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCPropertyRefExprClass"); + return nullptr; case Stmt::ObjCProtocolExprClass: - zig_panic("TODO handle C ObjCProtocolExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCProtocolExprClass"); + return nullptr; case Stmt::ObjCSelectorExprClass: - zig_panic("TODO handle C ObjCSelectorExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCSelectorExprClass"); + return nullptr; case Stmt::ObjCStringLiteralClass: - zig_panic("TODO handle C ObjCStringLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCStringLiteralClass"); + return nullptr; case Stmt::ObjCSubscriptRefExprClass: - zig_panic("TODO handle C ObjCSubscriptRefExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCSubscriptRefExprClass"); + return nullptr; case Stmt::OffsetOfExprClass: - zig_panic("TODO handle C OffsetOfExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OffsetOfExprClass"); + return nullptr; case Stmt::OpaqueValueExprClass: - zig_panic("TODO handle C OpaqueValueExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OpaqueValueExprClass"); + return nullptr; case Stmt::UnresolvedLookupExprClass: - zig_panic("TODO handle C UnresolvedLookupExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C UnresolvedLookupExprClass"); + return nullptr; case Stmt::UnresolvedMemberExprClass: - zig_panic("TODO handle C UnresolvedMemberExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C UnresolvedMemberExprClass"); + return nullptr; case Stmt::PackExpansionExprClass: - zig_panic("TODO handle C PackExpansionExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C PackExpansionExprClass"); + return nullptr; case Stmt::ParenExprClass: - zig_panic("TODO handle C ParenExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ParenExprClass"); + return nullptr; case Stmt::ParenListExprClass: - zig_panic("TODO handle C ParenListExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ParenListExprClass"); + return nullptr; case Stmt::PredefinedExprClass: - zig_panic("TODO handle C PredefinedExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C PredefinedExprClass"); + return nullptr; case Stmt::PseudoObjectExprClass: - zig_panic("TODO handle C PseudoObjectExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C PseudoObjectExprClass"); + return nullptr; case Stmt::ShuffleVectorExprClass: - zig_panic("TODO handle C ShuffleVectorExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ShuffleVectorExprClass"); + return nullptr; case Stmt::SizeOfPackExprClass: - zig_panic("TODO handle C SizeOfPackExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SizeOfPackExprClass"); + return nullptr; case Stmt::StmtExprClass: - zig_panic("TODO handle C StmtExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C StmtExprClass"); + return nullptr; case Stmt::StringLiteralClass: - zig_panic("TODO handle C StringLiteralClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C StringLiteralClass"); + return nullptr; case Stmt::SubstNonTypeTemplateParmExprClass: - zig_panic("TODO handle C SubstNonTypeTemplateParmExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SubstNonTypeTemplateParmExprClass"); + return nullptr; case Stmt::SubstNonTypeTemplateParmPackExprClass: - zig_panic("TODO handle C SubstNonTypeTemplateParmPackExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SubstNonTypeTemplateParmPackExprClass"); + return nullptr; case Stmt::TypeTraitExprClass: - zig_panic("TODO handle C TypeTraitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C TypeTraitExprClass"); + return nullptr; case Stmt::TypoExprClass: - zig_panic("TODO handle C TypoExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C TypoExprClass"); + return nullptr; case Stmt::UnaryExprOrTypeTraitExprClass: - zig_panic("TODO handle C UnaryExprOrTypeTraitExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C UnaryExprOrTypeTraitExprClass"); + return nullptr; case Stmt::VAArgExprClass: - zig_panic("TODO handle C VAArgExprClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C VAArgExprClass"); + return nullptr; case Stmt::ForStmtClass: - zig_panic("TODO handle C ForStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ForStmtClass"); + return nullptr; case Stmt::GotoStmtClass: - zig_panic("TODO handle C GotoStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C GotoStmtClass"); + return nullptr; case Stmt::IfStmtClass: - zig_panic("TODO handle C IfStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C IfStmtClass"); + return nullptr; case Stmt::IndirectGotoStmtClass: - zig_panic("TODO handle C IndirectGotoStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C IndirectGotoStmtClass"); + return nullptr; case Stmt::LabelStmtClass: - zig_panic("TODO handle C LabelStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C LabelStmtClass"); + return nullptr; case Stmt::MSDependentExistsStmtClass: - zig_panic("TODO handle C MSDependentExistsStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C MSDependentExistsStmtClass"); + return nullptr; case Stmt::NullStmtClass: - zig_panic("TODO handle C NullStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C NullStmtClass"); + return nullptr; case Stmt::OMPAtomicDirectiveClass: - zig_panic("TODO handle C OMPAtomicDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPAtomicDirectiveClass"); + return nullptr; case Stmt::OMPBarrierDirectiveClass: - zig_panic("TODO handle C OMPBarrierDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPBarrierDirectiveClass"); + return nullptr; case Stmt::OMPCancelDirectiveClass: - zig_panic("TODO handle C OMPCancelDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPCancelDirectiveClass"); + return nullptr; case Stmt::OMPCancellationPointDirectiveClass: - zig_panic("TODO handle C OMPCancellationPointDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPCancellationPointDirectiveClass"); + return nullptr; case Stmt::OMPCriticalDirectiveClass: - zig_panic("TODO handle C OMPCriticalDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPCriticalDirectiveClass"); + return nullptr; case Stmt::OMPFlushDirectiveClass: - zig_panic("TODO handle C OMPFlushDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPFlushDirectiveClass"); + return nullptr; case Stmt::OMPDistributeDirectiveClass: - zig_panic("TODO handle C OMPDistributeDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPDistributeDirectiveClass"); + return nullptr; case Stmt::OMPDistributeParallelForDirectiveClass: - zig_panic("TODO handle C OMPDistributeParallelForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPDistributeParallelForDirectiveClass"); + return nullptr; case Stmt::OMPDistributeParallelForSimdDirectiveClass: - zig_panic("TODO handle C OMPDistributeParallelForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPDistributeParallelForSimdDirectiveClass"); + return nullptr; case Stmt::OMPDistributeSimdDirectiveClass: - zig_panic("TODO handle C OMPDistributeSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPDistributeSimdDirectiveClass"); + return nullptr; case Stmt::OMPForDirectiveClass: - zig_panic("TODO handle C OMPForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPForDirectiveClass"); + return nullptr; case Stmt::OMPForSimdDirectiveClass: - zig_panic("TODO handle C OMPForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPForSimdDirectiveClass"); + return nullptr; case Stmt::OMPParallelForDirectiveClass: - zig_panic("TODO handle C OMPParallelForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPParallelForDirectiveClass"); + return nullptr; case Stmt::OMPParallelForSimdDirectiveClass: - zig_panic("TODO handle C OMPParallelForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPParallelForSimdDirectiveClass"); + return nullptr; case Stmt::OMPSimdDirectiveClass: - zig_panic("TODO handle C OMPSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPSimdDirectiveClass"); + return nullptr; case Stmt::OMPTargetParallelForSimdDirectiveClass: - zig_panic("TODO handle C OMPTargetParallelForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetParallelForSimdDirectiveClass"); + return nullptr; case Stmt::OMPTargetSimdDirectiveClass: - zig_panic("TODO handle C OMPTargetSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetSimdDirectiveClass"); + return nullptr; case Stmt::OMPTargetTeamsDistributeDirectiveClass: - zig_panic("TODO handle C OMPTargetTeamsDistributeDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetTeamsDistributeDirectiveClass"); + return nullptr; case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: - zig_panic("TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass"); + return nullptr; case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: - zig_panic("TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass"); + return nullptr; case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: - zig_panic("TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass"); + return nullptr; case Stmt::OMPTaskLoopDirectiveClass: - zig_panic("TODO handle C OMPTaskLoopDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskLoopDirectiveClass"); + return nullptr; case Stmt::OMPTaskLoopSimdDirectiveClass: - zig_panic("TODO handle C OMPTaskLoopSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskLoopSimdDirectiveClass"); + return nullptr; case Stmt::OMPTeamsDistributeDirectiveClass: - zig_panic("TODO handle C OMPTeamsDistributeDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTeamsDistributeDirectiveClass"); + return nullptr; case Stmt::OMPTeamsDistributeParallelForDirectiveClass: - zig_panic("TODO handle C OMPTeamsDistributeParallelForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass"); + return nullptr; case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: - zig_panic("TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass"); + return nullptr; case Stmt::OMPTeamsDistributeSimdDirectiveClass: - zig_panic("TODO handle C OMPTeamsDistributeSimdDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTeamsDistributeSimdDirectiveClass"); + return nullptr; case Stmt::OMPMasterDirectiveClass: - zig_panic("TODO handle C OMPMasterDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPMasterDirectiveClass"); + return nullptr; case Stmt::OMPOrderedDirectiveClass: - zig_panic("TODO handle C OMPOrderedDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPOrderedDirectiveClass"); + return nullptr; case Stmt::OMPParallelDirectiveClass: - zig_panic("TODO handle C OMPParallelDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPParallelDirectiveClass"); + return nullptr; case Stmt::OMPParallelSectionsDirectiveClass: - zig_panic("TODO handle C OMPParallelSectionsDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPParallelSectionsDirectiveClass"); + return nullptr; case Stmt::OMPSectionDirectiveClass: - zig_panic("TODO handle C OMPSectionDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPSectionDirectiveClass"); + return nullptr; case Stmt::OMPSectionsDirectiveClass: - zig_panic("TODO handle C OMPSectionsDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPSectionsDirectiveClass"); + return nullptr; case Stmt::OMPSingleDirectiveClass: - zig_panic("TODO handle C OMPSingleDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPSingleDirectiveClass"); + return nullptr; case Stmt::OMPTargetDataDirectiveClass: - zig_panic("TODO handle C OMPTargetDataDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetDataDirectiveClass"); + return nullptr; case Stmt::OMPTargetDirectiveClass: - zig_panic("TODO handle C OMPTargetDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetDirectiveClass"); + return nullptr; case Stmt::OMPTargetEnterDataDirectiveClass: - zig_panic("TODO handle C OMPTargetEnterDataDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetEnterDataDirectiveClass"); + return nullptr; case Stmt::OMPTargetExitDataDirectiveClass: - zig_panic("TODO handle C OMPTargetExitDataDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetExitDataDirectiveClass"); + return nullptr; case Stmt::OMPTargetParallelDirectiveClass: - zig_panic("TODO handle C OMPTargetParallelDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetParallelDirectiveClass"); + return nullptr; case Stmt::OMPTargetParallelForDirectiveClass: - zig_panic("TODO handle C OMPTargetParallelForDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetParallelForDirectiveClass"); + return nullptr; case Stmt::OMPTargetTeamsDirectiveClass: - zig_panic("TODO handle C OMPTargetTeamsDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetTeamsDirectiveClass"); + return nullptr; case Stmt::OMPTargetUpdateDirectiveClass: - zig_panic("TODO handle C OMPTargetUpdateDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTargetUpdateDirectiveClass"); + return nullptr; case Stmt::OMPTaskDirectiveClass: - zig_panic("TODO handle C OMPTaskDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskDirectiveClass"); + return nullptr; case Stmt::OMPTaskgroupDirectiveClass: - zig_panic("TODO handle C OMPTaskgroupDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskgroupDirectiveClass"); + return nullptr; case Stmt::OMPTaskwaitDirectiveClass: - zig_panic("TODO handle C OMPTaskwaitDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskwaitDirectiveClass"); + return nullptr; case Stmt::OMPTaskyieldDirectiveClass: - zig_panic("TODO handle C OMPTaskyieldDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTaskyieldDirectiveClass"); + return nullptr; case Stmt::OMPTeamsDirectiveClass: - zig_panic("TODO handle C OMPTeamsDirectiveClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C OMPTeamsDirectiveClass"); + return nullptr; case Stmt::ObjCAtCatchStmtClass: - zig_panic("TODO handle C ObjCAtCatchStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAtCatchStmtClass"); + return nullptr; case Stmt::ObjCAtFinallyStmtClass: - zig_panic("TODO handle C ObjCAtFinallyStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAtFinallyStmtClass"); + return nullptr; case Stmt::ObjCAtSynchronizedStmtClass: - zig_panic("TODO handle C ObjCAtSynchronizedStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAtSynchronizedStmtClass"); + return nullptr; case Stmt::ObjCAtThrowStmtClass: - zig_panic("TODO handle C ObjCAtThrowStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAtThrowStmtClass"); + return nullptr; case Stmt::ObjCAtTryStmtClass: - zig_panic("TODO handle C ObjCAtTryStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAtTryStmtClass"); + return nullptr; case Stmt::ObjCAutoreleasePoolStmtClass: - zig_panic("TODO handle C ObjCAutoreleasePoolStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCAutoreleasePoolStmtClass"); + return nullptr; case Stmt::ObjCForCollectionStmtClass: - zig_panic("TODO handle C ObjCForCollectionStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C ObjCForCollectionStmtClass"); + return nullptr; case Stmt::SEHExceptStmtClass: - zig_panic("TODO handle C SEHExceptStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SEHExceptStmtClass"); + return nullptr; case Stmt::SEHFinallyStmtClass: - zig_panic("TODO handle C SEHFinallyStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SEHFinallyStmtClass"); + return nullptr; case Stmt::SEHLeaveStmtClass: - zig_panic("TODO handle C SEHLeaveStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SEHLeaveStmtClass"); + return nullptr; case Stmt::SEHTryStmtClass: - zig_panic("TODO handle C SEHTryStmtClass"); + emit_warning(c, stmt->getLocStart(), "TODO handle C SEHTryStmtClass"); + return nullptr; } zig_unreachable(); } @@ -1642,6 +2043,11 @@ static void visit_fn_decl(Context *c, const FunctionDecl *fn_decl) { AstNode *fn_def_node = trans_create_node(c, NodeTypeFnDef); fn_def_node->data.fn_def.fn_proto = proto_node; fn_def_node->data.fn_def.body = trans_stmt(c, nullptr, body); + assert(fn_def_node->data.fn_def.body != skip_add_to_block_node); + if (fn_def_node->data.fn_def.body == nullptr) { + emit_warning(c, fn_decl->getLocation(), "unable to translate function"); + return; + } proto_node->data.fn_proto.fn_def_node = fn_def_node; c->root->data.root.top_level_decls.append(fn_def_node);