Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

implement null terminated pointers

Browse Source
This commit is contained in:
Andrew Kelley 2019-11-14 03:26:33 -05:00
parent e3404e3c78
commit 1aa978f32e
No known key found for this signature in database
GPG Key ID: 7C5F548F728501A9
10 changed files with 75 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/std/builtin.zig
View File

@ -144,6 +144,7 @@ pub const TypeInfo = union(enum) {
alignment: comptime_int,
child: type,
is_allowzero: bool,
is_null_terminated: bool,
/// This data structure is used by the Zig language code generation and
/// therefore must be kept in sync with the compiler implementation.

1
lib/std/meta.zig
View File

@ -558,3 +558,4 @@ pub fn refAllDecls(comptime T: type) void {
if (!builtin.is_test) return;
_ = declarations(T);
}

3
src/all_types.hpp
View File

@ -55,6 +55,7 @@ enum PtrLen {
PtrLenUnknown,
PtrLenSingle,
PtrLenC,
PtrLenNull,
};
// This one corresponds to the builtin.zig enum.
@ -825,6 +826,7 @@ struct AstNodePointerType {
Token *allow_zero_token;
bool is_const;
bool is_volatile;
bool is_null_terminated;
};
struct AstNodeInferredArrayType {
@ -838,6 +840,7 @@ struct AstNodeArrayType {
Token *allow_zero_token;
bool is_const;
bool is_volatile;
bool is_null_terminated;
};
struct AstNodeUsingNamespace {

4
src/analyze.cpp
View File

@ -460,6 +460,8 @@ static const char *ptr_len_to_star_str(PtrLen ptr_len) {
return "[*]";
case PtrLenC:
return "[*c]";
case PtrLenNull:
return "[*]null ";
}
zig_unreachable();
}
@ -7032,7 +7034,7 @@ uint32_t type_id_hash(TypeId x) {
return hash_ptr(x.data.error_union.err_set_type) ^ hash_ptr(x.data.error_union.payload_type);
case ZigTypeIdPointer:
return hash_ptr(x.data.pointer.child_type) +
((x.data.pointer.ptr_len == PtrLenSingle) ? (uint32_t)1120226602 : (uint32_t)3200913342) +
(uint32_t)x.data.pointer.ptr_len * 1120226602u +
(x.data.pointer.is_const ? (uint32_t)2749109194 : (uint32_t)4047371087) +
(x.data.pointer.is_volatile ? (uint32_t)536730450 : (uint32_t)1685612214) +
(x.data.pointer.allow_zero ? (uint32_t)3324284834 : (uint32_t)3584904923) +

4
src/dump_analysis.cpp
View File

@ -992,6 +992,10 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
jw_object_field(jw, "len");
jw_int(jw, 3);
break;
case PtrLenNull:
jw_object_field(jw, "len");
jw_int(jw, 4);
break;
}
anal_dump_pointer_attrs(ctx, ty);
break;

27
src/ir.cpp
View File

@ -6043,13 +6043,25 @@ static PtrLen star_token_to_ptr_len(TokenId token_id) {
static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode *node) {
assert(node->type == NodeTypePointerType);
PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);
if (node->data.pointer_type.is_null_terminated) {
if (ptr_len == PtrLenUnknown) {
ptr_len = PtrLenNull;
} else {
exec_add_error_node(irb->codegen, irb->exec, node,
buf_sprintf("null-terminated pointer must be specified with [*] token"));
return irb->codegen->invalid_instruction;
}
}
bool is_const = node->data.pointer_type.is_const;
bool is_volatile = node->data.pointer_type.is_volatile;
bool is_allow_zero = node->data.pointer_type.allow_zero_token != nullptr;
AstNode *expr_node = node->data.pointer_type.op_expr;
AstNode *align_expr = node->data.pointer_type.align_expr;
IrInstruction *align_value;
if (align_expr != nullptr) {
align_value = ir_gen_node(irb, align_expr, scope);
@ -9793,6 +9805,7 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
// alignment can be decreased
// bit offset attributes must match exactly
// PtrLenSingle/PtrLenUnknown must match exactly, but PtrLenC matches either one
// PtrLenNull can coerce into PtrLenUnknown
ZigType *wanted_ptr_type = get_src_ptr_type(wanted_type);
ZigType *actual_ptr_type = get_src_ptr_type(actual_type);
bool wanted_allows_zero = ptr_allows_addr_zero(wanted_type);
@ -9843,7 +9856,10 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
return result;
}
bool ptr_lens_equal = actual_ptr_type->data.pointer.ptr_len == wanted_ptr_type->data.pointer.ptr_len;
if ((ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr) &&
bool ok_null_term_ptrs =
actual_ptr_type->data.pointer.ptr_len == PtrLenNull ||
wanted_ptr_type->data.pointer.ptr_len == PtrLenUnknown;
if ((ptr_lens_equal || wanted_is_c_ptr || actual_is_c_ptr || ok_null_term_ptrs) &&
type_has_bits(wanted_type) == type_has_bits(actual_type) &&
(!actual_ptr_type->data.pointer.is_const || wanted_ptr_type->data.pointer.is_const) &&
(!actual_ptr_type->data.pointer.is_volatile || wanted_ptr_type->data.pointer.is_volatile) &&
@ -14532,6 +14548,7 @@ static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
case PtrLenSingle:
return false;
case PtrLenUnknown:
case PtrLenNull:
case PtrLenC:
break;
}
@ -21166,6 +21183,7 @@ static BuiltinPtrSize ptr_len_to_size_enum_index(PtrLen ptr_len) {
case PtrLenSingle:
return BuiltinPtrSizeOne;
case PtrLenUnknown:
case PtrLenNull:
return BuiltinPtrSizeMany;
case PtrLenC:
return BuiltinPtrSizeC;
@ -21210,7 +21228,7 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
result->special = ConstValSpecialStatic;
result->type = type_info_pointer_type;
ConstExprValue **fields = alloc_const_vals_ptrs(6);
ConstExprValue **fields = alloc_const_vals_ptrs(7);
result->data.x_struct.fields = fields;
// size: Size
@ -21246,6 +21264,11 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
fields[5]->special = ConstValSpecialStatic;
fields[5]->type = ira->codegen->builtin_types.entry_bool;
fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
// is_null_terminated: bool
ensure_field_index(result->type, "is_null_terminated", 6);
fields[6]->special = ConstValSpecialStatic;
fields[6]->type = ira->codegen->builtin_types.entry_bool;
fields[6]->data.x_bool = attrs_type->data.pointer.ptr_len == PtrLenNull;
return result;
};

10
src/parser.cpp
View File

@ -2618,6 +2618,11 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
if (array != nullptr) {
assert(array->type == NodeTypeArrayType);
while (true) {
if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
array->data.array_type.is_null_terminated = true;
continue;
}
Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
if (allowzero_token != nullptr) {
array->data.array_type.allow_zero_token = allowzero_token;
@ -2653,6 +2658,11 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
if (child == nullptr)
child = ptr;
while (true) {
if (eat_token_if(pc, TokenIdKeywordNull) != nullptr) {
child->data.pointer_type.is_null_terminated = true;
continue;
}
Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
if (allowzero_token != nullptr) {
child->data.pointer_type.allow_zero_token = allowzero_token;

2
src/translate_c.cpp
View File

@ -291,6 +291,7 @@ static TokenId ptr_len_to_token_id(PtrLen ptr_len) {
case PtrLenSingle:
return TokenIdStar;
case PtrLenUnknown:
case PtrLenNull:
return TokenIdBracketStarBracket;
case PtrLenC:
return TokenIdBracketStarCBracket;
@ -302,6 +303,7 @@ static AstNode *trans_create_node_ptr_type(Context *c, bool is_const, bool is_vo
AstNode *node = trans_create_node(c, NodeTypePointerType);
node->data.pointer_type.star_token = allocate<ZigToken>(1);
node->data.pointer_type.star_token->id = ptr_len_to_token_id(ptr_len);
node->data.pointer_type.is_null_terminated = (ptr_len == PtrLenNull);
node->data.pointer_type.is_const = is_const;
node->data.pointer_type.is_volatile = is_volatile;
node->data.pointer_type.op_expr = child_node;

12
test/compile_errors.zig
View File

@ -68,6 +68,18 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"tmp.zig:9:27: error: @atomicRmw on enum only works with .Xchg",
);
cases.add(
"disallow coercion from non-null-terminated pointer to null-terminated pointer",
\\extern fn puts(s: [*]null const u8) c_int;
\\pub fn main() void {
\\ const no_zero_array = [_]u8{'h', 'e', 'l', 'l', 'o'};
\\ const no_zero_ptr: [*]const u8 = &no_zero_array;
\\ _ = puts(no_zero_ptr);
\\}
,
"tmp.zig:5:14: error: expected type '[*]null const u8', found '[*]const u8'",
);
cases.add(
"atomic orderings of atomicStore Acquire or AcqRel",
\\export fn entry() void {

14
test/stage1/behavior/pointers.zig
View File

@ -200,3 +200,17 @@ test "assign null directly to C pointer and test null equality" {
}
comptime expect((y1 orelse &othery) == y1);
}
test "null terminated pointer" {
const S = struct {
fn doTheTest() void {
var array_with_zero = [_]u8{'h', 'e', 'l', 'l', 'o', 0};
var zero_ptr: [*]null const u8 = @ptrCast([*]null const u8, &array_with_zero);
var no_zero_ptr: [*]const u8 = zero_ptr;
expect(std.mem.eql(u8, std.mem.toSliceConst(u8, no_zero_ptr), "hello"));
}
};
S.doTheTest();
// TODO test fails at comptime
//comptime S.doTheTest();
}