diff --git a/CHANGELOG.md b/CHANGELOG.md
index a85ff9edcf..4c7127137e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,12 +5,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
 ## [Unreleased]
 
 ### Fixed
+* fix: `prepareCall` accepts a `{call ...}` or `{? = call ...}` escape with a quote inside a comment, a quoted identifier, or a dollar-quoted string, such as `{call f() /* it's */}`. Such a call failed with `Malformed function or procedure escape syntax at offset N.` (SQLState `2F003`) for either value of `standard_conforming_strings`, and with `standard_conforming_strings=off` a backslash at the end of the text threw `StringIndexOutOfBoundsException` instead [PR #4521](https://github.com/pgjdbc/pgjdbc/pull/4521)
+* fix: a `?` inside an `E'...'` string that also contains a doubled quote, such as `E'it''s \'?'` with `standard_conforming_strings=on`, is no longer taken for a parameter placeholder, and a `{fn ...}` escape inside such a string is no longer rewritten [PR #4521](https://github.com/pgjdbc/pgjdbc/pull/4521)
 * fix: `GSSInputStream.available()` now returns the number of decrypted bytes the stream holds and has not returned yet, instead of 0. Under GSS encryption, `PGConnection.getNotifications()` and non-blocking `COPY` reads no longer set a 1 ms socket timeout to probe for data while the stream still holds decrypted bytes [PR #4383](https://github.com/pgjdbc/pgjdbc/pull/4383)
 * fix: `PGStream.skip` no longer loops forever when the connection ends while the driver is discarding bytes, and no longer mistakes a stream that skips nothing for one that has ended. `InputStream.skip` may return zero with more data still coming, which a stream supplied through the `socketFactory` property is free to do; the driver now reads a byte in that case and treats only `-1` as the end [PR #4358](https://github.com/pgjdbc/pgjdbc/pull/4358)
 * fix: `LargeObjectManager` operations now work inside an active XA transaction. Since 42.7.13 an XA branch keeps the caller's `autoCommit=true`, and the guard rejected large objects as if the connection were idle. It now checks the server transaction state (`getTransactionState()`) instead of `autoCommit`, so a genuine auto-commit connection with no open transaction is still refused [Issue #4309](https://github.com/pgjdbc/pgjdbc/issues/4309) [PR #4310](https://github.com/pgjdbc/pgjdbc/pull/4310)
 * fix: batch update counts are no longer secured as committed inside an XA transaction. `BatchResultHandler` treated per-statement progress as durable whenever `autoCommit=true`, but an XA branch keeps `autoCommit=true` while the transaction is open, so a batch that flushed mid-way and then failed could report rolled-back statements as succeeded. Progress is now secured only when no server transaction is open [Issue #4309](https://github.com/pgjdbc/pgjdbc/issues/4309) [PR #4311](https://github.com/pgjdbc/pgjdbc/pull/4311)
 
 ### Changed
+* **Breaking:** inside a `{call ...}` or `{? = call ...}` escape, a `}` after `--` on the same line is now part of the comment, as it is for PostgreSQL, so `{call f(?) -- note}` fails with `Malformed function or procedure escape syntax at offset N.` (SQLState `2F003`). End the comment with a line break before the `}`, or use `/* note */` [PR #4521](https://github.com/pgjdbc/pgjdbc/pull/4521)
 * fix: backend message lengths are checked before anything is sized from them. Each length is checked against the message layout and a limit for its type, the lengths inside `DataRow` and `FunctionCallResponse` are checked against the message, and the `NegotiateProtocolVersion` option count is bounded. A hostile or out of sync backend could previously force an allocation of up to two gigabytes with a five byte header [Issue #4015](https://github.com/pgjdbc/pgjdbc/issues/4015)
 * fix: the read buffer is limited to 32 MiB and grows once per request rather than once per socket read. It previously doubled on every read while a large request was outstanding, so a peer that declared a large length and sent it slowly grew the buffer until the doubling past 1 GiB overflowed to a negative size [Issue #4015](https://github.com/pgjdbc/pgjdbc/issues/4015)
 * fix: a zero-length `CopyData` body is accepted. It is valid on the wire and was previously rejected by an assertion, so it failed only on JVMs started with `-ea` [Issue #4015](https://github.com/pgjdbc/pgjdbc/issues/4015)
diff --git a/pgjdbc/src/main/java/org/postgresql/core/Parser.java b/pgjdbc/src/main/java/org/postgresql/core/Parser.java
index d39684910b..e3b7c79717 100644
--- a/pgjdbc/src/main/java/org/postgresql/core/Parser.java
+++ b/pgjdbc/src/main/java/org/postgresql/core/Parser.java
@@ -419,14 +419,13 @@ private static boolean addReturning(StringBuilder nativeSql, SqlCommandType curr
   /**
    * Find the end of the single-quoted string starting at the given offset.
    *
-   * <p>Note: for {@code 'single '' quote in string'}, this method currently returns the offset of
-   * first {@code '} character after the initial one. The caller must call the method a second time
-   * for the second part of the quoted string.</p>
+   * <p>A doubled quote, as in {@code 'single '' quote in string'}, is part of the string, so an
+   * {@code E'...'} string keeps its backslash escapes up to the quote that ends it.</p>
    *
    * @param query                     query
    * @param offset                    start offset
    * @param standardConformingStrings standard conforming strings
-   * @return position of the end of the single-quoted string
+   * @return position of the quote that ends the string, or {@code query.length} if no quote ends it
    */
   public static int parseSingleQuotes(final char[] query, int offset,
       boolean standardConformingStrings) {
@@ -442,7 +441,11 @@ && charTerminatesIdentifier(query[offset - 2])) {
       // do NOT treat backslashes as escape characters
       while (++offset < query.length) {
         if (query[offset] == '\'') {
-          return offset;
+          if (offset + 1 < query.length && query[offset + 1] == '\'') {
+            ++offset;
+          } else {
+            return offset;
+          }
         }
       }
     } else {
@@ -453,6 +456,10 @@ && charTerminatesIdentifier(query[offset - 2])) {
             ++offset;
             break;
           case '\'':
+            if (offset + 1 < query.length && query[offset + 1] == '\'') {
+              ++offset;
+              break;
+            }
             return offset;
           default:
             break;
@@ -1073,7 +1080,6 @@ public static JdbcCallParseInfo modifyJdbcCall(String jdbcSql, boolean stdString
     char[] jdbcSqlChars = jdbcSql.toCharArray();
     int len = jdbcSql.length();
     int state = 1;
-    boolean inQuotes = false;
     boolean inEscape = false;
     int startIndex = -1;
     int endIndex = -1;
@@ -1162,16 +1168,23 @@ public static JdbcCallParseInfo modifyJdbcCall(String jdbcSql, boolean stdString
           break;
 
         case 7:  // In "body" of the query (after "{ [? =] call ")
+          // A literal, a quoted identifier, or a comment is skipped as a whole, so a quote or a
+          // brace inside it does not count. One left open runs to the end of the text, which then
+          // fails for the missing closing brace.
           if (ch == '\'') {
-            inQuotes = !inQuotes;
-            ++i;
-          } else if (inQuotes && ch == '\\' && !stdStrings) {
-            // Backslash in string constant, skip next character.
-            i += 2;
-          } else if (!inQuotes && ch == '{') {
+            i = Math.min(parseSingleQuotes(jdbcSqlChars, i, stdStrings) + 1, len);
+          } else if (ch == '"') {
+            i = Math.min(parseDoubleQuotes(jdbcSqlChars, i) + 1, len);
+          } else if (ch == '$') {
+            i = Math.min(parseDollarQuotes(jdbcSqlChars, i) + 1, len);
+          } else if (ch == '-') {
+            i = Math.min(parseLineComment(jdbcSqlChars, i) + 1, len);
+          } else if (ch == '/') {
+            i = Math.min(parseBlockComment(jdbcSqlChars, i) + 1, len);
+          } else if (ch == '{') {
             inEscape = !inEscape;
             ++i;
-          } else if (!inQuotes && ch == '}') {
+          } else if (ch == '}') {
             if (!inEscape) {
               // Should be end of string.
               endIndex = i;
@@ -1180,7 +1193,7 @@ public static JdbcCallParseInfo modifyJdbcCall(String jdbcSql, boolean stdString
             } else {
               inEscape = false;
             }
-          } else if (!inQuotes && ch == ';') {
+          } else if (ch == ';') {
             syntaxError = true;
           } else {
             // Everything else is ok.
diff --git a/pgjdbc/src/test/java/org/postgresql/core/ParserTest.java b/pgjdbc/src/test/java/org/postgresql/core/ParserTest.java
index fdca32526a..356c84def2 100644
--- a/pgjdbc/src/test/java/org/postgresql/core/ParserTest.java
+++ b/pgjdbc/src/test/java/org/postgresql/core/ParserTest.java
@@ -10,6 +10,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 import org.postgresql.jdbc.EscapeSyntaxCallMode;
 import org.postgresql.util.PSQLException;
@@ -18,10 +19,13 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.sql.SQLException;
 import java.util.List;
+import java.util.stream.Stream;
 
 /**
  * Test cases for the Parser.
@@ -230,6 +234,114 @@ void modifyJdbcCallToleratesTrailingComment() throws SQLException {
         ServerVersion.v11.getVersionNum(), EscapeSyntaxCallMode.CALL));
   }
 
+  static Stream<Arguments> callBodiesWithQuotesAndBracesInsideTokens() {
+    return Stream.of(
+        arguments("{call f() /* it's */}", true, "call f() /* it's */"),
+        arguments("{call f() /* it's */}", false, "call f() /* it's */"),
+        arguments("{call f() -- it's\n}", true, "call f() -- it's\n"),
+        arguments("{call f() -- it's\n}", false, "call f() -- it's\n"),
+        arguments("{call f(/* } */)}", true, "call f(/* } */)"),
+        arguments("{call f(/* } */)}", false, "call f(/* } */)"),
+        arguments("{call \"it's\"()}", true, "call \"it's\"()"),
+        arguments("{call \"it's\"()}", false, "call \"it's\"()"),
+        arguments("{call f($$it's$$)}", true, "call f($$it's$$)"),
+        arguments("{call f($$it's$$)}", false, "call f($$it's$$)"),
+        arguments("{call f(E'\\'')}", true, "call f(E'\\'')"),
+        arguments("{call f(E'\\'')}", false, "call f(E'\\'')"),
+        arguments("{call f(E'\\'a''b\\'c')}", true, "call f(E'\\'a''b\\'c')"),
+        arguments("{call f(E'\\'a''b\\'c')}", false, "call f(E'\\'a''b\\'c')"),
+        arguments("{call f('it''s /* -- }')}", true, "call f('it''s /* -- }')"),
+        arguments("{call f('it''s /* -- }')}", false, "call f('it''s /* -- }')"),
+        arguments("{call f('a' '}')}", true, "call f('a' '}')"),
+        arguments("{call f('a' '}')}", false, "call f('a' '}')"),
+        arguments("{call f('a\\')}", true, "call f('a\\')"),
+        arguments("{call f('\\'')}", false, "call f('\\'')"),
+        arguments("{call f(1-2, 4/2, $1, a$b)}", true, "call f(1-2, 4/2, $1, a$b)"),
+        arguments("{call f(1-2, 4/2, $1, a$b)}", false, "call f(1-2, 4/2, $1, a$b)"),
+        arguments("{? = call f(/* it's */ ?)}", true, "call f(?,/* it's */ ?)"),
+        arguments("{? = call f(/* it's */ ?)}", false, "call f(?,/* it's */ ?)")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("callBodiesWithQuotesAndBracesInsideTokens")
+  void callBodyIgnoresQuotesAndBracesInsideCommentsAndQuotedText(String sql, boolean stdStrings,
+      String expected) throws SQLException {
+    assertEquals(expected, Parser.modifyJdbcCall(sql, stdStrings, ServerVersion.v11.getVersionNum(),
+        EscapeSyntaxCallMode.CALL).getSql());
+  }
+
+  static Stream<Arguments> callBodiesWithoutClosingBrace() {
+    return Stream.of(
+        arguments("{call f() /* }", true),
+        arguments("{call f() /* }", false),
+        arguments("{call f() -- }", true),
+        arguments("{call f() -- }", false),
+        arguments("{call f() -- '\\", true),
+        arguments("{call f() -- '\\", false),
+        arguments("{call f('it''s}", true),
+        arguments("{call f('it''s}", false),
+        arguments("{call f('a\\", true),
+        arguments("{call f('a\\", false),
+        arguments("{?=call f('a\\", true),
+        arguments("{?=call f('a\\", false),
+        arguments("{call f('\\", true),
+        arguments("{call f('\\", false),
+        arguments("{call f('a\\')}", false),
+        arguments("{call \"it's}", true),
+        arguments("{call \"it's}", false),
+        arguments("{call \"it's\"() \\", true),
+        arguments("{call \"it's\"() \\", false),
+        arguments("{call f($$it's})", true),
+        arguments("{call f($$it's})", false),
+        arguments("{call f($$it's$$) \\", true),
+        arguments("{call f($$it's$$) \\", false)
+    );
+  }
+
+  /**
+   * A call escape is rejected at the offset of the end of the text when no closing brace stands
+   * outside a comment, string constant, quoted identifier, or dollar quote. A {@code --} comment runs
+   * to the end of the line, so a closing brace on that line belongs to the comment.
+   */
+  @ParameterizedTest
+  @MethodSource("callBodiesWithoutClosingBrace")
+  void callBodyWithoutClosingBraceIsRejected(String sql, boolean stdStrings) {
+    PSQLException e = assertThrows(PSQLException.class, () -> Parser.modifyJdbcCall(sql, stdStrings,
+        ServerVersion.v11.getVersionNum(), EscapeSyntaxCallMode.CALL));
+    assertEquals(PSQLState.STATEMENT_NOT_ALLOWED_IN_FUNCTION_CALL.getState(), e.getSQLState());
+    assertTrue(e.getMessage().contains(Integer.toString(sql.length())),
+        () -> "the message should report offset " + sql.length() + ": " + e.getMessage());
+  }
+
+  static Stream<Arguments> placeholdersAroundEscapeStrings() {
+    return Stream.of(
+        arguments("select E'a''b\\'?'", 0),
+        arguments("select 'a''b', ?", 1)
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("placeholdersAroundEscapeStrings")
+  void questionMarkInsideAnEscapeStringIsNotAPlaceholder(String sql, int bindCount)
+      throws SQLException {
+    List<NativeQuery> queries = Parser.parseJdbcSql(sql, true, true, true, false, true);
+    assertEquals(bindCount, queries.get(0).bindPositions.length);
+  }
+
+  static Stream<Arguments> escapesAroundEscapeStrings() {
+    return Stream.of(
+        arguments("select E'a''b\\' {fn now()} '", "select E'a''b\\' {fn now()} '"),
+        arguments("select 'a''b' || {fn now()}", "select 'a''b' || now()")
+    );
+  }
+
+  @ParameterizedTest
+  @MethodSource("escapesAroundEscapeStrings")
+  void escapeInsideAnEscapeStringIsNotReplaced(String sql, String expected) throws SQLException {
+    assertEquals(expected, Parser.replaceProcessing(sql, true, true));
+  }
+
   /**
    * A {@code CALL} (or {@code { ? = call ... }} escape) preceded by a comment must still be
    * recognised as a function call, otherwise OUT parameter registration fails. See issue #2538.
