% BibTeX bibliography style `njcarticle'
	% This BibTeX bibliography style is derived from the
	% standard BibTeX biliograhy style `plain'.
	% Copyright (C) 1994, all rights reserved.
	% Th modifications to the standard bibliography style `plain'
	% are copyrighted by the Nordic Journal of Computing Publishing
	% Association and by Kimmo Raatikainen.

ENTRY
  { address
    author
    booktitle
    chapter
    edition
    editor
    howpublished
    institution
    journal
    key
    month
    note
    number
    organization
    pages
    publisher
    school
    series
    title
    type
    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 q }

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$
     }
     if$
     mid.sentence 'output.state :=
  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 {generate.cite.names}
{
	'q :=
	q #1 "{vv~}{ll}{~jj}" format.name$
	q num.names$ duplicate$
	#2 >
        { pop$ " \etal" *}
        { #2 <
           'skip$
           { q #2 "{vv~}{ll}{~jj}" format.name$ "others" =
               {" \etal" *}
               { " and " * q #2 "{vv~}{ll}{~jj}" format.name$ *}
               if$
            }
            if$
        }
         if$
}

FUNCTION {generate.cite.label}
{
  author empty$
  {  editor empty$
     {  organization empty$
        {  key empty$
           {"?????"}{ key } if$
        }
        { organization }
        if$
     }
     { editor generate.cite.names}
     if$
   }
   { author generate.cite.names
   }
   if$
}

FUNCTION {format.year}
{ year empty$ {"?"}{year} if$
}
	
FUNCTION {output.bibitem}
{ newline$
  "\bibitem[{" write$
   generate.cite.label "}{" * format.year * "}]{" * 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.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 {new.sentence.checkc}
{ empty$
  swap$ empty$
  and
  swap$ empty$
  and
    'skip$
    'new.sentence
  if$
}

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

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

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

FUNCTION {smallcaps}
{ duplicate$ empty$
    { pop$ "" }
    { "{\sc " swap$ * "}" * }
  if$
}

FUNCTION {boldify}
{ duplicate$ empty$
    { pop$ "" }
    { "{\bf " swap$ * "}" * }
  if$
}

INTEGERS { nameptr namesleft numnames }

FUNCTION {format.names}
{ 's :=
  #1 'nameptr :=
  s num.names$ 'numnames :=
  numnames 'namesleft :=
    { namesleft #0 > }
    { s nameptr "{vv~}{ll}{~jj}{,~ff}" format.name$ 't :=
      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.names.two}
{ 's :=
  #1 'nameptr :=
  s num.names$ 'numnames :=
  numnames 'namesleft :=
    { namesleft #0 > }
    { s nameptr "{ff~}{vv~}{ll}{~jj}" format.name$ 't :=
      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$
}

FUNCTION {format.editors}
{ editor empty$
    { "" }
    { editor format.names
      editor num.names$ #1 >
	{ ", Editors" * }
	{ ", Editor" * }
      if$
    }
  if$
}

FUNCTION {format.editors.two}
{ editor empty$
    { "" }
    { editor format.names
      editor num.names$ #1 >
	{ ", Editors" * }
	{ ", Editor" * }
      if$
    }
  if$
}

FUNCTION {format.title}
{ title empty$
    { "" }
    { title }
  if$
}

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.date}
{ year empty$
    { month empty$
	{ "" }
	{ "there's a month but no year in " cite$ * warning$
	  month
	}
      if$
    }
    { month empty$
	'year
	{ month " " * year * }
      if$
    }
  if$
}

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 }
	{ "Number" number tie.or.space.connect
	  series empty$
	    { "there's a number but no series in " cite$ * warning$ }
	    { " in " * series * }
	  if$
	}
      if$
    }
    { "" }
  if$
}

FUNCTION {format.edition}
{ edition empty$
    { "" }
    { output.state mid.sentence =
	{ edition "l" change.case$ " edition" * }
	{ edition "t" change.case$ " edition" * }
      if$
    }
  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 empty$
    { "" }
    { pages multi.page.check
	{ pages n.dashify }
	{ pages }
      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.num.month.pages}
{ number empty$
    { "" }
    { number
      volume empty$
	{ "there's a number but no volume in " cite$ * warning$ }
	'skip$
      if$
    }
  if$
  month empty$
      'skip$
      { " (" month * ")" *  *}
  if$
  pages empty$
    { ", ?--?" *}
    { 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.booktitle}
{ booktitle empty$
    { "" }
    { "In " booktitle emphasize * }
  if$
}

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

FUNCTION {empty.misc.check}
{ author empty$ title empty$ howpublished empty$
  month empty$ year empty$ note empty$
  and and and and and
  key empty$ not and
    { "all relevant fields are empty in " cite$ * warning$ }
    'skip$
  if$
}

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

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

FUNCTION {article}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  new.block
  journal
  volume empty$
     { " {\bf ?}"}
     { " " volume *}
  if$
  * emphasize "journal" output.check
  format.num.month.pages output
  fin.entry
}

FUNCTION {book}
{ output.bibitem
  author empty$
    { format.editors smallcaps "author and editor" output.check }
    { format.authors smallcaps output.nonnull }
  if$
  new.sentence
  format.year "year" output.check
  new.block
  format.btitle "title" output.check
  format.edition output
  new.block
  format.bvolume output
  format.number.series output
  publisher address new.sentence.checkb
  publisher "publisher" output.check
  address output
  fin.entry
}

FUNCTION {booklet}
{ output.bibitem
  format.authors smallcaps output
  author new.sentence.checka
  format.year "year" output.check
  new.block
  format.title "title" output.check
  howpublished address new.block.checkb
  howpublished output
  address output
  fin.entry
}

FUNCTION {inbook}
{ output.bibitem
  author empty$
    { format.editors smallcaps "author and editor" output.check }
    { format.authors smallcaps output.nonnull
      "author and editor" editor either.or.check
    }
  if$
  new.sentence
  format.year "year" output.check
  new.block
  format.btitle "title" output.check
  format.edition output

  format.bvolume output
  format.number.series output
  new.sentence
  publisher "publisher" output.check
  address output
  format.chapter.pages "chapter and pages" output.check

  fin.entry
}

FUNCTION {incollection}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  new.block

  format.in.ed.booktitle "booktitle" output.check
  format.edition output
  new.sentence
  format.bvolume output
  format.number.series output
  new.sentence
  publisher "publisher" output.check
  address output
  format.chapter.pages output

  fin.entry
}

FUNCTION {inproceedings}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  new.block

  format.in.booktitle "booktitle" output.check
  format.bvolume output
  format.number.series output
  organization publisher address new.sentence.checkc
  organization empty$
    { publisher } { organization }
  if$ output
  address output
  format.pages output

  fin.entry
}

FUNCTION {conference} { inproceedings }

FUNCTION {manual}
{ output.bibitem
  author empty$
    { organization empty$
	{ "?????" }
	{ organization }
      if$
    }
    { format.authors }
  if$ smallcaps output
  new.sentence
  format.year "year" output.check
  new.block
  format.btitle "title" output.check
  format.edition output
  author empty$
    { address new.block.checka
      address output
    }
    { organization address new.block.checkb
      organization output
      address output
    }
  if$
  fin.entry
}

FUNCTION {mastersthesis}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  new.block
  "Master's thesis" format.thesis.type output.nonnull
  school "school" output.check
  address output
  fin.entry
}

FUNCTION {misc}
{ output.bibitem
  author empty$
   { key empty$
       { "?????"}
       { key }
     if$
    }
    { format.authors
    }
  if$ smallcaps output
  new.sentence 
  format.year "year" output.check
  title howpublished new.block.checkb
  format.title output
  howpublished new.block.checka
  howpublished output
  fin.entry
  empty.misc.check
}

FUNCTION {phdthesis}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.btitle "title" output.check
  new.block
  "PhD thesis" format.thesis.type output.nonnull
  school "school" output.check
  address output
  fin.entry
}

FUNCTION {proceedings}
{ output.bibitem
  editor empty$
    { organization smallcaps output }
    { format.editors smallcaps output.nonnull }
  if$
  editor organization new.sentence.checkb
  format.year "year" output.check
  new.block
  format.btitle "title" output.check
  format.bvolume output
  format.number.series output

  editor empty$
    { publisher address new.sentence.checkb
      publisher output
      address output
    }
    { organization publisher address new.sentence.checkc
      organization output
      publisher output
      address output
    }
  if$

  fin.entry
}

FUNCTION {techreport}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  new.block
  format.tr.number output.nonnull
  institution "institution" output.check
  address output
  fin.entry
}

FUNCTION {unpublished}
{ output.bibitem
  format.authors smallcaps "author" output.check
  new.sentence
  format.year "year" output.check
  new.block
  format.title "title" output.check
  fin.entry
}

FUNCTION {default.type} { misc }

MACRO {jan} {"Jan."}
MACRO {feb} {"Feb."}
MACRO {mar} {"Mar."}
MACRO {apr} {"Apr."}
MACRO {may} {"May"}
MACRO {jun} {"June"}
MACRO {jul} {"July"}
MACRO {aug} {"Aug."}
MACRO {sep} {"Sept."}
MACRO {sept} {"Sept."}
MACRO {oct} {"Oct."}
MACRO {nov} {"Nov."}
MACRO {dec} {"Dec."}

MACRO {acmcs} {"ACM Computing Surveys"}
MACRO {acta} {"Acta Informatica"}
MACRO {cacm} {"Commun. of the ACM"}
MACRO {ibmjrd} {"IBM Journal of Research and Development"}
MACRO {ibmsj} {"IBM Syst. J."}
MACRO {ieeese} {"IEEE Trans. on Softw. Eng."}
MACRO {ieeetc} {"IEEE Trans. on Comp."}
MACRO {ieeetcad} {"IEEE Trans. on Comp.-Aided Design of Integr. Circ."}
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 J. on Comp."}
MACRO {tocs} {"ACM TOCS"}
MACRO {tods} {"ACM TODS"}
MACRO {tog} {"ACM TOG"}
MACRO {tomacs} {"ACM TOMACS"}
MACRO {toms} {"ACM TOMS"}
MACRO {toois} {"ACM TOOIS"}
MACRO {toplas} {"ACM TOPLAS"}
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$
}

FUNCTION {sort.format.names}
{ 's :=
  #1 'nameptr :=
  ""
  s num.names$ 'numnames :=
  numnames 'namesleft :=
    { namesleft #0 > }
    { nameptr #1 >
	{ "   " * }
	'skip$
      if$
      s nameptr "{vv{ } }{ll{ }}{  ff{ }}{  jj{ }}" format.name$ 't :=
      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 {author.organization.sort}
{ author empty$
    { organization empty$
	{ key empty$
	    { "to sort, need author, organization, or key in " cite$ * warning$
	      ""
	    }
	    { key sortify }
	  if$
	}
	{ "The " #4 organization chop.word sortify }
      if$
    }
    { author sort.format.names }
  if$
}

FUNCTION {editor.organization.sort}
{ editor empty$
    { organization empty$
	{ key empty$
	    { "to sort, need editor, organization, or key in " cite$ * warning$
	      ""
	    }
	    { key sortify }
	  if$
	}
	{ "The " #4 organization chop.word sortify }
      if$
    }
    { editor sort.format.names }
  if$
}

FUNCTION {presort}
{ type$ "book" =
  type$ "inbook" =
  or
    'author.editor.sort
    { type$ "proceedings" =
	'editor.organization.sort
	{ type$ "manual" =
	    'author.organization.sort
	    'author.sort
	  if$
	}
      if$
    }
  if$
  "    "
  *
  year field.or.null sortify
  *
  "    "
  *
  title field.or.null
  sort.format.title
  *
  #1 entry.max$ substring$
  'sort.key$ :=
}

ITERATE {presort}

SORT

FUNCTION {begin.bib}
{ preamble$ empty$
    'skip$
    { preamble$ write$ newline$ }
  if$
  "\begin{thebibliography}{MMM}" write$ newline$
  "\let\bibem=\sl" write$ newline$
}

EXECUTE {begin.bib}

EXECUTE {init.state.consts}

ITERATE {call.type$}

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

EXECUTE {end.bib}