0

I have a bib entry that has no year but instead I want to print n. d.

In my document the periods of the year field are deleted. How do I have to edit the .bst to display them?

Document:

\documentclass[12pt,a4paper,oneside]{scrartcl}

\usepackage[round]{natbib}
\usepackage{natbib}
\bibliographystyle{humannat-mod}


\begin{document}


\cite{LISAn.d.e}\
\citealt{LISAn.d.e}


\newpage
\bibliography{literaturverzeichnis}


\end{document}

Entry:

@Misc{LISAn.d.e,
  author       = {LISA},
  note         = {access: 11/201/2020},
  title        = {LISA-Landnutzung},
  year         = {n. d.},
}

.bst File:

ENTRY
  { address
    author
    booktitle
    chapter
    edition
    editor
    howpublished
    institution
    journal
    key
%    month      not used in apalike
    note
    number
    organization
    pages
    publisher
    school
    series
    title
    type
    volume
    year
    url
    urldate
  }
  {}
  { label extra.label sort.label }

INTEGERS { output.state before.all mid.sentence after.sentence after.block }


FUNCTION {init.state.consts}
{ #0 'before.all :=
  #1 'mid.sentence :=
  #2 'after.sentence :=
  #3 'after.block :=
}


STRINGS { s t }


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}
{ duplicate$ empty$
    'pop$
    'output.nonnull
  if$
}


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


%                   apalike needs this function because
%                   the year has special punctuation;
%                   apalike ignores the month
FUNCTION {output.year.check}
{ year empty$
    { "empty year in " cite$ * warning$ }
    { write$
      " (" year * extra.label * ")" *
%      " " year * extra.label *           % for humannature
      mid.sentence 'output.state :=
    }
  if$
}


FUNCTION {output.bibitem}
{ newline$
  "\bibitem[" write$
  label write$
  "]{" write$
  cite$ write$
  "}" write$
  newline$
  ""
  before.all 'output.state :=
}


FUNCTION {fin.entry}
{ add.period$
  write$
  newline$
}


FUNCTION {new.block}
{ output.state before.all =
    'skip$
    { after.block 'output.state := }
  if$
}


FUNCTION {new.sentence}
{ output.state after.block =
    'skip$
    { output.state before.all =
    'skip$
    { after.sentence 'output.state := }
      if$
    }
  if$
}


FUNCTION {not}
{   { #0 }
    { #1 }
  if$
}


FUNCTION {and}
{   'skip$
    { pop$ #0 }
  if$
}


FUNCTION {or}
{   { pop$ #1 }
    'skip$
  if$
}


FUNCTION {new.block.checkb}
{ empty$
  swap$ empty$
  and
    'skip$
    'new.block
  if$
}


FUNCTION {field.or.null}
{ duplicate$ empty$
    { pop$ "" }
    'skip$
  if$
}


FUNCTION {emphasize}
{ duplicate$ empty$
    { pop$ "" }
    { "{\em " swap$ * "}" * }
  if$
}


INTEGERS { nameptr namesleft numnames }


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


FUNCTION {format.authors}
{ author empty$
    { "" }
    { author format.names }
  if$
  " " *   % for humannature
}


FUNCTION {format.key}           % this function is just for apalike
{ empty$
    { key field.or.null }
    { "" }
  if$
}


FUNCTION {format.editors}
{ editor empty$
    { "" }
    { author empty$
        { editor format.names }
        { editor format.editor.names }
      if$
      editor num.names$ #1 >
    { " (eds.)" * }         % for humannature
    { " (ed.)" * }          % for humannature
      if$
    }
  if$
  author empty$
    { " " * }
    { "" * }
  if$
}


FUNCTION {format.title}
{
%    title empty$
%    { "" }
%    { title "t" change.case$ }
%    if$
title
}


FUNCTION {n.dashify}
{ 't :=
  ""
    { t empty$ not }
    { t #1 #1 substring$ "-" =
    { t #1 #2 substring$ "--" = not
        { "--" *
          t #2 global.max$ substring$ 't :=
        }
        {   { t #1 #1 substring$ "-" = }
        { "-" *
          t #2 global.max$ substring$ 't :=
        }
          while$
        }
      if$
    }
    { t #1 #1 substring$ *
      t #2 global.max$ substring$ 't :=
    }
      if$
    }
  while$
}


FUNCTION {format.btitle}
{ title emphasize
}


FUNCTION {tie.or.space.connect}
{ duplicate$ text.length$ #3 <
    { "~" }
    { " " }
  if$
  swap$ * *
}


FUNCTION {either.or.check}
{ empty$
    'pop$
    { "can't use both " swap$ * " fields in " * cite$ * warning$ }
  if$
}


FUNCTION {format.bvolume}
{ volume empty$
    { "" }
    { "volume" volume tie.or.space.connect
      series empty$
    'skip$
    { " of " * series emphasize * }
      if$
      "volume and number" number either.or.check
    }
  if$
}


FUNCTION {format.number.series}
{ volume empty$
    { number empty$
    { series field.or.null }
    { output.state mid.sentence =
        { "number" }
        { "Number" }
      if$
      number tie.or.space.connect
      series empty$
        { "there's a number but no series in " cite$ * warning$ }
        { " in " * series * }
      if$
    }
      if$
    }
    { "" }
  if$
}


FUNCTION {format.address.publisher}
{
address
%address empty$
%    {
%      publisher empty$
%        { "" }
%        { publisher }
%      if$
%    }
%    {
%      publisher empty$
%        { address ": [publisher unknown]" * }
%        { address ": " * publisher * }
%      if$
%    }
%  if$
}


FUNCTION {format.edition}
{ 
edition
}


INTEGERS { multiresult }


FUNCTION {multi.page.check}
{ 't :=
  #0 'multiresult :=
    { multiresult not
      t empty$ not
      and
    }
    { t #1 #1 substring$
      duplicate$ "-" =
      swap$ duplicate$ "," =
      swap$ "+" =
      or or
    { #1 'multiresult := }
    { t #2 global.max$ substring$ 't := }
      if$
    }
  while$
  multiresult
}


FUNCTION {format.pages}
{ pages empty$
    { "" }
    { pages multi.page.check
    { "pp.~" pages n.dashify tie.or.space.connect }
    { "p.~" pages tie.or.space.connect }
      if$
    }
  if$
}


FUNCTION {format.vol.num.pages}
{ volume field.or.null
  number empty$
    'skip$
    { "(" number * ")" * *
      volume empty$
    { "there's a number but no volume in " cite$ * warning$ }
    'skip$
      if$
    }
  if$
  pages empty$
    'skip$
    { duplicate$ empty$
    { pop$ format.pages }
    { ": " * pages n.dashify * }
      if$
    }
  if$
}


FUNCTION {format.chapter.pages}
{ chapter empty$
    'format.pages
    { type empty$
    { "chapter" }
    { type "l" change.case$ }
      if$
      chapter tie.or.space.connect
      pages empty$
    'skip$
    { ", " * format.pages * }
      if$
    }
  if$
}


FUNCTION {format.in.ed.booktitle}
{ booktitle empty$
    { "" }
    { editor empty$
    { "In " booktitle emphasize * }
    { "In " booktitle emphasize * ", " * format.editors * }
      if$
    }
  if$
}


FUNCTION {format.thesis.type}
{ type empty$
    'skip$
    { pop$
      type "t" change.case$
    }
  if$
}


FUNCTION {format.tr.number}
{ type empty$
    { "Technical Report" }
    'type
  if$
  number empty$
    { "t" change.case$ }
    { number tie.or.space.connect }
  if$
}


FUNCTION {format.url}
{ url empty$
   { "" }
   { new.block "URL: \url{" url * "}" * 
        urldate empty$
         { "" }
         { new.block  "(Accessed on: " urldate * ")" * }
         if$
    }
   if$
}


FUNCTION {format.article.crossref}
{ "In"                          % this is for apalike
  " \cite{" * crossref * "}" *
}


FUNCTION {format.book.crossref}
{ volume empty$
    { "empty volume in " cite$ * "'s crossref of " * crossref * warning$
      "In "
    }
    { "Volume" volume tie.or.space.connect
      " of " *
    }
  if$
  "\cite{" * crossref * "}" *               % this is for apalike
}


FUNCTION {format.incoll.inproc.crossref}
{ "In"                          % this is for apalike
  " \cite{" * crossref * "}" *
}


FUNCTION {article}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  crossref missing$
    { journal emphasize "journal" output.check
      format.vol.num.pages output
    }
    { format.article.crossref output.nonnull
      format.pages output
    }
  if$
  format.url output
  new.block
  note output
  fin.entry
}


FUNCTION {book}
{ output.bibitem
  author empty$
    { format.editors "author and editor" output.check
      editor format.key output
    }
    { format.authors output.nonnull
      crossref missing$
    { "author and editor" editor either.or.check }
    'skip$
      if$
    }
  if$
  output.year.check             % special for apalike
  new.block
  format.btitle "title" output.check
  crossref missing$
    { format.bvolume output
      format.number.series output
      format.edition output
      new.block
      format.address.publisher output
    }
    { new.block
      format.book.crossref output.nonnull
    }
  if$
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {booklet}
{ output.bibitem
  format.authors output
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  howpublished output
  address output
  new.block
  note output
  format.url output
  fin.entry
}


FUNCTION {inbook}
{ output.bibitem
  author empty$
    { format.editors "author and editor" output.check
      editor format.key output
    }
    { format.authors output.nonnull
      crossref missing$
    { "author and editor" editor either.or.check }
    'skip$
      if$
    }
  if$
  output.year.check             % special for apalike
  new.block
  chapter output
  new.block %Lukas
  "In: " 
  format.editors * output
  format.btitle "title" output.check
  format.edition output
  new.block
  address output
  format.pages output
  fin.entry
}


FUNCTION {incollection}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  crossref missing$
    { format.in.ed.booktitle "booktitle" output.check
      format.bvolume output
      format.number.series output
      format.chapter.pages output
      new.block
      format.address.publisher output
    }
    { format.incoll.inproc.crossref output.nonnull
      format.chapter.pages output
    }
  if$
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {inproceedings}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  crossref missing$
    { format.in.ed.booktitle "booktitle" output.check
      format.bvolume output
      format.number.series output
      format.pages output
      address output                    % for apalike
      new.sentence                  % there's no year
      organization output               % here so things
      publisher output                  % are simpler
    }
    { format.incoll.inproc.crossref output.nonnull
      format.pages output
    }
  if$
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {conference} { inproceedings }


FUNCTION {manual}
{ output.bibitem
  format.authors output
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.btitle "title" output.check
  organization address new.block.checkb
  organization output
  address output
  format.edition output
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {mastersthesis}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  "Master's thesis" format.thesis.type output.nonnull
  school "school" output.check
  address output
  new.block
  note output
  format.url "" output
  fin.entry
}


FUNCTION {misc}
{ output.bibitem
  format.authors output
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "t" output.check

  new.block
  howpublished output
  new.block
  note output
  format.url output.check
  fin.entry
}


FUNCTION {phdthesis}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.btitle "title" output.check
  new.block
  "PhD thesis" format.thesis.type output.nonnull
  school "school" output.check
  address output
  new.block
  note output
  format.url output
  fin.entry
}


FUNCTION {proceedings}
{ output.bibitem
  format.editors output
  editor format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.btitle "title" output.check
  format.bvolume output
  format.number.series output
  address output                % for apalike
  new.sentence                  % we always output
  organization output               % a nonempty organization
  publisher output              % here
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {techreport}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  format.tr.number output.nonnull
  institution "institution" output.check
  address output
  new.block
  format.url output
  note output
  fin.entry
}


FUNCTION {unpublished}
{ output.bibitem
  format.authors "author" output.check
  author format.key output              % special for
  output.year.check                 % apalike
  new.block
  format.title "title" output.check
  new.block
  format.url output
  note "note" output.check
  fin.entry
}


FUNCTION {default.type} { misc }


MACRO {jan} {"January"}


MACRO {feb} {"February"}


MACRO {mar} {"March"}


MACRO {apr} {"April"}


MACRO {may} {"May"}


MACRO {jun} {"June"}


MACRO {jul} {"July"}


MACRO {aug} {"August"}


MACRO {sep} {"September"}


MACRO {oct} {"October"}


MACRO {nov} {"November"}


MACRO {dec} {"December"}


MACRO {acmcs} {"ACM Computing Surveys"}


MACRO {acta} {"Acta Informatica"}


MACRO {cacm} {"Communications of the ACM"}


MACRO {ibmjrd} {"IBM Journal of Research and Development"}


MACRO {ibmsj} {"IBM Systems Journal"}


MACRO {ieeese} {"IEEE Transactions on Software Engineering"}


MACRO {ieeetc} {"IEEE Transactions on Computers"}


MACRO {ieeetcad}
 {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"}


MACRO {ipl} {"Information Processing Letters"}


MACRO {jacm} {"Journal of the ACM"}


MACRO {jcss} {"Journal of Computer and System Sciences"}


MACRO {scp} {"Science of Computer Programming"}


MACRO {sicomp} {"SIAM Journal on Computing"}


MACRO {tocs} {"ACM Transactions on Computer Systems"}


MACRO {tods} {"ACM Transactions on Database Systems"}


MACRO {tog} {"ACM Transactions on Graphics"}


MACRO {toms} {"ACM Transactions on Mathematical Software"}


MACRO {toois} {"ACM Transactions on Office Information Systems"}


MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"}


MACRO {tcs} {"Theoretical Computer Science"}


READ


FUNCTION {sortify}
{ purify$
  "l" change.case$
}


INTEGERS { len }


FUNCTION {chop.word}
{ 's :=
  'len :=
  s #1 len substring$ =
    { s len #1 + global.max$ substring$ }
    's
  if$
}


%           There are three apalike cases: one person (Jones),
%           two (Jones and de~Bruijn), and more (Jones et~al.).
%           This function is much like format.crossref.editors.
%
FUNCTION {format.lab.names}
{ 's :=
  s #1 "{vv~}{ll}" format.name$
  s num.names$ duplicate$
  #2 >
    { pop$ " et~al." * }
    { #2 <
    'skip$
    { s #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =
        { " et~al." * }
        { " and " * s #2 "{vv~}{ll}" format.name$ * }
      if$
    }
      if$
    }
  if$
}


FUNCTION {author.key.label}
{ author empty$
    { key empty$
    { cite$ #1 #3 substring$ }
    'key                    % apalike uses the whole key
      if$
    }
    { author format.lab.names }
  if$
}


FUNCTION {author.editor.key.label}
{ author empty$
    { editor empty$
    { key empty$
        { cite$ #1 #3 substring$ }
        'key                % apalike uses the whole key
      if$
    }
    { editor format.lab.names }
      if$
    }
    { author format.lab.names }
  if$
}


FUNCTION {editor.key.label}
{ editor empty$
    { key empty$
    { cite$ #1 #3 substring$ }
    'key            % apalike uses the whole key, no organization
      if$
    }
    { editor format.lab.names }
  if$
}


FUNCTION {calc.label}      % this function came from ASTRON.BST (ARR)
{ type$ "book" =
  type$ "inbook" =
  or
    'author.editor.key.label
    { type$ "proceedings" =
        'editor.key.label                       % apalike ignores organization
        'author.key.label                       % for labeling and sorting
      if$
    }
  if$
  "\protect\astroncite{" swap$ * "}{"                   % these three lines are


    

  •                                                 % for apalike, which

    

    • 



year field.or.null purify$                            % uses all four digits but doesn't truncate


    

  •                   % the mathing closing &quot;}&quot; comes in at the reverse.pass

    

    • 



'label :=
}


FUNCTION {sort.format.names}
{ 's :=
  #1 'nameptr :=
  ""
  s num.names$ 'numnames :=
  numnames 'namesleft :=
    { namesleft #0 > }
    { nameptr #1 >
    { "   " * }
    'skip$
      if$                       % apalike uses initials
      s nameptr "{vv{ } }{ll{ }}{  f{ }}{  jj{ }}" format.name$ 't := % <= here
      nameptr numnames = t "others" = and
    { "et al" * }
    { t sortify * }
      if$
      nameptr #1 + 'nameptr :=
      namesleft #1 - 'namesleft :=
    }
  while$
}


FUNCTION {sort.format.title}
{ 't :=
  "A " #2
    "An " #3
      "The " #4 t chop.word
    chop.word
  chop.word
  sortify
  #1 global.max$ substring$
}


FUNCTION {author.sort}
{ author empty$
    { key empty$
    { "to sort, need author or key in " cite$ * warning$
      ""
    }
    { key sortify }
      if$
    }
    { author sort.format.names }
  if$
}


FUNCTION {author.editor.sort}
{ author empty$
    { editor empty$
    { key empty$
        { "to sort, need author, editor, or key in " cite$ * warning$
          ""
        }
        { key sortify }
      if$
    }
    { editor sort.format.names }
      if$
    }
    { author sort.format.names }
  if$
}


FUNCTION {editor.sort}
{ editor empty$
    { key empty$
    { "to sort, need editor or key in " cite$ * warning$
      ""
    }
    { key sortify }
      if$
    }
    { editor sort.format.names }
  if$
}


%           apalike uses two sorting passes; the first one sets the
%           labels so that the a's,b's, etc. can be computed;
%           the second pass puts the references in "correct" order.
%           The presort function is for the first pass. It computes
%           label, sort.label, and title, and then concatenates.
FUNCTION {presort}
{ calc.label
  label sortify
  "    "


    

  • 



type$ "book" =
  type$ "inbook" =
  or
    'author.editor.sort
    { type$ "proceedings" =
    'editor.sort
    'author.sort
      if$
    }
  if$
  #1 entry.max$ substring$  % for
  'sort.label :=        % apalike
  sort.label            % style


    

  • 



"    "


    

  • 



title field.or.null
  sort.format.title


    

  • 



#1 entry.max$ substring$
  'sort.key$ :=
}


ITERATE {presort}


SORT        % by label, sort.label, title---for final label calculation


STRINGS { last.label next.extra }   % apalike labels are only for the text;


INTEGERS { last.extra.num }     % there are none in the bibliography


FUNCTION {initialize.extra.label.stuff} % and hence there is no `longest.label'
{ #0 int.to.chr$ 'last.label :=
  "" 'next.extra :=
  #0 'last.extra.num :=
}


FUNCTION {forward.pass}
{ last.label label =
    { last.extra.num #1 + 'last.extra.num :=
      last.extra.num int.to.chr$ 'extra.label :=
    }
    { "a" chr.to.int$ 'last.extra.num :=
      "" 'extra.label :=
      label 'last.label :=
    }
  if$
}


FUNCTION {reverse.pass}       % this function came from ASTRON.BST (ARR)
{ next.extra "b" =
    { "a" 'extra.label := }
    'skip$
  if$
  label extra.label * "}" * 'label :=
  extra.label 'next.extra :=
}


EXECUTE {initialize.extra.label.stuff}


ITERATE {forward.pass}


REVERSE {reverse.pass}


%               Now that the label is right we sort for real,
%               on sort.label then year then title.  This is
%               for the second sorting pass.
FUNCTION {bib.sort.order}
{ sort.label
  "    "


    

  • 



year field.or.null sortify


    

  • 



"    "


    

  • 



title field.or.null
  sort.format.title


    

  • 



#1 entry.max$ substring$
  'sort.key$ :=
}


ITERATE {bib.sort.order}


SORT        % by sort.label, year, title---giving final bibliography order


FUNCTION {begin.bib}
{ preamble$ empty$              % no \etalchar in apalike
    'skip$
    { preamble$ write$ newline$ }
  if$
  "\begin{thebibliography}{}" write$ newline$       % no labels in apalike
}


EXECUTE {begin.bib}


EXECUTE {init.state.consts}


ITERATE {call.type$}


FUNCTION {end.bib}
{ newline$
  "\end{thebibliography}" write$ newline$
}


EXECUTE {end.bib}
Lukas
  • 27
  • What happens if you do year = {{n. d.}} instead? Perhaps the year field is parsed or something like that? In that case, the braces group might stop the parsing from looking into that piece of text. – Vincent Kuhlmann May 19 '21 at 08:27
  • @VincentKuhlmann unfortunately not – Lukas May 21 '21 at 11:23

1 Answers1

0

I deleted the purify$ call in the calc.label function:

FUNCTION {calc.label}      % this function came from ASTRON.BST (ARR)
{ type$ "book" =
  type$ "inbook" =
  or
    'author.editor.key.label
    { type$ "proceedings" =
        'editor.key.label                       % apalike ignores organization
        'author.key.label                       % for labeling and sorting
      if$
    }
  if$
  "\protect\astroncite{" swap$ * "}{"                   % these three lines are
  *                                                     % for apalike, which
  year field.or.null                                    % uses all four digits but doesn't truncate
  *                       % the mathing closing "}" comes in at the reverse.pass
  'label :=
}

I don't know what implications that has for my other bib entries but it solves the problem with the deleted periods. Feel free to tell me why this might be a bad idea or post a better answer :)

Lukas
  • 27
  • A good you found a solution! I had never seen bst files before, so I am familiarizing myself with them now. I guess you are still open to my research in this matter? Because purify is supposed to be only done for things like sorting. Perhaps this is a hacky solution which could entail problems for later – Vincent Kuhlmann May 21 '21 at 17:46
  • Also, for me it's not on line 1028. When compiling I'm experiencing an error 1142 (I think that's still the line number of your MWE). Have you solved that, or is it my installation version acting different from yours? – Vincent Kuhlmann May 21 '21 at 18:07
  • Yes I deleted some comments in my project .bst file so that I could post it here and not exceed stackexchange's character limit per question. It is more like around 950ish, therefore I explained which place the changes would be (calc.label function). – Lukas May 22 '21 at 19:00
  • And I also have presumably your problem: I get multiple error messages 'You can't pop an empty literal stack for entry [...]' around your line 1142. Couldn't find anything that immediately fixed it and since it seems to cause no problems I simply ignored it. – Lukas May 22 '21 at 19:05
  • Before I asked this question I tried things I found on other questions like https://tex.stackexchange.com/questions/101171/biblatex-and-entries-with-no-date, but it didn't work. Just right now I found https://tex.stackexchange.com/questions/597189/references-with-n-d-no-date-using-natbib-with-apalike which seems like exactly the same problem. This question should probably then be marked as a duplicate, although I don't know how to do that. – Lukas May 22 '21 at 19:08
  • And the answer over there solves your problem too? – Vincent Kuhlmann May 22 '21 at 19:17
  • Its the same thing I did – Lukas May 23 '21 at 20:26