Laboratoire de l'Informatique et du Parallélisme » XLcloud

%% This is file `wileyj.bst',

%% Created by Sunrise Setting Ltd, Torquay, UK, www.sunrise-setting.co.uk

%% Version 1.00, 21 September 2007

%%

%% The original source files were:

%%

%% merlin.mbs  (with options: `seq-no,nm-rvx,ed-rev,jnrlst,nmlm,x10,x0,m10,m0,dt-jnl,yr-com,yrp-semi,thtit-a,trnum-it,vol-bf,pgsep-s,pp-last,num-xser,numser,ser-vol,ser-ed,jnm-x,bkpg-x,pub-date,pub-xpar,pre-edn,doi,edpar,edby,edbyx,blk-tit,blknt,in-x,ppx,ed,abr,mth-bare,xedn,varand,and-xcom,xand,etal-xc,etal-it,url,url-nt,nfss,')

%% ----------------------------------------

%% *** wileyj.bst ***

%% 

%% Copyright 1994-2005 Patrick W Daly

 % ===============================================================

 % IMPORTANT NOTICE:

 % This bibliographic style (bst) file has been generated from one or

 % more master bibliographic style (mbs) files, listed above.

 %

 % This generated file can be redistributed and/or modified under the terms

 % of the LaTeX Project Public License Distributed from CTAN

 % archives in directory macros/latex/base/lppl.txt; either

 % version 1 of the License, or any later version.

 % ===============================================================

 % Name and version information of the main mbs file:

 % \ProvidesFile{merlin.mbs}[2005/10/17 4.14 (PWD, AO, DPC)]

 %   For use with BibTeX version 0.99a or later

 %-------------------------------------------------------------------

 % This bibliography style file is intended for texts in ENGLISH

 % This is a numerical citation style, and as such is standard LaTeX.

 % It requires no extra package to interface to the main text.

 % The form of the \bibitem entries is

 %   \bibitem{key}...

 % Usage of \cite is as follows:

 %   \cite{key} ==>>          [#]

 %   \cite[chap. 2]{key} ==>> [#, chap. 2]

 % where # is a number determined by the ordering in the reference list.

 % The order in the reference list is that by which the works were originally

 %   cited in the text, or that in the database.

 %---------------------------------------------------------------------

ENTRY

  { address

    author

    booktitle

    chapter

    doi

    edition

    editor

    eid

    howpublished

    institution

    journal

    key

    month

    note

    number

    organization

    pages

    publisher

    school

    series

    title

    type

    url

    volume

    year

  }

  {}

  { 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$

}

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 {add.blank}

{  " " * before.all 'output.state :=

}

%AS

FUNCTION {add.fullstop}

{ duplicate$ empty$

    'skip$

    { "." * add.blank }

  if$

}

FUNCTION {date.block}

{

  ";" *

  add.blank

}

FUNCTION {not}

{   { #0 }

    { #1 }

  if$

}

FUNCTION {and}

{   'skip$

    { pop$ #0 }

  if$

}

FUNCTION {or}

{   { pop$ #1 }

    'skip$

  if$

}

STRINGS {z}

FUNCTION {remove.dots}

{ 'z :=

  ""

  { z empty$ not }

  { z #1 #1 substring$

    z #2 global.max$ substring$ 'z :=

    duplicate$ "." = 'pop$

      { * }

    if$

  }

  while$

}

FUNCTION {new.block.checka}

{ empty$

    'skip$

    'new.block

  if$

}

FUNCTION {new.block.checkb}

{ empty$

  swap$ empty$

  and

    'skip$

    'new.block

  if$

}

FUNCTION {new.sentence.checka}

{ empty$

    'skip$

    'new.sentence

  if$

}

FUNCTION {new.sentence.checkb}

{ empty$

  swap$ empty$

  and

    'skip$

    'new.sentence

  if$

}

FUNCTION {field.or.null}

{ duplicate$ empty$

    { pop$ "" }

    'skip$

  if$

}

FUNCTION {emphasize}

{ duplicate$ empty$

    { pop$ "" }

    { "\emph{" swap$ * "}" * }

  if$

}

FUNCTION {bolden}

{ duplicate$ empty$

    { pop$ "" }

    { "\textbf{" swap$ * "}" * }

  if$

}

FUNCTION {tie.or.space.prefix}

{ duplicate$ text.length$ #3 <

    { "~" }

    { " " }

  if$

  swap$

}

FUNCTION {capitalize}

{ "u" change.case$ "t" change.case$ }

FUNCTION {space.word}

{ " " swap$ * " " * }

 % Here are the language-specific definitions for explicit words.

 % Each function has a name bbl.xxx where xxx is the English word.

 % The language selected here is ENGLISH

FUNCTION {bbl.and}

{ "\protect\BIBand{}"}

FUNCTION {bbl.etal}

{ "et~al." }

FUNCTION {bbl.editors}

{ " (eds.)" }

FUNCTION {bbl.editor}

{ " (ed.)" }

FUNCTION {bbl.edby}

{ "edited by" }

FUNCTION {bbl.edition}

{ "edn." }

FUNCTION {bbl.volume}

{ "vol." }

FUNCTION {bbl.of}

{ "of" }

FUNCTION {bbl.number}

{ "no." }

FUNCTION {bbl.nr}

{ "no." }

FUNCTION {bbl.in}

{ "in" }

FUNCTION {bbl.pages}

{ "" }

FUNCTION {bbl.page}

{ "" }

FUNCTION {bbl.chapter}

{ "chap." }

FUNCTION {bbl.techrep}

{ "Technical {R}eport" }

FUNCTION {bbl.mthesis}

{ "Master's {T}hesis" }

FUNCTION {bbl.phdthesis}

{ "Ph{D} {T}hesis" }

MACRO {jan} {"Jan."}

MACRO {feb} {"Feb."}

MACRO {mar} {"Mar."}

MACRO {apr} {"Apr."}

MACRO {may} {"May"}

MACRO {jun} {"Jun."}

MACRO {jul} {"Jul."}

MACRO {aug} {"Aug."}

MACRO {sep} {"Sep."}

MACRO {oct} {"Oct."}

MACRO {nov} {"Nov."}

MACRO {dec} {"Dec."}

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"}

FUNCTION {bibinfo.check}

{ swap$

  duplicate$ missing$

    {

      pop$ pop$

      ""

    }

    { duplicate$ empty$

        {

          swap$ pop$

        }

        { swap$

          pop$

        }

      if$

    }

  if$

}

FUNCTION {bibinfo.warn}

{ swap$

  duplicate$ missing$

    {

      swap$ "missing " swap$ * " in " * cite$ * warning$ pop$

      ""

    }

    { duplicate$ empty$

        {

          swap$ "empty " swap$ * " in " * cite$ * warning$

        }

        { swap$

          pop$

        }

      if$

    }

  if$

}

STRINGS  { bibinfo}

INTEGERS { nameptr namesleft numnames }

FUNCTION {format.names}

{ 'bibinfo :=

  duplicate$ empty$ 'skip$ {

  's :=

  "" 't :=

  #1 'nameptr :=

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { s nameptr

      "{vv~}{ll}{ f{}}{ jj}"

      format.name$

      remove.dots

      bibinfo bibinfo.check

      't :=

      nameptr #1 >

        {

          nameptr #0

          #10 +

          #1 + =

          numnames #0

          #10 +

          > and

            { "others" 't :=

              #1 'namesleft := }

            'skip$

          if$

          namesleft #1 >

            { ", " * t * }

            {

              s nameptr "{ll}" format.name$ duplicate$ "others" =

                { 't := }

                { pop$ }

              if$

              "," *

              t "others" =

                {

                  " " * bbl.etal emphasize *

                }

                { " " * t * }

              if$

            }

          if$

        }

        't

      if$

      nameptr #1 + 'nameptr :=

      namesleft #1 - 'namesleft :=

    }

  while$

  } if$

}

FUNCTION {format.names.ed}

{

  format.names

}

FUNCTION {format.authors}

{ author "author" format.names

}

FUNCTION {get.bbl.editor}

{ editor num.names$ #1 > 'bbl.editors 'bbl.editor if$ }

FUNCTION {format.editors}

{ editor "editor" format.names duplicate$ empty$ 'skip$

    {

      " " *

      get.bbl.editor

   "(" swap$ * ")" *

      *

    }

  if$

}

FUNCTION {format.doi}

{ doi "doi" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      "\doi{" swap$ * "}" *

    }

  if$

}

FUNCTION {format.note}

{

  url empty$

    'skip$

    { "\urlprefix\url{" url * "}" * output }

  if$

 note empty$

    { "" }

    { note #1 #1 substring$

      duplicate$ "{" =

        'skip$

        { output.state mid.sentence =

          { "l" }

          { "u" }

        if$

        change.case$

        }

      if$

      note #2 global.max$ substring$ * "note" bibinfo.check

    }

  if$

}

FUNCTION {format.title}

{ title

  duplicate$ empty$ 'skip$

    { "t" change.case$ }

  if$

  "title" bibinfo.check

}

FUNCTION {output.bibitem}

{ newline$

  "\bibitem{" write$

  cite$ write$

  "}" write$

  newline$

  ""

  before.all 'output.state :=

}

FUNCTION {if.digit}

{ duplicate$ "0" =

  swap$ duplicate$ "1" =

  swap$ duplicate$ "2" =

  swap$ duplicate$ "3" =

  swap$ duplicate$ "4" =

  swap$ duplicate$ "5" =

  swap$ duplicate$ "6" =

  swap$ duplicate$ "7" =

  swap$ duplicate$ "8" =

  swap$ "9" = or or or or or or or or or

}

FUNCTION {n.separate}

{ 't :=

  ""

  #0 'numnames :=

  { t empty$ not }

  { t #-1 #1 substring$ if.digit

      { numnames #1 + 'numnames := }

      { #0 'numnames := }

    if$

    t #-1 #1 substring$ swap$ *

    t #-2 global.max$ substring$ 't :=

    numnames #5 =

      { duplicate$ #1 #2 substring$ swap$

        #3 global.max$ substring$

        "\," swap$ * *

      }

      'skip$

    if$

  }

  while$

}

FUNCTION {n.dashify}

{

  n.separate

  '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 {word.in}

{ "" }

FUNCTION {format.date}

{

  month "month" bibinfo.check

  duplicate$ empty$

  year  "year"  bibinfo.check duplicate$ empty$

    { swap$ 'skip$

        { "there's a month but no year in " cite$ * warning$ }

      if$

      *

    }

    { swap$ 'skip$

        {

          swap$

          " " * swap$

        }

      if$

      *

      remove.dots

    }

  if$

  duplicate$ empty$

    'skip$

    {

      before.all 'output.state :=

    %AS", " swap$ *

    " " swap$ *

    }

  if$

}

FUNCTION {format.btitle}

{ title "title" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      emphasize

    }

  if$

}

FUNCTION {either.or.check}

{ empty$

    'pop$

    { "can't use both " swap$ * " fields in " * cite$ * warning$ }

  if$

}

FUNCTION {format.bvolume}

{ volume empty$

    { "" }

    { bbl.volume volume tie.or.space.prefix

      "volume" bibinfo.check * *

      series "series" bibinfo.check

      duplicate$ empty$ 'pop$

        { emphasize ", " * swap$ * }

      if$

      "volume and number" number either.or.check

    }

  if$

}

FUNCTION {format.number.series}

{ volume empty$

    { number empty$

        { series field.or.null }

        { series empty$

            { number "number" bibinfo.check }

            { output.state mid.sentence =

                { bbl.number }

                { bbl.number capitalize }

              if$

              number tie.or.space.prefix "number" bibinfo.check * *

              bbl.in space.word *

              series "series" bibinfo.check *

            }

          if$

        }

      if$

    }

    { "" }

  if$

}

FUNCTION {format.edition}

{ edition duplicate$ empty$ 'skip$

    {

      output.state mid.sentence =

        { "l" }

        { "t" }

      if$ change.case$

      "edition" bibinfo.check

      " " * bbl.edition *

    }

  if$

}

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 duplicate$ empty$ 'skip$

    { duplicate$ multi.page.check

        {

          n.dashify

        }

        {

        }

      if$

      "pages" bibinfo.check

    }

  if$

}

%AS

FUNCTION {format.book.pages}

{ pages duplicate$ empty$ 'pop$

    { swap$ duplicate$ empty$

        { pop$ pop$ format.pages }

        { 

          "; " *

          swap$

          n.dashify

          "pages" bibinfo.check

          *

        }

      if$

    }

  if$

}

FUNCTION {format.journal.pages}

{ pages duplicate$ empty$ 'pop$

    { swap$ duplicate$ empty$

        { pop$ pop$ format.pages }

        {

          ":" *

          swap$

          n.dashify

          "pages" bibinfo.check

          *

        }

      if$

    }

  if$

}

FUNCTION {format.journal.eid}

{ eid "eid" bibinfo.check

  duplicate$ empty$ 'pop$

    { swap$ duplicate$ empty$ 'skip$

      {

          ":" *

      }

      if$

      swap$ *

    }

  if$

}

FUNCTION {format.vol.num.pages}

{ volume field.or.null

  duplicate$ empty$ 'skip$

    {

      "volume" bibinfo.check

    }

  if$

  bolden

  number "number" bibinfo.check duplicate$ empty$ 'skip$

    {

      swap$ duplicate$ empty$

        { "there's a number but no volume in " cite$ * warning$ }

        'skip$

      if$

      swap$

      "(" swap$ * ")" *

    }

  if$ *

}

FUNCTION {format.chapter.pages}

{ chapter empty$

    { "" }

    { type empty$

        { bbl.chapter }

        { type "l" change.case$

          "type" bibinfo.check

        }

      if$

      chapter tie.or.space.prefix

      "chapter" bibinfo.check

      * *

    }

  if$

}

FUNCTION {format.booktitle}

{

  booktitle "booktitle" bibinfo.check

  emphasize

}

FUNCTION {format.in.ed.booktitle}

{ format.booktitle duplicate$ empty$ 'skip$

    {

      format.bvolume duplicate$ empty$ 'pop$

        { ", " swap$ * * }

      if$

      editor "editor" format.names.ed duplicate$ empty$ 'pop$

        {

          get.bbl.editor

          %" " * swap$ *

          * swap$ 

          "," *

          " " * swap$

          * }

      if$

      word.in swap$ *

    }

  if$

}

FUNCTION {empty.misc.check}

{ author empty$ title empty$ howpublished empty$

  month empty$ year empty$ note empty$

  and and and and and

    { "all relevant fields are empty in " cite$ * warning$ }

    'skip$

  if$

}

FUNCTION {format.thesis.type}

{ type duplicate$ empty$

    'pop$

    { swap$ pop$

      "t" change.case$ "type" bibinfo.check

    }

  if$

}

FUNCTION {format.tr.number}

{ number "number" bibinfo.check

  type duplicate$ empty$

    { pop$ bbl.techrep }

    'skip$

  if$

  "type" bibinfo.check

  swap$ duplicate$ empty$

    { pop$ "t" change.case$ }

    { tie.or.space.prefix * * }

  if$

}

FUNCTION {format.article.crossref}

{

  key duplicate$ empty$

    { pop$

      journal duplicate$ empty$

        { "need key or journal for " cite$ * " to crossref " * crossref * warning$ }

        { "journal" bibinfo.check emphasize word.in swap$ * }

      if$

    }

    { word.in swap$ * " " *}

  if$

  " \cite{" * crossref * "}" *

}

FUNCTION {format.crossref.editor}

{ editor #1 "{vv~}{ll}" format.name$

  "editor" bibinfo.check

  editor num.names$ duplicate$

  #2 >

    { pop$

      "editor" bibinfo.check

      " " * bbl.etal

      emphasize

      *

    }

    { #2 <

        'skip$

        { editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =

            {

              "editor" bibinfo.check

              " " * bbl.etal

              emphasize

              *

            }

            {

             bbl.and space.word

              * editor #2 "{vv~}{ll}" format.name$

              "editor" bibinfo.check

              *

            }

          if$

        }

      if$

    }

  if$

}

FUNCTION {format.book.crossref}

{ volume duplicate$ empty$

    { "empty volume in " cite$ * "'s crossref of " * crossref * warning$

      pop$ word.in

    }

    { bbl.volume

      capitalize

      swap$ tie.or.space.prefix "volume" bibinfo.check * * bbl.of space.word *

    }

  if$

  editor empty$

  editor field.or.null author field.or.null =

  or

    { key empty$

        { series empty$

            { "need editor, key, or series for " cite$ * " to crossref " *

              crossref * warning$

              "" *

            }

            { series emphasize * }

          if$

        }

        { key * }

      if$

    }

    { format.crossref.editor * }

  if$

  " \cite{" * crossref * "}" *

}

FUNCTION {format.incoll.inproc.crossref}

{

  editor empty$

  editor field.or.null author field.or.null =

  or

    { key empty$

        { format.booktitle duplicate$ empty$

            { "need editor, key, or booktitle for " cite$ * " to crossref " *

              crossref * warning$

            }

            { word.in swap$ * }

          if$

        }

        { word.in key * " " *}

      if$

    }

    { word.in format.crossref.editor * " " *}

  if$

  " \cite{" * crossref * "}" *

}

FUNCTION {format.org.or.pub}

{ 't :=

  ""

  year empty$

    { "empty year in " cite$ * warning$ }

    'skip$

  if$

  address empty$ t empty$ and

  year empty$ and

    'skip$

    {

      t empty$

        { address "address" bibinfo.check *

        }

        { t *

          address empty$

            'skip$

            { ": " * address "address" bibinfo.check * }

          if$

        }

      if$

      year empty$

        'skip$

        { t empty$ address empty$ and

            'skip$

            { ", " * }

          if$

          year "year" bibinfo.check

          *

        }

      if$

    }

  if$

}

FUNCTION {format.publisher.address}

{ publisher "publisher" bibinfo.warn format.org.or.pub

}

FUNCTION {format.organization.address}

{ organization "organization" bibinfo.check format.org.or.pub

}

FUNCTION {article}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title "title" output.check

  new.sentence

  crossref missing$

    {

      journal

      "journal" bibinfo.check

      emphasize

      "journal" output.check

      add.blank

      format.date "year" output.check

      date.block

      format.vol.num.pages output

    }

    { format.article.crossref output.nonnull

    }

  if$

  eid empty$

    { format.journal.pages }

    { format.journal.eid }

  if$

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {book}

{ output.bibitem

  author empty$

    { format.editors "author and editor" output.check

      add.fullstop

    }

    { format.authors output.nonnull

      add.fullstop

      crossref missing$

        { "author and editor" editor either.or.check }

        'skip$

      if$

    }

  if$

  format.btitle "title" output.check

  crossref missing$

    { format.bvolume output

  new.sentence

      format.edition output

      format.number.series output

      format.publisher.address output

    }

    {

  new.sentence

      format.book.crossref output.nonnull

      format.date "year" output.check

      }

  if$

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {booklet}

{ output.bibitem

  format.authors output

  add.fullstop

  format.title "title" output.check

  new.sentence

  howpublished "howpublished" bibinfo.check output

  address "address" bibinfo.check output

  format.date output

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {inbook}

{ output.bibitem

  author empty$

    { format.editors "author and editor" output.check

      add.fullstop

    }

    { format.authors output.nonnull

      add.fullstop

      crossref missing$

        { "author and editor" editor either.or.check }

        'skip$

      if$

    }

  if$

  format.btitle "title" output.check

  crossref missing$

    {

      format.bvolume output

      format.chapter.pages "chapter and pages" output.check

  new.sentence

      format.edition output

      format.number.series output

      format.publisher.address output

    }

    {

      format.chapter.pages "chapter and pages" output.check

  new.sentence

      format.book.crossref output.nonnull

    }

  if$

  format.book.pages %AS"pages" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {incollection}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title "title" output.check

  new.sentence

  crossref missing$

    { format.in.ed.booktitle "booktitle" output.check

    add.fullstop

      format.edition output

      format.chapter.pages output

      format.number.series output

      format.publisher.address output

    }

    { format.incoll.inproc.crossref output.nonnull

      format.chapter.pages output

    }

  if$

  format.book.pages %AS"pages" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {inproceedings}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title "title" output.check

  new.sentence

  crossref missing$

    { format.in.ed.booktitle "booktitle" output.check

      format.number.series output

      publisher empty$

        { format.organization.address output }

        { organization "organization" bibinfo.check output

          format.publisher.address output

        }

      if$

    }

    { format.incoll.inproc.crossref output.nonnull

    }

  if$

  format.book.pages %AS"pages" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {conference} { inproceedings }

FUNCTION {manual}

{ output.bibitem

  author empty$

    { organization "organization" bibinfo.check

      duplicate$ empty$ 'pop$

        { output

          address "address" bibinfo.check output

        }

      if$

    }

    { format.authors output.nonnull }

  if$

  add.fullstop

  format.btitle "title" output.check

  new.sentence

  author empty$

    { organization empty$

        {

          address "address" bibinfo.check output

        }

        'skip$

      if$

    }

    {

      organization "organization" bibinfo.check output

      address "address" bibinfo.check output

    }

  if$

  format.edition output

  format.date output

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {mastersthesis}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title

  "title" output.check

  new.sentence

  bbl.mthesis format.thesis.type output.nonnull

  school "school" bibinfo.warn output

  address "address" bibinfo.check output

  format.date "year" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {misc}

{ output.bibitem

  format.authors output

  add.fullstop

  format.title output

  new.sentence

  howpublished "howpublished" bibinfo.check output

  format.date output

  format.doi output

  new.sentence

  format.note output

  fin.entry

  empty.misc.check

}

FUNCTION {phdthesis}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title

  "title" output.check

  new.sentence

  bbl.phdthesis format.thesis.type output.nonnull

  school "school" bibinfo.warn output

  address "address" bibinfo.check output

  format.date "year" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {proceedings}

{ output.bibitem

  editor empty$

    { organization "organization" bibinfo.check output

    }

    { format.editors output.nonnull }

  if$

  add.fullstop

  format.btitle "title" output.check

  format.bvolume output

  editor empty$

    { publisher empty$

        'skip$

        {

          format.number.series output

          format.publisher.address output

        }

      if$

    }

    { publisher empty$

        {

          format.organization.address output }

        {

          organization "organization" bibinfo.check output

          format.publisher.address output

        }

      if$

     }

  if$

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {techreport}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title

  "title" output.check

  new.sentence

  format.tr.number emphasize output.nonnull

  institution "institution" bibinfo.warn output

  address "address" bibinfo.check output

  format.date "year" output.check

  format.doi output

  new.sentence

  format.note output

  fin.entry

}

FUNCTION {unpublished}

{ output.bibitem

  format.authors "author" output.check

  add.fullstop

  format.title "title" output.check

  format.date output

  format.doi output

  new.sentence

  format.note "note" output.check

  fin.entry

}

FUNCTION {default.type} { misc }

READ

STRINGS { longest.label }

INTEGERS { number.label longest.label.width }

FUNCTION {initialize.longest.label}

{ "" 'longest.label :=

  #1 'number.label :=

  #0 'longest.label.width :=

}

FUNCTION {longest.label.pass}

{ number.label int.to.str$ 'label :=

  number.label #1 + 'number.label :=

  label width$ longest.label.width >

    { label 'longest.label :=

      label width$ 'longest.label.width :=

    }

    'skip$

  if$

}

EXECUTE {initialize.longest.label}

ITERATE {longest.label.pass}

FUNCTION {begin.bib}

{ preamble$ empty$

    'skip$

    { preamble$ write$ newline$ }

  if$

  "\begin{thebibliography}{"  longest.label  * "}" *

  write$ newline$

  "\providecommand{\url}[1]{\texttt{#1}}"

  write$ newline$

  "\providecommand{\urlprefix}{URL }"

  write$ newline$

  "\expandafter\ifx\csname urlstyle\endcsname\relax"

  write$ newline$

  "  \providecommand{\doi}[1]{doi:\discretionary{}{}{}#1}\else"

  write$ newline$

  "  \providecommand{\doi}{doi:\discretionary{}{}{}\begingroup \urlstyle{rm}\Url}\fi"

  write$ newline$

}

EXECUTE {begin.bib}

EXECUTE {init.state.consts}

ITERATE {call.type$}

FUNCTION {end.bib}

{ newline$

  "\end{thebibliography}" write$ newline$

}

EXECUTE {end.bib}

%% End of customized bst file

%%

%% End of file `wileyj.bst'.