RhodeCode

%%%%% Defining LEMON %%%%%

@misc{lemon,

  key =          {LEMON},

  title =        {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and

                  {O}ptimization in {N}etworks},

  howpublished = {\url{http://lemon.cs.elte.hu/}},

  year =         2009

}

@misc{egres,

  key =          {EGRES},

  title =        {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on

                  {C}ombinatorial {O}ptimization},

  howpublished = {\url{http://www.cs.elte.hu/egres/}},

  year =         2009

}

@misc{coinor,

  key =          {COIN-OR},

  title =        {{COIN-OR} -- {C}omputational {I}nfrastructure for

                  {O}perations {R}esearch},

  howpublished = {\url{http://www.coin-or.org/}},

  year =         2009

}

%%%%% Other libraries %%%%%%

@misc{boost,

  key =          {Boost},

  title =        {{B}oost {C++} {L}ibraries},

  howpublished = {\url{http://www.boost.org/}},

  year =         2009

}

@book{bglbook,

  author =       {Jeremy G. Siek and Lee-Quan Lee and Andrew

                  Lumsdaine},

  title =        {The Boost Graph Library: User Guide and Reference

                  Manual},

  publisher =    {Addison-Wesley},

  year =         2002

}

@misc{leda,

  key =          {LEDA},

  title =        {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and

                  {A}lgorithms},

  howpublished = {\url{http://www.algorithmic-solutions.com/}},

  year =         2009

}

@book{ledabook,

  author =       {Kurt Mehlhorn and Stefan N{\"a}her},

  title =        {{LEDA}: {A} platform for combinatorial and geometric

                  computing},

  isbn =         {0-521-56329-1},

  publisher =    {Cambridge University Press},

  address =      {New York, NY, USA},

  year =         1999

}

%%%%% Tools that LEMON depends on %%%%%

@misc{cmake,

  key =          {CMake},

  title =        {{CMake} -- {C}ross {P}latform {M}ake},

  howpublished = {\url{http://www.cmake.org/}},

  year =         2009

}

@misc{doxygen,

  key =          {Doxygen},

  title =        {{Doxygen} -- {S}ource code documentation generator

                  tool},

  howpublished = {\url{http://www.doxygen.org/}},

  year =         2009

}

%%%%% LP/MIP libraries %%%%%

@misc{glpk,

  key =          {GLPK},

  title =        {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it},

  howpublished = {\url{http://www.gnu.org/software/glpk/}},

  year =         2009

}

@misc{clp,

  key =          {Clp},

  title =        {{Clp} -- {Coin-Or} {L}inear {P}rogramming},

  howpublished = {\url{http://projects.coin-or.org/Clp/}},

  year =         2009

}

@misc{cbc,

  key =          {Cbc},

  title =        {{Cbc} -- {Coin-Or} {B}ranch and {C}ut},

  howpublished = {\url{http://projects.coin-or.org/Cbc/}},

  year =         2009

}

@misc{cplex,

  key =          {CPLEX},

  title =        {{ILOG} {CPLEX}},

  howpublished = {\url{http://www.ilog.com/}},

  year =         2009

}

@misc{soplex,

  key =          {SoPlex},

  title =        {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented

                  {S}implex},

  howpublished = {\url{http://soplex.zib.de/}},

  year =         2009

}

%%%%% General books %%%%%

@book{amo93networkflows,

  author =       {Ravindra K. Ahuja and Thomas L. Magnanti and James

                  B. Orlin},

  title =        {Network Flows: Theory, Algorithms, and Applications},

  publisher =    {Prentice-Hall, Inc.},

  year =         1993,

  month =        feb,

  isbn =         {978-0136175490}

}

@book{schrijver03combinatorial,

  author =       {Alexander Schrijver},

  title =        {Combinatorial Optimization: Polyhedra and Efficiency},

  publisher =    {Springer-Verlag},

  year =         2003,

  isbn =         {978-3540443896}

}

@book{clrs01algorithms,

  author =       {Thomas H. Cormen and Charles E. Leiserson and Ronald

                  L. Rivest and Clifford Stein},

  title =        {Introduction to Algorithms},

  publisher =    {The MIT Press},

  year =         2001,

  edition =      {2nd}

}

@book{stroustrup00cpp,

  author =       {Bjarne Stroustrup},

  title =        {The C++ Programming Language},

  edition =      {3rd},

  publisher =    {Addison-Wesley Professional},

  isbn =         0201700735,

  month =        {February},

  year =         2000

}

%%%%% Maximum flow algorithms %%%%%

@inproceedings{goldberg86newapproach,

  author =       {Andrew V. Goldberg and Robert E. Tarjan},

  title =        {A new approach to the maximum flow problem},

  booktitle =    {STOC '86: Proceedings of the Eighteenth Annual ACM

                  Symposium on Theory of Computing},

  year =         1986,

  publisher =    {ACM Press},

  address =      {New York, NY},

  pages =        {136-146}

}

@article{dinic70algorithm,

  author =       {E. A. Dinic},

  title =        {Algorithm for solution of a problem of maximum flow

                  in a network with power estimation},

  journal =      {Soviet Math. Doklady},

  year =         1970,

  volume =       11,

  pages =        {1277-1280}

}

@article{goldberg08partial,

  author =       {Andrew V. Goldberg},

  title =        {The Partial Augment-Relabel Algorithm for the

                  Maximum Flow Problem},

  journal =      {16th Annual European Symposium on Algorithms},

  year =         2008,

  pages =        {466-477}

}

@article{sleator83dynamic,

  author =       {Daniel D. Sleator and Robert E. Tarjan},

  title =        {A data structure for dynamic trees},

  journal =      {Journal of Computer and System Sciences},

  year =         1983,

  volume =       26,

  number =       3,

  pages =        {362-391}

}

%%%%% Minimum mean cycle algorithms %%%%%

@article{karp78characterization,

  author =       {Richard M. Karp},

  title =        {A characterization of the minimum cycle mean in a

                  digraph},

  journal =      {Discrete Math.},

  year =         1978,

  volume =       23,

  pages =        {309-311}

}

@article{dasdan98minmeancycle,

  author =       {Ali Dasdan and Rajesh K. Gupta},

  title =        {Faster Maximum and Minimum Mean Cycle Alogrithms for

                  System Performance Analysis},

  journal =      {IEEE Transactions on Computer-Aided Design of

                  Integrated Circuits and Systems},

  year =         1998,

  volume =       17,

  number =       10,

  pages =        {889-899}

}

%%%%% Minimum cost flow algorithms %%%%%

@article{klein67primal,

  author =       {Morton Klein},

  title =        {A primal method for minimal cost flows with

                  applications to the assignment and transportation

                  problems},

  journal =      {Management Science},

  year =         1967,

  volume =       14,

  pages =        {205-220}

}

@inproceedings{goldberg88cyclecanceling,

  author =       {Andrew V. Goldberg and Robert E. Tarjan},

  title =        {Finding minimum-cost circulations by canceling

                  negative cycles},

  booktitle =    {STOC '88: Proceedings of the Twentieth Annual ACM

                  Symposium on Theory of Computing},

  year =         1988,

  publisher =    {ACM Press},

  address =      {New York, NY},

  pages =        {388-397}

}

@article{edmondskarp72theoretical,

  author =       {Jack Edmonds and Richard M. Karp},

  title =        {Theoretical improvements in algorithmic efficiency

                  for network flow problems},

  journal =      {Journal of the ACM},

  year =         1972,

  volume =       19,

  number =       2,

  pages =        {248-264}

}

@inproceedings{goldberg87approximation,

  author =       {Andrew V. Goldberg and Robert E. Tarjan},

  title =        {Solving minimum-cost flow problems by successive

                  approximation},

  booktitle =    {STOC '87: Proceedings of the Nineteenth Annual ACM

                  Symposium on Theory of Computing},

  year =         1987,

  publisher =    {ACM Press},

  address =      {New York, NY},

  pages =        {7-18}

}

@article{goldberg90finding,

  author =       {Andrew V. Goldberg and Robert E. Tarjan},

  title =        {Finding Minimum-Cost Circulations by Successive

                  Approximation},

  journal =      {Mathematics of Operations Research},

  year =         1990,

  volume =       15,

  number =       3,

  pages =        {430-466}

}

@article{goldberg97efficient,

  author =       {Andrew V. Goldberg},

  title =        {An Efficient Implementation of a Scaling

                  Minimum-Cost Flow Algorithm},

  journal =      {Journal of Algorithms},

  year =         1997,

  volume =       22,

  number =       1,

  pages =        {1-29}

}

@article{bunnagel98efficient,

  author =       {Ursula B{\"u}nnagel and Bernhard Korte and Jens

                  Vygen},

  title =        {Efficient implementation of the {G}oldberg-{T}arjan

                  minimum-cost flow algorithm},

  journal =      {Optimization Methods and Software},

  year =         1998,

  volume =       10,

  pages =        {157-174}

}

@mastersthesis{kellyoneill91netsimplex,

  author =       {Damian J. Kelly and Garrett M. O'Neill},

  title =        {The Minimum Cost Flow Problem and The Network

                  Simplex Method},

  school =       {University College},

  address =      {Dublin, Ireland},

  year =         1991,

  month =        sep,

}

@techreport{lobel96networksimplex,

  author =       {Andreas L{\"o}bel},

  title =        {Solving large-scale real-world minimum-cost flow

                  problems by a network simplex method},

  institution =  {Konrad-Zuse-Zentrum fur Informationstechnik Berlin

                  ({ZIB})},

  address =      {Berlin, Germany},

  year =         1996,

  number =       {SC 96-7}

}

@article{frangioni06computational,

  author =       {Antonio Frangioni and Antonio Manca},

  title =        {A Computational Study of Cost Reoptimization for

                  Min-Cost Flow Problems},

  journal =      {INFORMS Journal On Computing},

  year =         2006,

  volume =       18,

  number =       1,

  pages =        {61-70}

}

#!/usr/bin/env /usr/local/Python/bin/python2.1

"""

  BibTeX to Doxygen converter

  Usage: python bib2dox.py bibfile.bib > bibfile.dox

  This code is the modification of the BibTeX to XML converter

  by Vidar Bronken Gundersen et al. See the original copyright notices below. 

  **********************************************************************

  Decoder for bibliographic data, BibTeX

  Usage: python bibtex2xml.py bibfile.bib > bibfile.xml

  v.8

  (c)2002-06-23 Vidar Bronken Gundersen

  http://bibtexml.sf.net/

  Reuse approved as long as this notification is kept.

  Licence: GPL.

  Contributions/thanks to:

  Egon Willighagen, http://sf.net/projects/jreferences/

  Richard Mahoney (for providing a test case)

  Editted by Sara Sprenkle to be more robust and handle more bibtex features.

  (c) 2003-01-15

  1.  Changed bibtex: tags to bibxml: tags.

  2.  Use xmlns:bibxml="http://bibtexml.sf.net/"

  3.  Allow spaces between @type and first {

  4.  "author" fields with multiple authors split by " and "

      are put in separate xml "bibxml:author" tags.

  5.  Option for Titles: words are capitalized

      only if first letter in title or capitalized inside braces

  6.  Removes braces from within field values

  7.  Ignores comments in bibtex file (including @comment{ or % )

  8.  Replaces some special latex tags, e.g., replaces ~ with ' '

  9.  Handles bibtex @string abbreviations

        --> includes bibtex's default abbreviations for months

        --> does concatenation of abbr # " more " and " more " # abbr

  10. Handles @type( ... ) or @type{ ... }

  11. The keywords field is split on , or ; and put into separate xml

      "bibxml:keywords" tags

  12. Ignores @preamble

  Known Limitations

  1.  Does not transform Latex encoding like math mode and special

      latex symbols.

  2.  Does not parse author fields into first and last names.

      E.g., It does not do anything special to an author whose name is

      in the form LAST_NAME, FIRST_NAME

      In "author" tag, will show up as

      <bibxml:author>LAST_NAME, FIRST_NAME</bibxml:author>

  3.  Does not handle "crossref" fields other than to print

      <bibxml:crossref>...</bibxml:crossref>

  4.  Does not inform user of the input's format errors.  You just won't

      be able to transform the file later with XSL

  You will have to manually edit the XML output if you need to handle

  these (and unknown) limitations.

"""

import string, re

# set of valid name characters

valid_name_chars = '[\w\-:]'

#

# define global regular expression variables

#

author_rex = re.compile('\s+and\s+')

rembraces_rex = re.compile('[{}]')

capitalize_rex = re.compile('({\w*})')

# used by bibtexkeywords(data)

keywords_rex = re.compile('[,;]')

# used by concat_line(line)

concatsplit_rex = re.compile('\s*#\s*')

# split on {, }, or " in verify_out_of_braces

delimiter_rex = re.compile('([{}"])',re.I)

field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')

url_rex = re.compile('\\\url\{([^}]*)\}')

#

# return the string parameter without braces

#

def transformurls(str):

    return url_rex.sub(r'<a href="\1">\1</a>', str)

#

# return the string parameter without braces

#

def removebraces(str):

    return rembraces_rex.sub('', str)

#

# latex-specific replacements

# (do this after braces were removed)

#

def latexreplacements(line):

    line = string.replace(line, '~', ' ')

    line = string.replace(line, '\\\'a', 'á')

    line = string.replace(line, '\\"a', 'ä')

    line = string.replace(line, '\\\'e', 'é')

    line = string.replace(line, '\\"e', 'ë')

    line = string.replace(line, '\\\'i', 'í')

    line = string.replace(line, '\\"i', 'ï')

    line = string.replace(line, '\\\'o', 'ó')

    line = string.replace(line, '\\"o', 'ö')

    line = string.replace(line, '\\\'u', 'ú')

    line = string.replace(line, '\\"u', 'ü')

    line = string.replace(line, '\\H o', 'õ')

    line = string.replace(line, '\\H u', 'ü')   # ũ does not exist

    line = string.replace(line, '\\\'A', 'Á')

    line = string.replace(line, '\\"A', 'Ä')

    line = string.replace(line, '\\\'E', 'É')

    line = string.replace(line, '\\"E', 'Ë')

    line = string.replace(line, '\\\'I', 'Í')

    line = string.replace(line, '\\"I', 'Ï')

    line = string.replace(line, '\\\'O', 'Ó')

    line = string.replace(line, '\\"O', 'Ö')

    line = string.replace(line, '\\\'U', 'Ú')

    line = string.replace(line, '\\"U', 'Ü')

    line = string.replace(line, '\\H O', 'Õ')

    line = string.replace(line, '\\H U', 'Ü')   # Ũ does not exist

    return line

#

# copy characters form a string decoding html expressions (&xyz;)

#

def copychars(str, ifrom, count):

    result = ''

    i = ifrom

    c = 0

    html_spec = False

    while (i < len(str)) and (c < count):

        if str[i] == '&':

            html_spec = True;

            if i+1 < len(str):

                result += str[i+1]

            c += 1

            i += 2

        else:

            if not html_spec:

                if ((str[i] >= 'A') and (str[i] <= 'Z')) or \

                   ((str[i] >= 'a') and (str[i] <= 'z')):

                    result += str[i]

                    c += 1

            elif str[i] == ';':

                html_spec = False;

            i += 1

    return result

# 

# Handle a list of authors (separated by 'and').

# It gives back an array of the follwing values:

#  - num: the number of authors,

#  - list: the list of the author names,

#  - text: the bibtex text (separated by commas and/or 'and')

#  - abbrev: abbreviation that can be used for indicate the

#    bibliography entries

#

def bibtexauthor(data):

    result = {}

    bibtex = ''

    result['list'] = author_rex.split(data)

    result['num'] = len(result['list'])

    for i, author in enumerate(result['list']):

        # general transformations

        author = latexreplacements(removebraces(author.strip()))

        # transform "Xyz, A. B." to "A. B. Xyz"

        pos = author.find(',')

        if pos != -1:

            author = author[pos+1:].strip() + ' ' + author[:pos].strip()

        result['list'][i] = author

        bibtex += author + '#'

    bibtex = bibtex[:-1]

    if result['num'] > 1:

        ix = bibtex.rfind('#')

        if result['num'] == 2:

            bibtex = bibtex[:ix] + ' and ' + bibtex[ix+1:]

        else:

            bibtex = bibtex[:ix] + ', and ' + bibtex[ix+1:]

    bibtex = bibtex.replace('#', ', ')

    result['text'] = bibtex

    result['abbrev'] = ''

    for author in result['list']:

        pos = author.rfind(' ') + 1

        count = 1

        if result['num'] == 1:

            count = 3

        result['abbrev'] += copychars(author, pos, count)

    return result

#

# data = title string

# @return the capitalized title (first letter is capitalized), rest are capitalized

# only if capitalized inside braces

#

def capitalizetitle(data):

    title_list = capitalize_rex.split(data)

    title = ''

    count = 0

    for phrase in title_list:

         check = string.lstrip(phrase)

         # keep phrase's capitalization the same

         if check.find('{') == 0:

              title += removebraces(phrase)

         else:

         # first word --> capitalize first letter (after spaces)

              if count == 0:

                  title += check.capitalize()

              else:

                  title += phrase.lower()

         count = count + 1

    return title

#

# @return the bibtex for the title

# @param data --> title string

# braces are removed from title

#

def bibtextitle(data, entrytype):

    if entrytype in ('book', 'inbook'):

        title = removebraces(data.strip())

    else:

        title = removebraces(capitalizetitle(data.strip()))

    bibtex = title

    return bibtex

#

# function to compare entry lists

#

def entry_cmp(x, y):

    return cmp(x[0], y[0])

#

# print the XML for the transformed "filecont_source"

#

def bibtexdecoder(filecont_source):

    filecont = []

    file = []

    # want @<alphanumeric chars><spaces>{<spaces><any chars>,

    pubtype_rex = re.compile('@(\w*)\s*{\s*(.*),')

    endtype_rex = re.compile('}\s*$')

    endtag_rex = re.compile('^\s*}\s*$')

    bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

    bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?')

    quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

    quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?')

    for line in filecont_source:

        line = line[:-1]

        # encode character entities

        line = string.replace(line, '&', '&')

        line = string.replace(line, '<', '&lt;')

        line = string.replace(line, '>', '>')

        # start entry: publication type (store for later use)

        if pubtype_rex.match(line):

        # want @<alphanumeric chars><spaces>{<spaces><any chars>,

            entrycont = {}

            entry = []

            entrytype = pubtype_rex.sub('\g<1>',line)

            entrytype = string.lower(entrytype)

            # entryid   = pubtype_rex.sub('\g<2>', line)

        # end entry if just a }

        elif endtype_rex.match(line):

            # generate doxygen code for the entry

            # enty type related formattings

            if entrytype in ('book', 'inbook'):

                entrycont['title'] = '<em>' + entrycont['title'] + '</em>'

                if not entrycont.has_key('author'):

                    entrycont['author'] = entrycont['editor']

                    entrycont['author']['text'] += ', editors'

            elif entrytype == 'article':

                entrycont['journal'] = '<em>' + entrycont['journal'] + '</em>'

            elif entrytype in ('inproceedings', 'incollection', 'conference'):

                entrycont['booktitle'] = '<em>' + entrycont['booktitle'] + '</em>'

            elif entrytype == 'techreport':

                if not entrycont.has_key('type'):

                    entrycont['type'] = 'Technical report'

            elif entrytype == 'mastersthesis':

                entrycont['type'] = 'Master\'s thesis'

            elif entrytype == 'phdthesis':

                entrycont['type'] = 'PhD thesis'

            for eline in entrycont:

                if eline != '':

                    eline = latexreplacements(eline)

            if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                entrycont['pages'] = string.replace(entrycont['pages'], '--', '-')

            if entrycont.has_key('author') and (entrycont['author'] != ''):

                entry.append(entrycont['author']['text'] + '.')

            if entrycont.has_key('title') and (entrycont['title'] != ''):

                entry.append(entrycont['title'] + '.')

            if entrycont.has_key('journal') and (entrycont['journal'] != ''):

                entry.append(entrycont['journal'] + ',')

            if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''):

                entry.append('In ' + entrycont['booktitle'] + ',')

            if entrycont.has_key('type') and (entrycont['type'] != ''):

                eline = entrycont['type']

                if entrycont.has_key('number') and (entrycont['number'] != ''):

                    eline += ' ' + entrycont['number']

                eline += ','

                entry.append(eline)

            if entrycont.has_key('institution') and (entrycont['institution'] != ''):

                entry.append(entrycont['institution'] + ',')

            if entrycont.has_key('publisher') and (entrycont['publisher'] != ''):

                entry.append(entrycont['publisher'] + ',')

            if entrycont.has_key('school') and (entrycont['school'] != ''):

                entry.append(entrycont['school'] + ',')

            if entrycont.has_key('address') and (entrycont['address'] != ''):

                entry.append(entrycont['address'] + ',')

            if entrycont.has_key('edition') and (entrycont['edition'] != ''):

                entry.append(entrycont['edition'] + ' edition,')

            if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''):

                entry.append(entrycont['howpublished'] + ',')

            if entrycont.has_key('volume') and (entrycont['volume'] != ''):

                eline = entrycont['volume'];

                if entrycont.has_key('number') and (entrycont['number'] != ''):

                    eline += '(' + entrycont['number'] + ')'

                if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                    eline += ':' + entrycont['pages']

                eline += ','

                entry.append(eline)

            else:

                if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                    entry.append('pages ' + entrycont['pages'] + ',')

            if entrycont.has_key('year') and (entrycont['year'] != ''):

                if entrycont.has_key('month') and (entrycont['month'] != ''):

                    entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.')

                else:

                    entry.append(entrycont['year'] + '.')

            if entrycont.has_key('note') and (entrycont['note'] != ''):

                entry.append(entrycont['note'] + '.')

            # generate keys for sorting and for the output

            sortkey = ''

            bibkey = ''

            if entrycont.has_key('author'):

                for author in entrycont['author']['list']:

                    sortkey += copychars(author, author.rfind(' ')+1, len(author))

                bibkey = entrycont['author']['abbrev']

            else:

                bibkey = 'x'

            if entrycont.has_key('year'):

                sortkey += entrycont['year']

                bibkey += entrycont['year'][-2:]

            if entrycont.has_key('title'):

                sortkey += entrycont['title']

            if entrycont.has_key('key'):

                sortkey = entrycont['key'] + sortkey

                bibkey = entrycont['key']

            entry.insert(0, sortkey)

            entry.insert(1, bibkey)

            # add the entry to the file contents

            filecont.append(entry)

        else:

            # field, publication info

            field = ''

            data = ''

            # field = {data} entries

            if bracedata_rex.match(line):

                field = bracefield_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  bracedata_rex.sub('\g<2>', line)

            # field = "data" entries

            elif quotedata_rex.match(line):

                field = quotefield_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  quotedata_rex.sub('\g<2>', line)

            # field = data entries

            elif data_rex.match(line):

                field = field_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  data_rex.sub('\g<2>', line)

            if field in ('author', 'editor'):

                entrycont[field] = bibtexauthor(data)

                line = ''

            elif field == 'title':

                line = bibtextitle(data, entrytype)

            elif field != '':

                line = removebraces(transformurls(data.strip()))

            if line != '':

                line = latexreplacements(line)

                entrycont[field] = line

    # sort entries

    filecont.sort(entry_cmp)

    # count the bibtex keys

    keytable = {}

    counttable = {}

    for entry in filecont:

        bibkey = entry[1]

        if not keytable.has_key(bibkey):

            keytable[bibkey] = 1

        else:

            keytable[bibkey] += 1

    for bibkey in keytable.keys():

        counttable[bibkey] = 0

    # generate output

    for entry in filecont:

        # generate output key form the bibtex key

        bibkey = entry[1]

        if keytable[bibkey] == 1:

            outkey = bibkey

        else:

            outkey = bibkey + chr(97 + counttable[bibkey])

        counttable[bibkey] += 1

        # append the entry code to the output

        file.append('<tr valign="top">\n' + \

                    '<td>[' + outkey + ']</td>')

        file.append('<td>')

        file.append('\\anchor ' + outkey)

        for line in entry[2:]:

            file.append(line)

        file.append('</td>\n</tr>')

        file.append('')

    return file

#

# return 1 iff abbr is in line but not inside braces or quotes

# assumes that abbr appears only once on the line (out of braces and quotes)

#

def verify_out_of_braces(line, abbr):

    phrase_split = delimiter_rex.split(line)

    abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I)

    open_brace = 0

    open_quote = 0

    for phrase in phrase_split:

        if phrase == "{":

            open_brace = open_brace + 1

        elif phrase == "}":

            open_brace = open_brace - 1

        elif phrase == '"':

            if open_quote == 1:

                open_quote = 0

            else:

                open_quote = 1

        elif abbr_rex.search(phrase):

            if open_brace == 0 and open_quote == 0:

                return 1

    return 0

#

# a line in the form phrase1 # phrase2 # ... # phrasen

# is returned as phrase1 phrase2 ... phrasen

# with the correct punctuation

# Bug: Doesn't always work with multiple abbreviations plugged in

#

def concat_line(line):

    # only look at part after equals

    field = field_rex.sub('\g<1>',line)

    rest = field_rex.sub('\g<2>',line)

    concat_line = field + ' ='

    pound_split = concatsplit_rex.split(rest)

    phrase_count = 0

    length = len(pound_split)

    for phrase in pound_split:

        phrase = phrase.strip()

        if phrase_count != 0:

            if phrase.startswith('"') or phrase.startswith('{'):

                phrase = phrase[1:]

        elif phrase.startswith('"'):

            phrase = phrase.replace('"','{',1)

        if phrase_count != length-1:

            if phrase.endswith('"') or phrase.endswith('}'):

                phrase = phrase[:-1]

        else:

            if phrase.endswith('"'):

                phrase = phrase[:-1]

                phrase = phrase + "}"

            elif phrase.endswith('",'):

                phrase = phrase[:-2]

                phrase = phrase + "},"

        # if phrase did have \#, add the \# back

        if phrase.endswith('\\'):

            phrase = phrase + "#"

        concat_line = concat_line + ' ' + phrase

        phrase_count = phrase_count + 1

    return concat_line

#

# substitute abbreviations into filecont

# @param filecont_source - string of data from file

#

def bibtex_replace_abbreviations(filecont_source):

    filecont = filecont_source.splitlines()

    #  These are defined in bibtex, so we'll define them too

    abbr_list = ['jan','feb','mar','apr','may','jun',

                 'jul','aug','sep','oct','nov','dec']

    value_list = ['January','February','March','April',

                  'May','June','July','August','September',

                  'October','November','December']

    abbr_rex = []

    total_abbr_count = 0

    front = '\\b'

    back = '(,?)\\b'

    for x in abbr_list:

        abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )

        total_abbr_count = total_abbr_count + 1

    abbrdef_rex = re.compile('\s*@string\s*{\s*('+ valid_name_chars +'*)\s*=(.*)',

                             re.I)

    comment_rex = re.compile('@comment\s*{',re.I)

    preamble_rex = re.compile('@preamble\s*{',re.I)

    waiting_for_end_string = 0

    i = 0

    filecont2 = ''

    for line in filecont:

        if line == ' ' or line == '':

            continue

        if waiting_for_end_string:

            if re.search('}',line):

                waiting_for_end_string = 0

                continue

        if abbrdef_rex.search(line):

            abbr = abbrdef_rex.sub('\g<1>', line)

            if abbr_list.count(abbr) == 0:

                val = abbrdef_rex.sub('\g<2>', line)

                abbr_list.append(abbr)

                value_list.append(string.strip(val))

                abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )

                total_abbr_count = total_abbr_count + 1

            waiting_for_end_string = 1

            continue

        if comment_rex.search(line):

            waiting_for_end_string = 1

            continue

        if preamble_rex.search(line):

            waiting_for_end_string = 1

            continue

        # replace subsequent abbreviations with the value

        abbr_count = 0

        for x in abbr_list:

            if abbr_rex[abbr_count].search(line):

                if verify_out_of_braces(line,abbr_list[abbr_count]) == 1:

                    line = abbr_rex[abbr_count].sub( value_list[abbr_count] + '\g<1>', line)

                # Check for # concatenations

                if concatsplit_rex.search(line):

                    line = concat_line(line)

            abbr_count = abbr_count + 1

        filecont2 = filecont2 + line + '\n'

        i = i+1

    # Do one final pass over file

    # make sure that didn't end up with {" or }" after the substitution

    filecont2 = filecont2.replace('{"','{{')

    filecont2 = filecont2.replace('"}','}}')

    afterquotevalue_rex = re.compile('"\s*,\s*')

    afterbrace_rex = re.compile('"\s*}')

    afterbracevalue_rex = re.compile('(=\s*{[^=]*)},\s*')

    # add new lines to data that changed because of abbreviation substitutions

    filecont2 = afterquotevalue_rex.sub('",\n', filecont2)

    filecont2 = afterbrace_rex.sub('"\n}', filecont2)

    filecont2 = afterbracevalue_rex.sub('\g<1>},\n', filecont2)

    return filecont2

#

# convert @type( ... ) to @type{ ... }

#

def no_outer_parens(filecont):

    # do checking for open parens

    # will convert to braces

    paren_split = re.split('([(){}])',filecont)

    open_paren_count = 0

    open_type = 0

    look_next = 0

    # rebuild filecont

    filecont = ''

    at_rex = re.compile('@\w*')

    for phrase in paren_split:

        if look_next == 1:

            if phrase == '(':

                phrase = '{'

                open_paren_count = open_paren_count + 1

            else:

                open_type = 0

            look_next = 0

        if phrase == '(':

            open_paren_count = open_paren_count + 1

        elif phrase == ')':

            open_paren_count = open_paren_count - 1

            if open_type == 1 and open_paren_count == 0:

                phrase = '}'

                open_type = 0

        elif at_rex.search( phrase ):

            open_type = 1

            look_next = 1

        filecont = filecont + phrase

    return filecont

#

# make all whitespace into just one space

# format the bibtex file into a usable form.

#

def bibtexwasher(filecont_source):

    space_rex = re.compile('\s+')

    comment_rex = re.compile('\s*%')

    filecont = []

    # remove trailing and excessive whitespace

    # ignore comments

    for line in filecont_source:

        line = string.strip(line)

        line = space_rex.sub(' ', line)

        # ignore comments

        if not comment_rex.match(line) and line != '':

            filecont.append(' '+ line)

    filecont = string.join(filecont, '')

    # the file is in one long string

    filecont = no_outer_parens(filecont)

    #

    # split lines according to preferred syntax scheme

    #

    filecont = re.sub('(=\s*{[^=]*)},', '\g<1>},\n', filecont)

    # add new lines after commas that are after values

    filecont = re.sub('"\s*,', '",\n', filecont)

    filecont = re.sub('=\s*([\w\d]+)\s*,', '= \g<1>,\n', filecont)

    filecont = re.sub('(@\w*)\s*({(\s*)[^,\s]*)\s*,',

                          '\n\n\g<1>\g<2>,\n', filecont)

    # add new lines after }

    filecont = re.sub('"\s*}','"\n}\n', filecont)

    filecont = re.sub('}\s*,','},\n', filecont)

    filecont = re.sub('@(\w*)', '\n@\g<1>', filecont)

    # character encoding, reserved latex characters

    filecont = re.sub('{\\\&}', '&', filecont)

    filecont = re.sub('\\\&', '&', filecont)

    # do checking for open braces to get format correct

    open_brace_count = 0

    brace_split = re.split('([{}])',filecont)

    # rebuild filecont

    filecont = ''

    for phrase in brace_split:

        if phrase == '{':

            open_brace_count = open_brace_count + 1

        elif phrase == '}':

            open_brace_count = open_brace_count - 1

            if open_brace_count == 0:

                filecont = filecont + '\n'

        filecont = filecont + phrase

    filecont2 = bibtex_replace_abbreviations(filecont)

    # gather

    filecont = filecont2.splitlines()

    i=0

    j=0         # count the number of blank lines

    for line in filecont:

        # ignore blank lines

        if line == '' or line == ' ':

            j = j+1

            continue

        filecont[i] = line + '\n'

        i = i+1

    # get rid of the extra stuff at the end of the array

    # (The extra stuff are duplicates that are in the array because

    # blank lines were removed.)

    length = len( filecont)

    filecont[length-j:length] = []

    return filecont

def filehandler(filepath):

    try:

        fd = open(filepath, 'r')

        filecont_source = fd.readlines()