Bibliography - a comma separating author(s) from titles

Question

I am compiling a bibliography in a book by means of bibtex using plain.bst style (or rather its Polish version plplain.bst). Using answers to other questions on similar problems, I have modified plplain.bst so as to change the default order of names and surnames, and now an exemplary entry from my bibliography looks like this:

However, I do not know how to convince bibtex to put a comma after the name's initial (and before the title) to have something like the following:

[10] Surname, N., The title

and similarly in case of more than one author or more than one-letter initials. I tried tinkering with bst file, yet with no success. Currently, the part of the file responsible for names syntax looks like this:

FUNCTION {format.names}
{ 's :=
#1 'nameptr :=
s num.names$ 'numnames :=
    numnames 'namesleft :=
{ namesleft #0 > }
{ s nameptr "{vv }{ll}{, jj}{, f.}" format.name$ 't :=
  nameptr #1 >
{ numnames #2 =
    { ", " * }
    'skip$
 if$
     namesleft #1 >
    { ", " * t * }
    { numnames #2 >
    { "," * }
    'skip$
      if$
      t "others" =
            { " i~in." * }
            { " " * t * }
          if$
    }
  if$
}
't
  if$
  nameptr #1 + 'nameptr :=
  namesleft #1 - 'namesleft :=
}   
while$ }

I would be grateful if you could explain to me how to achieve what I want.

Following Guido's answer and my problems with implementation of his solution I thought I could add code of those fragments of bst file to which he refers.

FUNCTION {format.authors}
{ author empty$
{ "" }
{ author format.names }
if$
 }

FUNCTION {output.nonnull}
{ 's :=
    output.state mid.sentence =
    { ", " * write$ }
    { output.state after.block =
    { add.period$ write$
      newline$
      "\newblock " write$
    }
    { output.state before.all =
        'write$
        { add.period$ " " * write$ }
      if$
    }
      if$
      mid.sentence 'output.state :=
    }
  if$
  s
}

FUNCTION {output.check}
{ 't :=
  duplicate$ empty$
    { pop$ "empty " t * " in " * cite$ * warning$ }
    'output.nonnull
  if$
}

I probably misunderstood something from Guido's answer, so it would be great if you could help me to get it straight.

Answer 1

The punctuation sign after the name is determined by the function output.check that, in case the name is not empty calls the function output.nonnull. Shortly, output.nonnull prints a comma if we are in the middle of a sentence, or a period or a space. The style uses the variable output.state to store if we are in the middle of a sentence or elsewhere. Thus, one has to set that value while formatting a name. To achieve this we can insert such an assignment at the end of the function (followed by swap$ to keep the formatting of the name in the stack )

mid.sentence 'output.state :=
swap$

Thus the function now is:

FUNCTION {format.names}
{ 's :=
#1 'nameptr :=
s num.names$ 'numnames :=
    numnames 'namesleft :=
{ namesleft #0 > }
{ s nameptr "{vv }{ll}{, jj}{, f.}" format.name$ 't :=
  nameptr #1 >
{ numnames #2 =
    { ", " * }
    'skip$
 if$
     namesleft #1 >
    { ", " * t * }
    { numnames #2 >
    { "," * }
    'skip$
      if$
      t "others" =
            { " i~in." * }
            { " " * t * }
          if$
    }
  if$
}
't
  if$
  nameptr #1 + 'nameptr :=
  namesleft #1 - 'namesleft :=
  mid.sentence 'output.state :=
  swap$
}
while$ }

Notice, this will affect all the names (authors and editors). In case one wants to insert the comma only after the authors and not the editors, one can modify the format.authors function as follows:

FUNCTION {format.authors}
{ author empty$
    { "" }
    { author format.names
    mid.sentence 'output.state :=
    swap$
    }
  if$
}

A problem with the solution above is that different entry types use either output.check or output.nonnull (or output). The issue is that output.check and output.nonnull have different inputs, thus one has to change "<authors>" output.check to output.nonnull, also this requires more work for the editors.

Another alternative is to change the function that actually prints the comma (new.block). Thus we can create a my.new.block function with the following definition:

FUNCTION {my.new.block}
{ duplicate$ empty$
    { skip$ }
    {
     ", " * }
  if$
  before.all 'output.state :=
  new.block
}

and replace the first occurrence of new.block with my.new.block in all functions defining how the various entry types are going to be formatted.

For example, for article we get

FUNCTION {article}
{ output.bibitem
  format.authors "authors"  output.check
    my.new.block  %                    <=== was new.block 
  format.title "title" output.check
  new.block
  crossref missing$
    { journal emphasize "journal" output.check
      format.vol.num.pages output
      format.date "year" output.check
    }
    { format.article.crossref output.nonnull
      format.pages output
    }
  if$
  new.block
  note output
  fin.entry
}