Use or_break and or_continue where appropriate in the core library

core/encoding/json/marshal.odin

@@ -265,9 +265,8 @@ marshal_to_writer :: proc(w: io.Writer, v: any, opt: ^Marshal_Options) -> (err:
 
 			i := 0
 			for bucket_index in 0..<map_cap {
-				if !runtime.map_hash_is_valid(hs[bucket_index]) {
+				runtime.map_hash_is_valid(hs[bucket_index]) or_continue
-					continue
+
-				}
 				opt_write_iteration(w, opt, i) or_return
 				i += 1
 

core/fmt/fmt.odin

@@ -755,9 +755,8 @@ _parse_int :: proc(s: string, offset: int) -> (result: int, new_offset: int, ok:
 	new_offset = offset
 	for new_offset < len(s) {
 		c := s[new_offset]
-		if !is_digit(c) {
+		is_digit(c) or_break
-			break
+
-		}
 		new_offset += 1
 
 		result *= 10
@@ -2555,9 +2554,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 			ks, vs, hs, _, _ := runtime.map_kvh_data_dynamic(m^, info.map_info)
 			j := 0
 			for bucket_index in 0..<map_cap {
-				if !runtime.map_hash_is_valid(hs[bucket_index]) {
+				runtime.map_hash_is_valid(hs[bucket_index]) or_continue
-					continue
-				}
 
 				if j > 0 {
 					io.write_string(fi.writer, ", ", &fi.n)

core/math/big/prime.odin

@@ -1214,7 +1214,6 @@ internal_random_prime :: proc(a: ^Int, size_in_bits: int, trials: int, flags :=
 		trials = number_of_rabin_miller_trials(size_in_bits)
 	}
 
-	res: bool
 	RANDOM_PRIME_ITERATIONS_USED = 0
 
 	for {
@@ -1251,11 +1250,7 @@ internal_random_prime :: proc(a: ^Int, size_in_bits: int, trials: int, flags :=
 		/*
 			Is it prime?
 		*/
-		res = internal_int_is_prime(a, trials)                       or_return
+		internal_int_is_prime(a, trials) or_return or_continue
-
-		if (!res) {
-			continue
-		}
 
 		if .Safe in flags {
 			/*
@@ -1267,9 +1262,10 @@ internal_random_prime :: proc(a: ^Int, size_in_bits: int, trials: int, flags :=
 			/*
 				Is it prime?
 			*/
-			res = internal_int_is_prime(a, trials)                   or_return
+			if internal_int_is_prime(a, trials) or_return {
+				break
+			}
 		}
-		if res { break }
 	}
 
 	if .Safe in flags {

core/net/dns.odin

@@ -247,23 +247,19 @@ get_dns_records_from_nameservers :: proc(hostname: string, type: DNS_Record_Type
 		}
 		defer close(conn)
 
-		_, send_err := send(conn, dns_packet[:], name_server)
+		_ = send(conn, dns_packet[:], name_server) or_continue
-		if send_err != nil {
-			continue
-		}
 
-		set_err := set_option(conn, .Receive_Timeout, time.Second * 1)
+		if set_option(conn, .Receive_Timeout, time.Second * 1) != nil {
-		if set_err != nil {
 			return nil, .Connection_Error
 		}
 
-		recv_sz, _, recv_err := recv_udp(conn, dns_response_buf[:])
+		// recv_sz, _, recv_err := recv_udp(conn, dns_response_buf[:])
-		if recv_err == UDP_Recv_Error.Timeout {
+		// if recv_err == UDP_Recv_Error.Timeout {
-			continue
+		// 	continue
-		} else if recv_err != nil {
+		// } else if recv_err != nil {
-			continue
+		// 	continue
-		}
+		// }
-
+		recv_sz, _ := recv_udp(conn, dns_response_buf[:]) or_continue
 		if recv_sz == 0 {
 			continue
 		}
@@ -429,13 +425,11 @@ load_hosts :: proc(hosts_file_path: string, allocator := context.allocator) -> (
 		}
 
 		for hostname in splits[1:] {
-			if len(hostname) == 0 {
+			if len(hostname) != 0 {
-				continue
-			}
-
 				append(&_hosts, DNS_Host_Entry{hostname, addr})
 			}
 		}
+	}
 
 	return _hosts[:], true
 }
@@ -833,12 +827,10 @@ parse_response :: proc(response: []u8, filter: DNS_Record_Type = nil, allocator
 		}
 
 		rec := parse_record(response, &cur_idx, filter) or_return
-		if rec == nil {
+		if rec != nil {
-			continue
-		}
-
 			append(&_records, rec)
 		}
+	}
 
 	for _ in 0..<authority_count {
 		if cur_idx == len(response) {
@@ -846,12 +838,10 @@ parse_response :: proc(response: []u8, filter: DNS_Record_Type = nil, allocator
 		}
 
 		rec := parse_record(response, &cur_idx, filter) or_return
-		if rec == nil {
+		if rec != nil {
-			continue
-		}
-
 			append(&_records, rec)
 		}
+	}
 
 	for _ in 0..<additional_count {
 		if cur_idx == len(response) {
@@ -859,12 +849,10 @@ parse_response :: proc(response: []u8, filter: DNS_Record_Type = nil, allocator
 		}
 
 		rec := parse_record(response, &cur_idx, filter) or_return
-		if rec == nil {
+		if rec != nil {
-			continue
-		}
-
 			append(&_records, rec)
 		}
+	}
 
 	return _records[:], true
 }

core/net/dns_windows.odin

@@ -45,15 +45,22 @@ _get_dns_records_os :: proc(hostname: string, type: DNS_Record_Type, allocator :
 
 	count := 0
 	for r := rec; r != nil; r = r.pNext {
-		if r.wType != u16(type) do continue // NOTE(tetra): Should never happen, but...
+		if r.wType != u16(type) {
+			// NOTE(tetra): Should never happen, but...
+			continue
+		}
 		count += 1
 	}
 
 	recs := make([dynamic]DNS_Record, 0, count)
-	if recs == nil do return nil, .System_Error // return no results if OOM.
+	if recs == nil {
+		return nil, .System_Error // return no results if OOM.
+	}
 
 	for r := rec; r != nil; r = r.pNext {
-		if r.wType != u16(type) do continue // NOTE(tetra): Should never happen, but...
+		if r.wType != u16(type) {
+			continue // NOTE(tetra): Should never happen, but...
+		}
 
 		base_record := DNS_Record_Base{
 			record_name = strings.clone(string(r.pName)),

core/odin/ast/ast.odin

@@ -551,8 +551,8 @@ unparen_expr :: proc(expr: ^Expr) -> (val: ^Expr) {
 		return
 	}
 	for {
-		e, ok := val.derived.(^Paren_Expr)
+		e := val.derived.(^Paren_Expr) or_break
-		if !ok || e.expr == nil {
+		if e.expr == nil {
 			break
 		}
 		val = e.expr

core/odin/parser/parser.odin

@@ -1053,9 +1053,7 @@ parse_attribute :: proc(p: ^Parser, tok: tokenizer.Token, open_kind, close_kind:
 			}
 			append(&elems, elem)
 
-			if !allow_token(p, .Comma) {
+			allow_token(p, .Comma) or_break
-				break
-			}
 		}
 		p.expr_level -= 1
 		close = expect_token_after(p, close_kind, "attribute")
@@ -1174,9 +1172,7 @@ parse_foreign_decl :: proc(p: ^Parser) -> ^ast.Decl {
 				path := expect_token(p, .String)
 				append(&fullpaths, path.text)
 
-				if !allow_token(p, .Comma) {
+				allow_token(p, .Comma) or_break
-					break
-				}
 			}
 			expect_token(p, .Close_Brace)
 		} else {
@@ -1961,9 +1957,7 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
 
 		eaf := Expr_And_Flags{param, prefix_flags}
 		append(&list, eaf)
-		if !allow_token(p, .Comma) {
+		allow_token(p, .Comma) or_break
-			break
-		}
 	}
 
 	if p.curr_tok.kind != .Colon {
@@ -2011,10 +2005,7 @@ parse_field_list :: proc(p: ^Parser, follow: tokenizer.Token_Kind, allowed_flags
 			names = parse_ident_list(p, allow_poly_names)
 
 			total_name_count += len(names)
-			ok := handle_field(p, &seen_ellipsis, &fields, docs, names, allowed_flags, set_flags)
+			handle_field(p, &seen_ellipsis, &fields, docs, names, allowed_flags, set_flags) or_break
-			if !ok {
-				break
-			}
 		}
 	}
 
@@ -2361,9 +2352,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
 				elem := parse_expr(p, false)
 				append(&args, elem)
 
-				if !allow_token(p, .Comma) {
+				allow_token(p, .Comma) or_break
-					break
-				}
 			}
 
 			close := expect_token(p, .Close_Brace)
@@ -2696,9 +2685,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
 			if _, ok := type.derived.(^ast.Bad_Expr); !ok {
 				append(&variants, type)
 			}
-			if !allow_token(p, .Comma) {
+			allow_token(p, .Comma) or_break
-				break
-			}
 		}
 
 		close := expect_closing_brace_of_field_list(p)
@@ -2916,9 +2903,7 @@ parse_elem_list :: proc(p: ^Parser) -> []^ast.Expr {
 
 		append(&elems, elem)
 
-		if !allow_token(p, .Comma) {
+		allow_token(p, .Comma) or_break
-			break
-		}
 	}
 
 	return elems[:]
@@ -2993,9 +2978,7 @@ parse_call_expr :: proc(p: ^Parser, operand: ^ast.Expr) -> ^ast.Expr {
 			seen_ellipsis = true
 		}
 
-		if !allow_token(p, .Comma) {
+		allow_token(p, .Comma) or_break
-			break
-		}
 	}
 
 	close := expect_token_after(p, .Close_Paren, "argument list")

core/path/filepath/match.odin

@@ -99,9 +99,7 @@ scan_chunk :: proc(pattern: string) -> (star: bool, chunk, rest: string) {
 		case ']':
 			in_range = false
 		case '*':
-			if !in_range {
+			in_range or_break scan_loop
-				break scan_loop
-			}
 
 		}
 	}

core/path/filepath/path.odin

@@ -392,9 +392,8 @@ rel :: proc(base_path, target_path: string, allocator := context.allocator) -> (
 		for ti < tl && target[ti] != SEPARATOR {
 			ti += 1
 		}
-		if !strings.equal_fold(target[t0:ti], base[b0:bi]) {
+		strings.equal_fold(target[t0:ti], base[b0:bi]) or_break
-			break
+
-		}
 		if bi < bl {
 			bi += 1
 		}

core/path/slashpath/match.odin

@@ -93,10 +93,7 @@ scan_chunk :: proc(pattern: string) -> (star: bool, chunk, rest: string) {
 		case ']':
 			in_range = false
 		case '*':
-			if !in_range {
+			in_range or_break scan_loop
-				break scan_loop
-			}
-
 		}
 	}
 	return star, pattern[:i], pattern[i:]

core/text/i18n/qt_linguist.odin

@@ -91,10 +91,7 @@ parse_qt_linguist_from_bytes :: proc(data: []byte, options := DEFAULT_PARSE_OPTI
 		// Find messages in section.
 		nth: int
 		for {
-			message_id, message_found := xml.find_child_by_ident(ts, child_id, "message", nth)
+			message_id := xml.find_child_by_ident(ts, child_id, "message", nth) or_break
-			if !message_found {
-				break
-			}
 
 			numerus_tag, _ := xml.find_attribute_val_by_key(ts, message_id, "numerus")
 			has_plurals := numerus_tag == "yes"
@@ -131,10 +128,7 @@ parse_qt_linguist_from_bytes :: proc(data: []byte, options := DEFAULT_PARSE_OPTI
 
 				num_plurals: int
 				for {
-					numerus_id, numerus_found := xml.find_child_by_ident(ts, translation_id, "numerusform", num_plurals)
+					numerus_id := xml.find_child_by_ident(ts, translation_id, "numerusform", num_plurals) or_break
-					if !numerus_found {
-						break
-					}
 					num_plurals += 1
 				}
 
@@ -145,10 +139,7 @@ parse_qt_linguist_from_bytes :: proc(data: []byte, options := DEFAULT_PARSE_OPTI
 
 				num_plurals = 0
 				for {
-					numerus_id, numerus_found := xml.find_child_by_ident(ts, translation_id, "numerusform", num_plurals)
+					numerus_id := xml.find_child_by_ident(ts, translation_id, "numerusform", num_plurals) or_break
-					if !numerus_found {
-						break
-					}
 					numerus := get_str(ts.elements[numerus_id].value[0]) or_return
 					numerus, _ = strings.intern_get(&translation.intern, numerus)
 					section[source][num_plurals] = numerus

core/text/match/strlib.odin

@@ -775,10 +775,9 @@ gsub_with :: proc(
 	haystack := haystack
 
 	for {
-		length, err := find_aux(haystack, pattern, 0, false, &captures)
+		length := find_aux(haystack, pattern, 0, false, &captures) or_break
-
 		// done
-		if length == 0 || err != .OK {
+		if length == 0 {
 			break
 		}
 

core/unicode/tools/generate_entity_table.odin

@@ -86,12 +86,9 @@ generate_encoding_entity_table :: proc() {
 
 			nth := 0
 			for {
-				character_entity, entity_ok := xml.find_child_by_ident(char, "entity", nth)
+				character_entity := xml.find_child_by_ident(char, "entity", nth) or_break
-				if !entity_ok { break }
-
 				nth += 1
-				if name, name_ok := xml.find_attribute_val_by_key(character_entity, "id"); name_ok {
+				name := xml.find_attribute_val_by_key(character_entity, "id") or_continue
-
 				if len(name) == 0 {
 					/*
 						Invalid name. Skip.
@@ -116,7 +113,7 @@ generate_encoding_entity_table :: proc() {
 					description = description,
 				}
 
-					if _, seen := entity_map[name]; seen {
+				if name in entity_map {
 					continue
 				}
 
@@ -126,7 +123,6 @@ generate_encoding_entity_table :: proc() {
 			}
 		}
 	}
-	}
 
 	/*
 		Sort by name.