%%

%% This is file `gbt7714-unsrt.bst',

%% generated with the docstrip utility.

%%

%% The original source files were:

%%

%% gbt7714.dtx (with options: `numerical')

%%

%% Copyright (C) 2016-2018 by Zeping Lee <zepinglee AT gmail.com>

%%

%% This file may be distributed and/or modified under the

%% conditions of the LaTeX Project Public License, either

%% version 1.2 of this license or (at your option) any later

%% version. The latest version of this license is in:

%%

%% http://www.latex-project.org/lppl.txt

%%

%% and version 1.2 or later is part of all distributions of

%% LaTeX version 1999/12/01 or later.

%%

%% This BibTeX style file is derived from `plainnat.bst' by Patrick W Daly,

%% which was designed for use with the `natbib.sty' package.

%%

ENTRY

{ address

author

booktitle

date

doi

edition

editor

institution

journal

key

language

mark

medium

number

organization

pages

publisher

school

series

title

translator

url

urldate

volume

year

}

{ entry.lang }

{ label extra.label sort.label short.list entry.mark }

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

INTEGERS { lang.zh lang.ja lang.en lang.ru lang.other }

INTEGERS { charptr stringlength }

FUNCTION {init.state.consts}

{ #0 'before.all :=

#1 'mid.sentence :=

#2 'after.sentence :=

#3 'after.block :=

#4 'after.slash :=

#3 'lang.zh :=

#4 'lang.ja :=

#1 'lang.en :=

#2 'lang.ru :=

#0 'lang.other :=

}

STRINGS { s t }

FUNCTION {debug}

{ 's :=

duplicate$

"DEBUG: " s * " -> `" *

swap$ * "'" *

top$

}

FUNCTION {debug.int}

{ 's :=

duplicate$ int.to.str$

"DEBUG: " s * " == " *

swap$ *

top$

}

FUNCTION {punct.colon}

{ ": "

}

FUNCTION {punct.slash}

{ "//\allowbreak{}"

}

FUNCTION {punct.space}

{ " "

}

FUNCTION {output.nonnull}

{ 's :=

output.state mid.sentence =

{ ", " * write$ }

{ output.state after.block =

{ add.period$ write$

newline$

"\newblock " write$

}

{ output.state before.all =

'write$

{ output.state after.slash =

{ punct.slash * write$ }

{ add.period$ " " * write$ }

if$

}

if$

}

if$

mid.sentence 'output.state :=

}

if$

s

}

FUNCTION {output}

{ duplicate$ empty$

'pop$

'output.nonnull

if$

}

FUNCTION {output.after}

{ 't :=

duplicate$ empty$

'pop$

{ 's :=

output.state mid.sentence =

{ t * write$ }

{ output.state after.block =

{ add.period$ write$

newline$

"\newblock " write$

}

{ output.state before.all =

'write$

{ output.state after.slash =

{ punct.slash * write$ }

{ add.period$ " " * write$ }

if$

}

if$

}

if$

mid.sentence 'output.state :=

}

if$

s

}

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$

{ output.state after.slash =

'skip$

{ after.block 'output.state := }

if$

}

if$

}

FUNCTION {new.sentence}

{ output.state after.block =

'skip$

{ output.state before.all =

'skip$

{ output.state after.slash =

'skip$

{ after.sentence 'output.state := }

if$

}

if$

}

if$

}

FUNCTION {new.slash}

{ output.state before.all =

'skip$

{ after.slash 'output.state := }

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 {field.or.null}

{ duplicate$ empty$

{ pop$ "" }

'skip$

if$

}

FUNCTION {emphasize}

{ duplicate$ empty$

{ pop$ "" }

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

if$

}

INTEGERS { ascii }

FUNCTION {get.char.lang}

{ chr.to.int$ 'ascii :=

ascii #64 > ascii #91 < and ascii #96 > ascii #123 < and or

{ lang.en }

{ ascii #227 > ascii #234 < and

{ lang.zh }

{ ascii #227 =

{ lang.ja }

{ ascii #207 > ascii #212 < and

{ lang.ru }

{ lang.en }

if$

}

if$

}

if$

}

if$

}

INTEGERS { char.lang tmp.lang }

STRINGS { tmp.str }

FUNCTION {get.str.lang}

{ 'tmp.str :=

lang.other 'tmp.lang :=

tmp.str empty$

{ "Empty string!" warning$ }

{ #1 'charptr :=

tmp.str text.length$ #1 + 'stringlength :=

{ charptr stringlength < }

{ tmp.str charptr #1 substring$ get.char.lang 'char.lang :=

char.lang tmp.lang >

{ char.lang 'tmp.lang := }

'skip$

if$

char.lang lang.zh = char.lang lang.ja = or

{ charptr #3 + 'charptr := }

{ char.lang lang.ru =

{ charptr #2 + 'charptr := }

{ charptr #1 + 'charptr := }

if$

}

if$

}

while$

}

if$

tmp.lang

}

FUNCTION {is.in.chinese}

{ entry.lang lang.zh =

}

FUNCTION {format.et.al}

{ is.in.chinese

{ "等"}

{ "et~al." }

if$

}

FUNCTION {format.anonymous}

{ is.in.chinese

{ "佚名" }

{ "Anon" }

if$

}

INTEGERS { nameptr namesleft numnames name.lang}

FUNCTION {format.names}

{ 's :=

#1 'nameptr :=

s num.names$ 'numnames :=

numnames 'namesleft :=

{ namesleft #0 > nameptr #4 < and }

{ s nameptr "{vv~}{ll}{, jj}{, ff}" format.name$ 't :=

t get.str.lang 'name.lang :=

name.lang lang.en =

{ t #1 "{vv~}{ll}{ f{~}}" format.name$ "u" change.case$

t #1 "{, jj}" format.name$ *

't :=

}

{ t #1 "{ll}{ff}" format.name$ 't := }

if$

nameptr #1 >

{ namesleft #1 >

{ ", " * t * }

{ t "others" =

{ ", " * format.et.al * }

{ ", " * t * }

if$

}

if$

nameptr #3 = namesleft #1 > and

{ ", " * format.et.al * }

'skip$

if$

}

't

if$

nameptr #1 + 'nameptr :=

namesleft #1 - 'namesleft :=

}

while$

}

FUNCTION {format.key}

{ empty$

{ key field.or.null }

{ "" }

if$

}

FUNCTION {format.authors}

{ author empty$

{ "" }

{ author format.names }

if$

}

FUNCTION {format.editors}

{ editor empty$

{ "" }

{ editor format.names }

if$

}

FUNCTION {format.translators}

{ translator empty$

{ "" }

{ translator format.names

is.in.chinese

{ translator num.names$ #3 >

{ "译" * }

{ ", 译" * }

if$

}

'skip$

if$

}

if$

}

FUNCTION {format.url}

{ url empty$

{ "" }

{ new.block "\url{" url * "}" * }

if$

}

FUNCTION {is.doi.in.url}

{ url empty$

{ #0 }

{ doi text.length$ 'stringlength :=

url text.length$ 'charptr :=

{ url charptr stringlength substring$ doi = not

charptr #0 >

and

}

{ charptr #1 - 'charptr := }

while$

charptr

}

if$

}

FUNCTION {format.doi}

{ doi empty$

{ "" }

{ is.doi.in.url

{ "" }

{ new.block "\doi{" doi * "}" * }

if$

}

if$

}

FUNCTION {format.title}

{ title empty$

{ "" }

{ title "t" change.case$ }

if$

}

FUNCTION {set.mark}

{ entry.mark empty$ not

'pop$

{ mark empty$ not

{ pop$ mark 'entry.mark := }

{ 'entry.mark := }

if$

medium empty$ not

{ entry.mark "/" * medium * 'entry.mark := }

{ url empty$ not

{ entry.mark "/OL" * 'entry.mark := }

'skip$

if$

}

if$

}

if$

}

FUNCTION {format.mark}

{ "\allowbreak[" entry.mark * "]" * }

FUNCTION {format.full.names}

{'s :=

#1 'nameptr :=

s num.names$ 'numnames :=

numnames 'namesleft :=

{ namesleft #0 > }

{ s nameptr "{vv~}{ll}{, jj}{, ff}" format.name$ 't :=

t get.str.lang 'name.lang :=

name.lang lang.en =

{ t #1 "{vv~}{ll}" format.name$ 't := }

{ t #1 "{ll}{ff}" format.name$ 't := }

if$

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 {author.editor.full}

{ author empty$

{ editor empty$

{ "" }

{ editor format.full.names }

if$

}

{ author format.full.names }

if$

}

FUNCTION {author.full}

{ author empty$

{ "" }

{ author format.full.names }

if$

}

FUNCTION {editor.full}

{ editor empty$

{ "" }

{ editor format.full.names }

if$

}

FUNCTION {make.full.names}

{ type$ "book" =

type$ "inbook" =

or

'author.editor.full

{ type$ "collection" =

type$ "proceedings" =

or

'editor.full

'author.full

if$

}

if$

}

FUNCTION {output.bibitem}

{ newline$

"\bibitem[" write$

label write$

")" make.full.names duplicate$ short.list =

{ pop$ }

{ * }

if$

"]{" * write$

cite$ write$

"}" write$

newline$

""

before.all 'output.state :=

}

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 {extract.before.dash}

{ duplicate$ empty$

{ pop$ "" }

{ 's :=

#1 'charptr :=

s text.length$ #1 + 'stringlength :=

{ charptr stringlength <

s charptr #1 substring$ "-" = not

and

}

{ charptr #1 + 'charptr := }

while$

s #1 charptr #1 - substring$

}

if$

}

FUNCTION {extract.after.dash}

{ duplicate$ empty$

{ pop$ "" }

{ 's :=

#1 'charptr :=

s text.length$ #1 + 'stringlength :=

{ charptr stringlength <

s charptr #1 substring$ "-" = not

and

}

{ charptr #1 + 'charptr := }

while$

{ charptr stringlength <

s charptr #1 substring$ "-" =

and

}

{ charptr #1 + 'charptr := }

while$

s charptr global.max$ substring$

}

if$

}

FUNCTION {contains.dash}

{ duplicate$ empty$

{ pop$ #0 }

{ 's :=

{ s empty$ not

s #1 #1 substring$ "-" = not

and

}

{ s #2 global.max$ substring$ 's := }

while$

s empty$ not

}

if$

}

FUNCTION {format.year}

{ year empty$ not

{ year extract.before.dash }

{ date empty$ not

{ date extract.before.dash }

{ "empty year in " cite$ * warning$

""

}

if$

}

if$

extra.label *

}

FUNCTION {format.date}

{ type$ "patent" = type$ "newspaper" = or

date empty$ not and

{ date }

{ year }

if$

}

FUNCTION {format.editdate}

{ date empty$ not

type$ "newspaper" = not and

url empty$ not doi empty$ not or

and

{ "\allowbreak(" date * ")" * }

{ "" }

if$

}

FUNCTION {format.urldate}

{ urldate empty$ not

{ "\allowbreak[" urldate * "]" * }

{ "" }

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 {is.digit}

{ duplicate$ empty$

{ pop$ #0 }

{ chr.to.int$

duplicate$ "0" chr.to.int$ <

{ pop$ #0 }

{ "9" chr.to.int$ >

{ #0 }

{ #1 }

if$

}

if$

}

if$

}

FUNCTION {is.number}

{ 's :=

s empty$

{ #0 }

{ s text.length$ 'charptr :=

{ charptr #0 >

s charptr #1 substring$ is.digit

and

}

{ charptr #1 - 'charptr := }

while$

charptr not

}

if$

}

FUNCTION {format.volume}

{ volume empty$

{ "" }

{ volume is.number

{ is.in.chinese

{ "第" volume * "卷" * }

{ "volume" volume tie.or.space.connect }

if$

}

{ volume }

if$

}

if$

}

FUNCTION {format.number}

{ number empty$

{ "" }

{ number is.number

{ is.in.chinese

{ "第" number * "册" * }

{ "number" number tie.or.space.connect }

if$

}

{ number }

if$

}

if$

}

FUNCTION {format.volume.number}

{ volume empty$ not

{ format.volume }

{ format.number }

if$

}

FUNCTION {format.series.vol.num.title}

{ format.volume.number 's :=

series empty$ not

{ series ": " *

s empty$ not

{ s * "\quad " * }

'skip$

if$

title *

}

{ title

s empty$ not

{ ": " * s * }

'skip$

if$

}

if$

"t" change.case$

}

FUNCTION {format.series.vol.num.booktitle}

{ format.volume.number 's :=

series empty$ not

{ series ": " *

s empty$ not

{ s * "\quad " * }

'skip$

if$

booktitle *

}

{ booktitle

s empty$ not

{ ": " * s * }

'skip$

if$

}

if$

}

FUNCTION {num.to.ordinal}

{ duplicate$ text.length$ 'charptr :=

duplicate$ charptr #1 substring$ 's :=

s "1" =

{ "st" * }

{ s "2" =

{ "nd" * }

{ s "3" =

{ "rd" * }

{ "th" * }

if$

}

if$

}

if$

}

FUNCTION {format.edition}

{ edition empty$

{ "" }

{ edition is.number

{ is.in.chinese

{ edition "版" * }

{ edition num.to.ordinal " ed." * }

if$

}

{ entry.lang lang.en =

{ edition "t" change.case$ 's :=

s "Revised" = s "Revised edition" = or

{ "Rev. ed." }

{ s " ed." *}

if$

}

{ edition }

if$

}

if$

}

if$

}

FUNCTION {format.sine.loco}

{ is.in.chinese

{ "[出版地不详]" }

{ "[S.l.]" }

if$

}

FUNCTION {format.address}

{ address }

FUNCTION {format.sine.nomine}

{ is.in.chinese

{ "[出版地不详]" }

{ "[s.n.]" }

if$

}

FUNCTION {format.publisher}

{ publisher empty$ not

{ publisher }

{ school empty$ not

{ school }

{ organization empty$ not

{ organization }

{ institution empty$ not

{ institution }

{ "" }

if$

}

if$

}

if$

}

if$

}

FUNCTION {format.sine.loco.sine.nomine}

{ is.in.chinese

{ "[出版地不详: 出版者不详]" }

{ "[S.l.: s.n.]" }

if$

}

FUNCTION {format.address.publisher}

{ address empty$ not

{ address

format.publisher empty$ not

{ ": " * format.publisher * }

{ url empty$ doi empty$ and

{ ": " * format.sine.nomine * }

'skip$

if$

}

if$

}

{ url empty$ doi empty$ and

{ format.publisher empty$ not

{ format.sine.loco ": " * format.publisher * }

{ format.sine.loco.sine.nomine }

if$

}

{ format.publisher empty$ not

{ format.publisher }

{ "" }

if$

}

if$

}

if$

}

FUNCTION {format.pages}

{ pages empty$

{ "" }

{ pages n.dashify }

if$

}

FUNCTION {format.journal.volume}

{ volume }

FUNCTION {format.journal.number}

{ number empty$ not

{ "\penalty0 (" number * ")" * }

{ "" }

if$

}

FUNCTION {format.periodical.year.volume.number}

{ year empty$ not

{ year extract.before.dash }

{ "No year in periodical " cite$ * warning$ }

if$

volume empty$ not

{ ", " * volume extract.before.dash * }

'skip$

if$

number empty$ not

{ "\penalty0 (" * number extract.before.dash * ")" * }

'skip$

if$

year contains.dash

{ "--" *

year extract.after.dash empty$

volume extract.after.dash empty$ and

number extract.after.dash empty$ and not

{ year extract.after.dash empty$ not

{ year extract.after.dash * }

{ year extract.before.dash * }

if$

volume empty$ not

{ ", " * volume extract.after.dash * }

'skip$

if$

number empty$ not

{ "\penalty0 (" * number extract.after.dash * ")" * }

'skip$

if$

}

'skip$

if$

}

'skip$

if$

}

FUNCTION {format.in.ed.booktitle}

{ booktitle empty$

{ "" }

{ editor empty$

{ "In " booktitle emphasize * }

{ "In " format.editors * ", " * booktitle emphasize * }

if$

}