Task 061: .BIB File Format
Task 061: .BIB File Format
File Format Specifications for .BIB
The .BIB file format refers to the BibTeX bibliography format, a plain-text structure used for managing bibliographic references in LaTeX documents. It was designed by Oren Patashnik and Leslie Lamport in 1985. BibTeX files store entries in a human-readable format, typically with multiple reference records. Each file uses ASCII or UTF-8 encoding and has no binary header or magic number, as it is text-based. The structure includes optional elements like @string definitions for abbreviations, @preamble for custom LaTeX code, and comments (lines starting with % or text outside entries). The core content consists of bibliographic entries formatted as:
@ENTRYTYPE{citekey,
field1 = {value1},
field2 = "value2",
...
}
- ENTRYTYPE: Defines the reference type (case-insensitive, e.g., @article, @book).
- citekey: A unique alphanumeric identifier (may include -, _, :).
- fields: Key-value pairs separated by commas, with values enclosed in {} or "" (braces support nesting for formatting).
Values can be strings, numbers, or macros defined via @string. Entries are separated by newlines, and the file can include arbitrary whitespace.
For full details, refer to the official BibTeX documentation or resources like the BibTeX format guide.
- List of All Properties Intrinsic to This File Format
Since .BIB (BibTeX) is a text-based format without binary structures, "properties intrinsic to its file system" are interpreted as the standard bibliographic fields defined in the format specification. These fields store the metadata for each entry and are the core elements parsed from the file. Not all fields are required or applicable to every entry type; some are optional. The standard fields are:
- address: Publisher's or institution's address.
- annote: Annotation or notes.
- author: Author names (multiple separated by "and").
- booktitle: Title of the book (for parts of books).
- chapter: Chapter number.
- edition: Edition of the book.
- editor: Editor names (multiple separated by "and").
- howpublished: How the work was published (for unusual types).
- institution: Institution sponsoring the work.
- journal: Journal or magazine name.
- month: Publication month.
- note: Miscellaneous notes.
- number: Issue number or report number.
- organization: Organization sponsoring the conference or manual.
- pages: Page numbers or range.
- publisher: Publisher's name.
- school: Academic institution for theses.
- series: Book series name.
- title: Title of the work.
- type: Type of technical report or thesis.
- volume: Volume number.
- year: Publication year.
Additional non-standard fields (e.g., doi, url, isbn) may appear in modern usage but are not part of the core specification.
- Two Direct Download Links for .BIB Files
- https://www.math.sci.hokudai.ac.jp/sympo/fpsac2025/tex/sample.bib (Sample bibliography for FPSAC submissions)
- https://mirror.math.princeton.edu/pub/CTAN/macros/latex/contrib/asmejour/asmejour-sample.bib (Sample bibliography for ASME journal style)
- Ghost Blog Embedded HTML JavaScript for Drag-and-Drop .BIB File Dump
Below is self-contained HTML code with embedded JavaScript that can be embedded in a Ghost blog post (or any HTML page). It creates a drag-and-drop area where users can drop a .BIB file. The script reads the file as text, parses it using a simple regex-based parser to extract entries and their properties (from the list above), and dumps them to the screen in a readable format. It handles basic BibTeX syntax but may not cover all edge cases like nested braces or macros.
Drag and drop a .BIB file here
- Python Class for .BIB File Handling
Below is a Python class BibHandler that can open a .BIB file, parse it (read/decode as text), extract and print the properties (fields from the list), and write a new or modified .BIB file. It uses a simple parser with regex for basic cases.
import re
import json # For pretty-printing, optional
class BibHandler:
def __init__(self):
self.entries = []
def read(self, filepath):
with open(filepath, 'r', encoding='utf-8') as f:
content = f.read()
self.parse(content)
def parse(self, content):
self.entries = []
entry_regex = re.compile(r'@(\w+)\s*{\s*([^,]+)\s*,([^@]*)}', re.DOTALL | re.IGNORECASE)
for match in entry_regex.finditer(content):
entry_type = match.group(1).lower()
citekey = match.group(2).strip()
fields_str = match.group(3)
fields = {}
field_regex = re.compile(r'(\w+)\s*=\s*(?:"([^"]*)"|\{([^{}]*)\})', re.DOTALL | re.IGNORECASE)
for fmatch in field_regex.finditer(fields_str):
key = fmatch.group(1).lower()
value = fmatch.group(2) or fmatch.group(3)
fields[key] = value.strip() if value else ''
self.entries.append({'entry_type': entry_type, 'citekey': citekey, 'fields': fields})
def print_properties(self):
for entry in self.entries:
print(f"Entry: @{entry['entry_type']}{{{entry['citekey']}}}")
for prop in ['address', 'annote', 'author', 'booktitle', 'chapter', 'edition', 'editor', 'howpublished',
'institution', 'journal', 'month', 'note', 'number', 'organization', 'pages', 'publisher',
'school', 'series', 'title', 'type', 'volume', 'year']:
if prop in entry['fields']:
print(f" {prop}: {entry['fields'][prop]}")
print()
def write(self, filepath):
with open(filepath, 'w', encoding='utf-8') as f:
for entry in self.entries:
f.write(f"@{entry['entry_type']}{{{entry['citekey']},\n")
for key, value in entry['fields'].items():
f.write(f" {key} = {{{value}}},\n")
f.write("}\n\n")
# Example usage:
# handler = BibHandler()
# handler.read('sample.bib')
# handler.print_properties()
# handler.write('output.bib')
- Java Class for .BIB File Handling
Below is a Java class BibHandler that opens a .BIB file, parses it, prints the properties, and writes a new file. It uses regex for parsing.
import java.io.*;
import java.util.*;
import java.util.regex.*;
public class BibHandler {
private List<Map<String, Object>> entries = new ArrayList<>();
public void read(String filepath) throws IOException {
StringBuilder content = new StringBuilder();
try (BufferedReader br = new BufferedReader(new FileReader(filepath))) {
String line;
while ((line = br.readLine()) != null) {
content.append(line).append("\n");
}
}
parse(content.toString());
}
private void parse(String content) {
entries.clear();
Pattern entryPattern = Pattern.compile("@(\\w+)\\s*\\{\\s*([^,]+)\\s*,([^@]*)}", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
Matcher entryMatcher = entryPattern.matcher(content);
while (entryMatcher.find()) {
String entryType = entryMatcher.group(1).toLowerCase();
String citekey = entryMatcher.group(2).trim();
String fieldsStr = entryMatcher.group(3);
Map<String, String> fields = new HashMap<>();
Pattern fieldPattern = Pattern.compile("(\\w+)\\s*=\\s*(?:\"([^\"]*)\"|\\{([^}]*)\\})", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
Matcher fieldMatcher = fieldPattern.matcher(fieldsStr);
while (fieldMatcher.find()) {
String key = fieldMatcher.group(1).toLowerCase();
String value = fieldMatcher.group(2) != null ? fieldMatcher.group(2) : fieldMatcher.group(3);
fields.put(key, value.trim());
}
Map<String, Object> entry = new HashMap<>();
entry.put("entry_type", entryType);
entry.put("citekey", citekey);
entry.put("fields", fields);
entries.add(entry);
}
}
public void printProperties() {
String[] props = {"address", "annote", "author", "booktitle", "chapter", "edition", "editor", "howpublished",
"institution", "journal", "month", "note", "number", "organization", "pages", "publisher",
"school", "series", "title", "type", "volume", "year"};
for (Map<String, Object> entry : entries) {
System.out.println("Entry: @" + entry.get("entry_type") + "{" + entry.get("citekey") + "}");
@SuppressWarnings("unchecked")
Map<String, String> fields = (Map<String, String>) entry.get("fields");
for (String prop : props) {
if (fields.containsKey(prop)) {
System.out.println(" " + prop + ": " + fields.get(prop));
}
}
System.out.println();
}
}
public void write(String filepath) throws IOException {
try (BufferedWriter bw = new BufferedWriter(new FileWriter(filepath))) {
for (Map<String, Object> entry : entries) {
bw.write("@" + entry.get("entry_type") + "{" + entry.get("citekey") + ",\n");
@SuppressWarnings("unchecked")
Map<String, String> fields = (Map<String, String>) entry.get("fields");
for (Map.Entry<String, String> field : fields.entrySet()) {
bw.write(" " + field.getKey() + " = {" + field.getValue() + "},\n");
}
bw.write("}\n\n");
}
}
}
// Example usage:
// public static void main(String[] args) throws IOException {
// BibHandler handler = new BibHandler();
// handler.read("sample.bib");
// handler.printProperties();
// handler.write("output.bib");
// }
}
- JavaScript Class for .BIB File Handling
Below is a JavaScript class BibHandler (using Node.js for file I/O). It reads a .BIB file, parses it, prints properties to console, and writes a new file. Requires fs module.
const fs = require('fs');
class BibHandler {
constructor() {
this.entries = [];
}
read(filepath) {
const content = fs.readFileSync(filepath, 'utf-8');
this.parse(content);
}
parse(content) {
this.entries = [];
const entryRegex = /@(\w+)\s*{\s*([^,]+)\s*,([^@]*)}/gsi;
let match;
while ((match = entryRegex.exec(content)) !== null) {
const entryType = match[1].toLowerCase();
const citekey = match[2].trim();
const fieldsStr = match[3];
const fields = {};
const fieldRegex = /(\w+)\s*=\s*(?:"([^"]*)"|{([^}]*)})/gsi;
let fieldMatch;
while ((fieldMatch = fieldRegex.exec(fieldsStr)) !== null) {
const key = fieldMatch[1].toLowerCase();
const value = fieldMatch[2] || fieldMatch[3];
fields[key] = value.trim();
}
this.entries.push({ entryType, citekey, fields });
}
}
printProperties() {
const props = ['address', 'annote', 'author', 'booktitle', 'chapter', 'edition', 'editor', 'howpublished',
'institution', 'journal', 'month', 'note', 'number', 'organization', 'pages', 'publisher',
'school', 'series', 'title', 'type', 'volume', 'year'];
this.entries.forEach(entry => {
console.log(`Entry: @${entry.entryType}{${entry.citekey}}`);
props.forEach(prop => {
if (entry.fields[prop]) {
console.log(` ${prop}: ${entry.fields[prop]}`);
}
});
console.log('');
});
}
write(filepath) {
let output = '';
this.entries.forEach(entry => {
output += `@${entry.entryType}{${entry.citekey},\n`;
Object.keys(entry.fields).forEach(key => {
output += ` ${key} = {${entry.fields[key]}},\n`;
});
output += '}\n\n';
});
fs.writeFileSync(filepath, output, 'utf-8');
}
}
// Example usage:
// const handler = new BibHandler();
// handler.read('sample.bib');
// handler.printProperties();
// handler.write('output.bib');
- C++ Class for .BIB File Handling
Below is a C++ class BibHandler that opens a .BIB file, parses it, prints properties to console, and writes a new file. It uses <regex> for parsing (requires C++11 or later).
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <regex>
class BibHandler {
private:
struct Entry {
std::string entry_type;
std::string citekey;
std::map<std::string, std::string> fields;
};
std::vector<Entry> entries;
public:
void read(const std::string& filepath) {
std::ifstream file(filepath);
if (!file) {
std::cerr << "Error opening file: " << filepath << std::endl;
return;
}
std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
parse(content);
}
void parse(const std::string& content) {
entries.clear();
std::regex entry_regex(R"(@(\w+)\s*\{\s*([^,]+)\s*,([^@]*)\})", std::regex::icase | std::regex::ECMAScript);
auto entries_begin = std::sregex_iterator(content.begin(), content.end(), entry_regex);
auto entries_end = std::sregex_iterator();
for (std::sregex_iterator i = entries_begin; i != entries_end; ++i) {
std::smatch match = *i;
std::string entry_type = match[1].str();
std::transform(entry_type.begin(), entry_type.end(), entry_type.begin(), ::tolower);
std::string citekey = match[2].str();
citekey.erase(std::remove_if(citekey.begin(), citekey.end(), ::isspace), citekey.end());
std::string fields_str = match[3].str();
Entry entry;
entry.entry_type = entry_type;
entry.citekey = citekey;
std::regex field_regex(R"((\w+)\s*=\s*(?:"([^"]*)"|\{([^}]*)\}))", std::regex::icase | std::regex::ECMAScript);
auto fields_begin = std::sregex_iterator(fields_str.begin(), fields_str.end(), field_regex);
auto fields_end = std::sregex_iterator();
for (std::sregex_iterator f = fields_begin; f != fields_end; ++f) {
std::smatch fmatch = *f;
std::string key = fmatch[1].str();
std::transform(key.begin(), key.end(), key.begin(), ::tolower);
std::string value = fmatch[2].matched ? fmatch[2].str() : fmatch[3].str();
value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
entry.fields[key] = value;
}
entries.push_back(entry);
}
}
void print_properties() {
std::vector<std::string> props = {"address", "annote", "author", "booktitle", "chapter", "edition", "editor", "howpublished",
"institution", "journal", "month", "note", "number", "organization", "pages", "publisher",
"school", "series", "title", "type", "volume", "year"};
for (const auto& entry : entries) {
std::cout << "Entry: @" << entry.entry_type << "{" << entry.citekey << "}" << std::endl;
for (const auto& prop : props) {
auto it = entry.fields.find(prop);
if (it != entry.fields.end()) {
std::cout << " " << prop << ": " << it->second << std::endl;
}
}
std::cout << std::endl;
}
}
void write(const std::string& filepath) {
std::ofstream file(filepath);
if (!file) {
std::cerr << "Error writing file: " << filepath << std::endl;
return;
}
for (const auto& entry : entries) {
file << "@" << entry.entry_type << "{" << entry.citekey << ",\n";
for (const auto& field : entry.fields) {
file << " " << field.first << " = {" << field.second << "},\n";
}
file << "}\n\n";
}
}
};
// Example usage:
// int main() {
// BibHandler handler;
// handler.read("sample.bib");
// handler.print_properties();
// handler.write("output.bib");
// return 0;
// }