Reduced nesting level of branches in njs_string_replace_regexp().

No functional changes.

diff --git a/njs/njs_string.c b/njs/njs_string.c
index 21973b9585e5647b92a54f76eda774ac9dd0014a..ba4358c8a8af0dc47653c5d6f8e89785d0ea188e 100644 (file)
--- a/njs/njs_string.c
+++ b/njs/njs_string.c
@@ -3092,95 +3092,96 @@ njs_string_replace_regexp(njs_vm_t *vm, njs_value_t *args,
                                r->part[0].start, r->part[0].size,
                                r->match_data);
 
-        if (ret >= 0) {
-            captures = nxt_regex_captures(r->match_data);
+        if (ret < 0) {
+            if (nxt_slow_path(ret != NXT_REGEX_NOMATCH)) {
+                return NXT_ERROR;
+            }
 
-            if (r->substitutions != NULL) {
-                ret = njs_string_replace_substitute(vm, r, captures);
-                if (nxt_slow_path(ret != NXT_OK)) {
-                    return ret;
-                }
+            break;
+        }
 
-                if (!pattern->global) {
-                    return njs_string_replace_regexp_join(vm, r);
-                }
+        captures = nxt_regex_captures(r->match_data);
 
-            } else {
-                if (r->part != r->parts.start) {
-                    r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
-                                            vm->mem_pool);
-                    if (nxt_slow_path(r->part == NULL)) {
-                        return NXT_ERROR;
-                    }
-
-                    r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
-                                            vm->mem_pool);
-                    if (nxt_slow_path(r->part == NULL)) {
-                        return NXT_ERROR;
-                    }
+        if (r->substitutions != NULL) {
+            ret = njs_string_replace_substitute(vm, r, captures);
+            if (nxt_slow_path(ret != NXT_OK)) {
+                return ret;
+            }
 
-                    r->part -= 2;
-                }
+            if (!pattern->global) {
+                return njs_string_replace_regexp_join(vm, r);
+            }
 
-                if (captures[1] == 0) {
+            continue;
+        }
 
-                    /* Empty match. */
+        if (r->part != r->parts.start) {
+            r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
+                                    vm->mem_pool);
+            if (nxt_slow_path(r->part == NULL)) {
+                return NXT_ERROR;
+            }
 
-                    start = r->part[0].start;
+            r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
+                                    vm->mem_pool);
+            if (nxt_slow_path(r->part == NULL)) {
+                return NXT_ERROR;
+            }
 
-                    if (start < end) {
-                        p = (u_char *) nxt_utf8_next(start, end);
+            r->part -= 2;
+        }
 
-                        r->part[1].start = start;
-                        r->part[1].size = p - start;
+        if (captures[1] == 0) {
 
-                        r->part[2].start = p;
-                        r->part[2].size = end - p;
+            /* Empty match. */
 
-                    } else {
-                        r->part[1].size = 0;
-                        r->part[2].size = 0;
+            start = r->part[0].start;
 
-                        /* To exit the loop. */
-                        r->part[2].start = start + 1;
-                    }
+            if (start < end) {
+                p = (u_char *) nxt_utf8_next(start, end);
 
-                    if (r->function != NULL) {
-                        return njs_string_replace_regexp_function(vm, args, r,
-                                                                 captures, ret);
-                    }
+                r->part[1].start = start;
+                r->part[1].size = p - start;
 
-                    r->part[0] = replace;
+                r->part[2].start = p;
+                r->part[2].size = end - p;
 
-                } else {
-                    r->part[2].start = r->part[0].start + captures[1];
-                    r->part[2].size = r->part[0].size - captures[1];
-                    njs_set_invalid(&r->part[2].value);
+            } else {
+                r->part[1].size = 0;
+                r->part[2].size = 0;
 
-                    if (r->function != NULL) {
-                        return njs_string_replace_regexp_function(vm, args, r,
-                                                                 captures, ret);
-                    }
+                /* To exit the loop. */
+                r->part[2].start = start + 1;
+            }
 
-                    r->part[0].size = captures[0];
+            if (r->function != NULL) {
+                return njs_string_replace_regexp_function(vm, args, r,
+                                                          captures, ret);
+            }
 
-                    r->part[1] = replace;
-                }
+            r->part[0] = replace;
 
-                if (!pattern->global) {
-                    return njs_string_replace_regexp_join(vm, r);
-                }
+        } else {
+            r->part[2].start = r->part[0].start + captures[1];
+            r->part[2].size = r->part[0].size - captures[1];
+            njs_set_invalid(&r->part[2].value);
 
-                r->part += 2;
+            if (r->function != NULL) {
+                return njs_string_replace_regexp_function(vm, args, r,
+                                                          captures, ret);
             }
 
-        } else if (ret == NXT_REGEX_NOMATCH) {
-            break;
+            r->part[0].size = captures[0];
 
-        } else {
-            return NXT_ERROR;
+            r->part[1] = replace;
         }
 
+        if (!pattern->global) {
+            return njs_string_replace_regexp_join(vm, r);
+        }
+
+        r->part += 2;
+
     } while (r->part[0].start <= end);
 
     if (r->part != r->parts.start) {