#! /usr/bin/env python

# MMD by David A. Moon is licensed under a
# Creative Commons Attribution-ShareAlike 4.0 International License
# http://creativecommons.org/licenses/by-sa/4.0/
#
# Please inform me if you find this useful, or any of the ideas embedded in it.
# Comments and criticisms to dave underscore moon atsign alum dot mit dot edu.

# Incorporates details_shim by Tyler Uebele licensed as follows:
# 
# Copyright (c) 2013 Tyler Uebele
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to 
# deal in the Software without restriction, including without limitation the 
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
# sell copies of the Software, and to permit persons to whom the Software is 
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in 
# all copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
# THE SOFTWARE.


# Convert MMD to HTML

import codecs
import math
import os
import re
import sys
import time

default_code_style = "display:table; border:1px solid black; background-color:whitesmoke; padding-left:5px; padding-right:5px; padding-top:5px; padding-bottom:5px"

# Global state
# g is bound to it in most functions
class MMD_globals:
  pass

def MMD(input_stream, output_directory):
  self = MMD_globals()
  self.input_stream          = input_stream
  self.output_stream         = False
  self.output_directory      = output_directory
  self.line_number           = 0
  self.title_prefix          = False
  self.page_number           = 0
  self.current_chapter_name  = False
  self.page_titles           = []                #[[chapter [section subsection...]...]...]
  self.all_references        = []          	 #[[see_arg href]...]
  self.all_anchors           = []         	 #{"chapter#anchor"...}
  self.pre_html              = []
  self.post_html             = []
  self.this_page_file        = False
  self.previous_page_file    = False
  self.current_mode          = 'normal'
  self.nesting_level         = 0
  self.code_style            = default_code_style
  return self

dot_handlers = dict()   # maps a string to a list of before, main, after function

# Define the handler(s) with def first, then call this
# Handler arguments are (g, line, directive_name)
def defdot(directive_name, handler, before=None, after=None):
  dot_handlers[directive_name] = [before, handler, after]

# Main Program
def main(argv):
  if len(argv) < 2 or len(argv) > 3:
    print("Usage: mmd input_pathname [output_directory]")
    return 1
  else:
    input_pathname = argv[1]
    output_directory = None
    if len(argv) == 3:
      output_directory = argv[2]
    else:
      output_directory = os.path.join(os.path.dirname(input_pathname), "HTML")
    g = MMD(codecs.open(input_pathname, mode='r', encoding='utf-8'), output_directory)
    try:
      os.mkdir(g.output_directory)
    except OSError:
      pass
    try:
      process_lines(g)
      return 0
    finally:
      g.input_stream.close()
      if g.output_stream:
        g.output_stream.close()

# Process lines until end of input file
def process_lines(g):
  while True:
    line = next_line(g)
    if line == False:
      break
    line2 = line.lstrip()    # Remove leading whitespace
    if len(line2) == 0:
      # Blank line separates paragraphs
      if g.output_stream:
        change_mode(g, 'normal')
        output_raw(g, "<P>")
    elif line2[0] == '.':
      directive_line(g, line2)
    elif line2[0] == '*':
      list_line(g, line2, 'UL')
    elif line2[0] == '#':
      list_line(g, line2, 'OL')
    elif line2[0] == '|':
      table_line(g, line2)
    else:
      change_mode(g, 'normal')
      output_with_flags_and_translations(g, line)
  
  # Input file exhausted
  end_page(g, False)
  
  # Check for broken links
  for x in g.all_references:
    see_arg = x[0]
    href    = x[1]
    if not (href in g.all_anchors):
      error_output("Broken link: .see " + see_arg + "\n")
  
  # Generate index.html file
  index_path = os.path.join(g.output_directory, "index.html")
  g.output_stream = open(index_path, "w")
  output_index(g)
  index_path

# Line Handlers

def undefined_handler(g, line, directive_name):
  error("Unrecognized directive ." + directive_name + " on line " + str(g.line_number))

undefined_handlers = [undefined_handler, undefined_handler, undefined_handler]

def directive_line(g, line):
  change_mode(g, 'normal')
  
  space                 = line.find(" ")
  directive_end         = len(line)
  if space >= 0:
    directive_end = space
  directive_name        = line[1 : directive_end]  # 1 skips initial period
  dot_name              = directive_name.lower()
  handler               = undefined_handlers
  if dot_name in dot_handlers:
    handler = dot_handlers[dot_name]
  before                = handler[0]
  main_handler          = handler[1]
  after                 = handler[2]
  
  if before:
    before(g, line, directive_name)
  
  if space >= 0:
    main_handler(g, line[space+1 : len(line)], directive_name)
  else:
    end_line = ".end " + directive_name
    while True:
      this_line = next_line(g)
      if this_line == False:
        break
      if this_line == end_line:
        break
      main_handler(g, this_line, directive_name)
  
  if after:
    after(g, line, directive_name)

def list_line(g, line, mode):
  change_mode(g, mode)
  
  # number of leading stars or splats
  level = 0
  while level < len(line) and line[level] == line[0]:
    level = level + 1
  
  while g.nesting_level > level:
    output_raw(g, "</" + mode + ">")
    g.nesting_level = g.nesting_level - 1
  
  while g.nesting_level < level:
    type = '1'
    if g.nesting_level < 3:
      type = "1ai"[g.nesting_level]
    if mode == 'UL':
      output_raw(g, "<UL>")
    else:
      output_raw(g, "<OL type=\"" + type + "\">")
    g.nesting_level = g.nesting_level + 1
  
  output_raw(g, "<LI>", newline=False)
  output_with_flags_and_translations(g, line[level : len(line)], newline=False)
  output_raw(g, "</LI>", newline=True)

def enter_UL_mode(g):
  output_raw(g, "<UL>")

def leave_UL_mode(g):
  output_raw(g, "</UL>")

def enter_OL_mode(g):
  output_raw(g, "<OL type=1>")

def leave_OL_mode(g):
  output_raw(g, "</OL>")

def table_line(g, line):
  change_mode(g, 'TABLE')
  if not line.endswith("|"):
    error("Missing closing | in " + line + " on line " + str(g.line_number))
  
  # Parse out the columns of this row
  # A header column will retain an extra | at the start
  # This relies on our special characters all taking one UTF-8 byte to encode
  start   = 1   # position after leading |
  end     = len(line)
  columns = []
  next = start
  while next < end:
    next1 = line.find('|', next)
    next2 = line.find('`', next)
    if next1 < 0 or (next2 >= 0 and next2 < next1):
      next = next2
    else:
      next = next1
    if next < 0:
      error("Parsing error after position " + str(start) + " in " + line + " on line " + str(g.line_number))
    elif next == start and line[next] == '|':
      # Skip over second | in ||
      next = next + 1
    elif line[next] == '`':
      # Skip over | inside of ` pair
      next = line.find('`', next + 2) + 1
    else:
      # | at next is end of column
      columns.append(line[start : next].strip())
      start = next + 1
      next = start
  
  # Output this row
  output_raw(g, "<TR>")
  for column in columns:
    if column.startswith("|"):
      # This is a heading
      output_raw(g, "<TH style=\"border: 1px solid black; padding: 8pt;\">", newline=False)
      output_with_flags_and_translations(g, column[1 : len(column)])
      output_raw(g, "</TH>")
    else:
      # This is a normal row
      output_raw(g, "<TD style=\"border: 1px solid black; padding: 8pt;\">", newline=False)
      output_with_flags_and_translations(g, column)
      output_raw(g, "</TD>")
  
  output_raw(g, "</TR>")

def enter_table_mode(g):
  output_raw(g, "<TABLE style=\"border-collapse: collapse; border: 1px solid black;\">")

def leave_table_mode(g):
  output_raw(g, "</TABLE>")


# Directives

# .chapter, .section, and .subsection produce a table of contents
# in the index.html file.  Each chapter goes in its own .html file.
def chapter(g, line, _):
  if g.output_stream:
    end_page(g, chapter_name(line))
  g.page_titles.append([line, []])               # [chapter]
  g.current_chapter_name = chapter_name(line)
  set_anchor(g, line)
  set_anchor(g, "")
  start_page(g, line)
  output_raw(g, "<h2 id=\"" + anchor_name(line) + "\">" + line + "</h2>")

defdot("chapter", chapter)

def section(g, line, _):
  g.page_titles[-1][1].append([line, []])       #[chapter, [section]]
  set_anchor(g, line)
  output_raw(g, "<h3 id=\"" + anchor_name(line) + "\">" + line + "</h3>")

defdot("section", section)

def subsection(g, line, _):
  g.page_titles[-1][1][-1][1].append(line)      #[chapter, [section, [subsection]]]
  set_anchor(g, line)
  output_raw(g, "<h4 id=\"" + anchor_name(line) + "\">" + line + "</h4>")

defdot("subsection", subsection)

def anchor(g, line, _):
  set_anchor(g, line)
  output_raw(g, "<A id=\"" + anchor_name(line) + "\"/>")

defdot("anchor", anchor)

def set_anchor(g, line):
  g.all_anchors.append(g.current_chapter_name + ".html#" + anchor_name(line))

# Remove all but letters and numbers, change spaces to underscores
def anchor_name(title):
  result = []
  for char in title:       # This iterates over UTF-8 bytes
    if ord(char) < 128 and (char.isalpha() or char.isdigit()):
      result.append(char.lower())
    elif char == ' ':
      result.append('_')
  return "".join(result)

# Remove all but letters and numbers, change spaces to underscores, can't be "index"
def chapter_name(title):
  anchor = anchor_name(title)
  if anchor == "index":
    return "index_"
  else:
    return anchor

# chapter
# #anchor
# chapter#anchor
# Returns [chapter, anchor] where chapter can be false
def decode_see(line):
  sharp   = line.find('#')
  first   = line[0 : (sharp if sharp >= 0 else len(line))]
  second  = line[sharp + 1 : len(line)] if sharp >= 0 else False
  chapter = line if sharp < 0 else first if sharp > 0 else False
  anchor  = second if sharp >= 0 else ""
  return [chapter, anchor]

def make_href(g, line):
  x       = decode_see(line)
  chapter = x[0]
  anchor  = x[1]
  file    = chapter_name(chapter) if chapter else g.current_chapter_name
  return file + ".html#" + anchor_name(anchor)

# .see chapter#anchor
# or .See, output preserves the alphabetic case of the directive
def see(g, line, directive):
  x       = decode_see(line)
  chapter = x[0]
  anchor  = x[1]
  href    = make_href(g, line)
  text    = chapter if anchor == "" else anchor
  g.all_references.append([line, href])
  output_raw(g, directive + " <A href=\"" + href + "\">" + text + "</A>")

defdot("see", see)

# .code displays a block of code
def code(g, line, _):
  output_with_translations(g, line[9:] if line.startswith(".QUOTE!! ") else line)

def before_code(g, line, _):
  output_raw(g, "<PRE style=\"" + g.code_style + "\">")

def after_code(g, line, _):
  output_raw(g, "</PRE>")

defdot("code", code, before=before_code, after=after_code)

def codestyle(g, line, _):
  g.code_style = line
  
defdot("codestyle", codestyle)

# .comment comments-out its directed lines
def comment(g, line, _):
  pass

defdot("comment", comment)

# .html inserts raw HTML directly into the formatted output
def html(g, line, _):
  output_raw(g, line)

defdot("html", html)

def prehtml(g, line, _):
  g.pre_html.append(line)

defdot("prehtml", prehtml)

def posthtml(g, line, _):
  g.post_html.append(line)

defdot("posthtml", posthtml)

# .title inserts a prefix and a colon space before each page title
def title(g, line, _):
  g.title_prefix = line

defdot("title", title)

# .sequence displays a UML sequence diagram

def before_sequence(g, line, _):
  g.sequence_lines = []

def sequence(g, line, _):
  g.sequence_lines.append(line)

def after_sequence(g, line, _):
  # Defaults
  parameters = { 'row height' : 60, 'column width' : 150, 'title size' : 20, 'text size' : 15,
                 'arrow color' : 'red', 'note color' : 'yellow',
                 'participant color' : 'rgb(255,255,200)' }
  participant_names = []  # name...
  participants = []       # [color,string]...
  labels = {}             # map string to row number
  arrows = []             # [from_row, from_col, to_row, to_col, string?]...
  notes = []              # [row, col, edge, color, string]...
  row = 0
  left_margin = 0
  right_margin = 0
  last_arrowhead_row = 0
  last_arrowhead_col = 0

  # Parse
  tokenre = re.compile(r' *(?:(-?[0-9]+)|(->)|(-)|(:)|(@)|"([^"]*)"|([^ :@"-]+))')

  def token(match):
    if match.group(1):
      return int(match.group(1))
    for token in match.groups():
      if token:
        return token

  for line in g.sequence_lines:
    tokens = [token(match) for match in tokenre.finditer(line)]
    command = tokens[0]
    if command == 'set':
      parameter = tokens[1] + ' ' + tokens[2]
      if len(tokens) == 4:
        value = tokens[3]
      else:
        value = str.join(' ', tokens[3:])
      if parameter in parameters:
        parameters[parameter] = value
      else:
        error("%s is not a sequence parameter", parameter)
    elif command == 'participant':
      name = tokens[1]
      string = name
      color = parameters['participant color']
      if len(tokens) > 3 and tokens[2] == 'color':
        color = tokens[3]
        tokens = tokens[2:]
      if len(tokens) > 2:
        string = tokens[2]
      participant_names.append(name)
      participants.append([color, string])
    elif command == 'note':
      # Could use more error checking
      edge = tokens[1]
      if tokens[2] == 'color':
        color = tokens[3]
        string = tokens[4]
      else:
        color = parameters['note color']
        string = tokens[2]
      notes.append([last_arrowhead_row, last_arrowhead_col, edge, color, string])
      # box width is text length plus 1 times "en" guess as 1/2 text height
      width = (len(string) + 1) * parameters['text size'] / 2
      # margin width is box width minus half column occupied by box plus 25 slop
      width = width - parameters['column width'] / 2 + 25
      if last_arrowhead_col == 0 and edge == 'left' and width > left_margin:
	left_margin = width
      if last_arrowhead_col == len(participants) - 1 and edge == 'right' and width > right_margin:
        right_margin = width
    elif len(tokens) < 3 and tokens[-1] == ':':
      # Just a label or a colon
      row = row + 1
      if len(tokens) > 1:
        labels[tokens[0]] = row
    elif len(tokens) < 3 or '->' not in tokens:
      error('"%s" unrecognized sequence command line' % line)
    else:
      # [[label] ":"] name ["@" label] "->" name ["@" label] [string]
      label = None
      colon = False
      if tokens[0] == ':':
        colon = True
        tokens = tokens[1:]
      elif tokens[1] == ':':
        label = str(tokens[0])
        colon = True
        tokens = tokens[2:]
      if colon and len(arrows) > 0:
        row = row + 1
      if label:
        labels[label] = row
      from_row = row
      to_row = row
      string = None
      from_col = participant_names.index(tokens[0])
      if tokens[1] == '@':
        from_row = str(tokens[2])
        tokens = tokens[3:]
      else:
        tokens = tokens[1:]
      if tokens[0] != '->':
        error("Missing -> in %s" % line)
      to_col = participant_names.index(tokens[1])
      if len(tokens) > 2 and tokens[2] == '@':
        to_row = str(tokens[3])
        tokens = tokens[2:]
      if len(tokens) > 2:
        string = tokens[2]
      arrows.append([from_row, from_col, to_row, to_col, string])
      last_arrowhead_row = to_row
      last_arrowhead_col = to_col

  row = row + 1

  # Render

  # (x,y) is in the middle of edge (left, right, top, bottom)
  def renderTextInBox(g, x, y, edge, font_size, color, text):
    # box height is twice text height
    height = font_size * 2
    # box width is text length plus 1 times "en" guess as 1/2 text height
    width = (len(text) + 1) * font_size / 2
    # rect origin is always in the upper left
    if edge == 'left':
      y = y - height/2
    elif edge == 'right':
      x = x - width
      y = y - height/2
    elif edge == 'top':
      x = x - width/2
    elif edge == 'bottom':
      x = x - width/2
      y = y - height
    output_raw(g, '<rect x="%d" width="%d" y="%d" height="%d" style="fill:%s;stroke-width:1;stroke:black"/>' % (x, width, y, height, color))
    output_raw(g, '<text x="%d" y="%d" font-size="%d" fill="black" text-anchor="middle" dominant-baseline="middle">' % (x + width/2, y + height/2, font_size), newline=False)
    output_with_translations(g, text, newline=False)
    output_raw(g, '</text>')

  def renderArrow(g, parameters, labels, from_row, from_col, to_row, to_col, text):
    # Resolve symbolic rows
    if type(from_row) == str:
      from_row = labels[from_row]
    if type(to_row) == str:
      to_row = labels[to_row]
    # Convert row,column to x,y
    col_width = parameters['column width']
    row_height = parameters['row height']
    title_height = parameters['title size'] * 3
    from_x = from_col * col_width + col_width/2 + left_margin
    to_x   = to_col * col_width + col_width/2 + left_margin
    from_y = title_height + from_row * row_height + row_height/2
    to_y   = title_height + to_row * row_height + row_height/2
    if from_x < to_x:
      text_x = from_x + 5
      from_x = from_x + 2
      to_x   = to_x - 10
    else:
      text_x = to_x + 15
      from_x = from_x - 2
      to_x   = to_x + 10
    # Render
    font_size = parameters['text size']
    if from_row == to_row:
      # Horizontal arrow
      output_raw(g, '<line x1="%d" y1="%d" x2="%d" y2="%d" style="stroke:%s;stroke-width:2" marker-end="url(#arrowhead)"/>' % (from_x, from_y, to_x, to_y, parameters['arrow color']))
      if text:
        output_raw(g, '<text x="%d" y="%d" font-size="%d">' % (text_x, from_y - 5, font_size), newline=False)
        output_with_translations(g, text, newline=False)
        output_raw(g, '</text>')
    else:
      # Slanted arrow
      to_y = to_y - 10
      output_raw(g, '<line x1="%d" y1="%d" x2="%d" y2="%d" style="stroke:%s;stroke-width:2" marker-end="url(#arrowhead)"/>' % (from_x, from_y, to_x, to_y, parameters['arrow color']))
      if text:
        if from_x < to_x:
          angle_radians = math.atan2(to_y - from_y, to_x - from_x)
        else:
          angle_radians = math.atan2(from_y - to_y, from_x - to_x)
        angle_degrees = angle_radians * 360 / (2 * math.pi)
        if from_x < to_x:
          text_x = from_x + 40 * math.cos(angle_radians) + 5 * math.sin(angle_radians)
          text_y = from_y + 40 * math.sin(angle_radians) - 5 * math.cos(angle_radians)
        else:
          text_x = to_x + 15 * math.cos(angle_radians) + 5 * math.sin(angle_radians)
	  text_y = to_y + 15 * math.sin(angle_radians) - 5 * math.cos(angle_radians)
        output_raw(g, '<text x="%d" y="%d" font-size="%d" transform="rotate(%d %d,%d)">' %
                   (text_x, text_y, font_size, angle_degrees, text_x, text_y),
                   newline=False)
        output_with_translations(g, text, newline=False)
        output_raw(g, '</text>')

  # Use those subroutines to do the rendering
  # Initial boilerplate
  col_width = parameters['column width']
  row_height = parameters['row height']
  title_height = parameters['title size'] * 3
  output_raw(g, '<svg xmlns="http://www.w3.org/2000/svg" height="%d" width="%d">' % 
             (title_height * 2 + row_height * row, 
              col_width * len(participants) + left_margin + right_margin))
  output_raw(g, '<marker id="arrowhead" viewBox="0 0 10 10" refX="3" refY="5" markerUnits="strokeWidth" markerWidth="8" markerHeight="6" stroke="%s" fill="%s" orient="auto">' %
             (parameters['arrow color'], parameters['arrow color']))
  output_raw(g, '    <path d="M 3 5 L 0 0 L 10 5 L 0 10 z"/>')
  output_raw(g, '</marker>')

  # Headers, Footers, and Vertical lines
  col = 0
  for [color, string] in participants:
    x = col * col_width + col_width / 2 + left_margin
    renderTextInBox(g, x, 0, 'top', parameters['title size'], color, string)
    renderTextInBox(g, x, title_height + row * row_height, 'top', parameters['title size'], color, string)
    y = parameters['title size'] * 2
    # Drawing two lines is the only way I can find to darken the color
    output_raw(g, '<line x1="%d" y1="%d" x2="%d" y2="%d" style="stroke:gray;stroke-width:1;stroke-dasharray:5,3"/>' %
               (x, y, x, title_height + row * row_height))
    output_raw(g, '<line x1="%d" y1="%d" x2="%d" y2="%d" style="stroke:%s;;stroke-width:1;stroke-dasharray:5,3" opacity="0.6"/>' %
               (x, y, x, title_height + row * row_height, color))
    col = col + 1

  # Arrows
  for [from_row, from_col, to_row, to_col, text] in arrows:
    renderArrow(g, parameters, labels, from_row, from_col, to_row, to_col, text)

  # Notes
  for [row, col, edge, color, string] in notes:
    # Resolve symbolic row
    if type(row) == str:
      row = labels[row]
    y = title_height + row * row_height + row_height / 2
    if edge == 'right':
      x = left_margin + col_width * len(participants) - col_width / 2 + 10
      box_edge = 'left'
    else:
      x = left_margin + col_width / 2 - 10
      box_edge = 'right'
    renderTextInBox(g, x, y, box_edge, parameters['text size'], color, string)

  # Final boilerplate
  output_raw(g, 'Sorry, your browser does not support inline SVG so it cannot display this sequence diagram.')
  output_raw(g, '</svg>')

  # Clean up
  g.sequence_lines = []

defdot("sequence", sequence, before=before_sequence, after=after_sequence)


# Subroutines

# Begin or end a table or list
def change_mode(g, new_mode):
  if new_mode != g.current_mode:
    if g.current_mode == 'TABLE':
      leave_table_mode(g)
    elif g.current_mode == 'UL':
      leave_UL_mode(g)
    elif g.current_mode == 'OL':
      leave_OL_mode(g)
    g.current_mode = new_mode
    g.nesting_level = 1
    if new_mode == 'TABLE':
      enter_table_mode(g)
    elif new_mode == 'UL':
      enter_UL_mode(g)
    elif new_mode == 'OL':
      enter_OL_mode(g)

# Read line, strip trailing spaces, convert tabs, false at EOF
def next_line(g):
  line = g.input_stream.readline()
  if len(line) == 0:
    return False
  line = line.rstrip(" \t\n")
  g.line_number = g.line_number + 1
  spaces = "        "
  while True:
    column = line.find("\t")
    if column < 0:
      return line
    line = line[0 : column] + spaces[column % 8 : ] + line[column + 1 : ]

# Start a non-index page
def start_page(g, title):
  g.page_number        = g.page_number + 1
  g.previous_page_file = g.this_page_file
  g.this_page_file     = chapter_name(title)
  g.output_stream      = open(os.path.join(g.output_directory, g.this_page_file + ".html"), "w")
  output_raw(g, "<!DOCTYPE html>")
  output_raw(g, "<html><head>")
  output_raw(g, "<title>")
  if g.title_prefix:
    output_with_translations(g, g.title_prefix)
    output_raw(g, ": ")
  output_with_translations(g, title)
  output_raw(g, "</title></head><body>")
  for html in g.pre_html:
    output_raw(g, html)

# End a non-index page
def end_page(g, next_chapter_name):
  if g.output_stream:
    change_mode(g, 'normal')
    # Navigation
    first     = g.page_number == 1
    prev_page = "index.html" if first else g.previous_page_file + ".html"
    next_page = next_chapter_name + ".html" if next_chapter_name else None
    output_raw(g, "<BR><P align=center>")
    output_raw(g, "<A HREF=\"" + prev_page + "\">", newline=False)
    output_raw(g, "Previous page", newline=False)
    output_raw(g, "</A>", newline=False)
    output_raw(g, "&nbsp;&nbsp;&nbsp;<A HREF=\"index.html\">Table of Contents</A>&nbsp;&nbsp;&nbsp;", newline=False)
    if next_chapter_name:
      output_raw(g, "<A HREF=\"" + next_page + "\">", newline=False)
      output_raw(g, "Next page", newline=False)
      output_raw(g, "</A>", newline=False)
    output_raw(g, "</P>")
    # Bottom of page material
    for html in g.post_html:
      output_raw(g, html)
    output_raw(g, "</body></html>")
    g.output_stream.close()
    g.output_stream = False


# Generate the table of contents
def output_index(g):
  prefix = g.title_prefix + ": " if g.title_prefix else ""
  output_raw(g, "<!DOCTYPE html>")
  output_raw(g, "<html><head><title>" + prefix + "Table of Contents</title>")
  
  # Special code to make <details> work in old browsers that don't support it
  # Thank you Tyler Uebele !!
  
  details_shim_min_js = "/* Copyright (c) 2006-2013 Tyler Uebele * Released under the MIT license. * latest at https://github.com/tyleruebele/details-shim * minified by Google Closure Compiler */\nfunction details_shim(a){if(!(a&&\"nodeType\"in a&&\"tagName\"in a))return details_shim.init();var b;if(\"details\"==a.tagName.toLowerCase())b=a.getElementsByTagName(\"summary\")[0];else if(a.parentNode&&\"summary\"==a.tagName.toLowerCase())b=a,a=b.parentNode;else return!1;if(\"boolean\"==typeof a.open)return a.getAttribute(\"data-open\")||(a.className=a.className.replace(/\\bdetails_shim_open\\b|\\bdetails_shim_closed\\b/g,\" \")),!1;var c=a.outerHTML||(new XMLSerializer).serializeToString(a),c=c.substring(0,c.indexOf(\">\")),\nc=-1!=c.indexOf(\"open\")&&-1==c.indexOf('open=\"\"')?\"open\":\"closed\";a.setAttribute(\"data-open\",c);a.className+=\" details_shim_\"+c;b.addEventListener?b.addEventListener(\"click\",function(){details_shim.toggle(a)}):b.attachEvent&&b.attachEvent(\"onclick\",function(){details_shim.toggle(a)});Object.defineProperty(a,\"open\",{get:function(){return\"open\"==this.getAttribute(\"data-open\")},set:function(a){details_shim.toggle(this,a)}});for(b=0;b<a.childNodes.length;b++)if(3==a.childNodes[b].nodeType&&/[^\\s]/.test(a.childNodes[b].data)){var c=\ndocument.createElement(\"span\"),d=a.childNodes[b];a.insertBefore(c,d);a.removeChild(d);c.appendChild(d)}}details_shim.toggle=function(a,b){b=\"undefined\"===typeof b?\"open\"==a.getAttribute(\"data-open\")?\"closed\":\"open\":b?\"open\":\"closed\";a.setAttribute(\"data-open\",b);a.className=a.className.replace(/\\bdetails_shim_open\\b|\\bdetails_shim_closed\\b/g,\" \")+\" details_shim_\"+b};details_shim.init=function(){for(var a=document.getElementsByTagName(\"summary\"),b=0;b<a.length;b++)details_shim(a[b])};\nwindow.addEventListener?window.addEventListener(\"load\",details_shim.init,!1):window.attachEvent&&window.attachEvent(\"onload\",details_shim.init);\n"
  
  details_shim_min_css = "details.details_shim_closed,details.details_shim_open{display:block}details.details_shim_closed>*{display:none}details.details_shim_closed>summary,details.details_shim_open>summary{display:block}details.details_shim_closed>summary:before{display:inline-block;content:\"\\25b6\";padding:0 .1em;margin-right:.4em;font-size:.9em}details.details_shim_open>summary:before{display:inline-block;content:\"\\25bc\";padding:0;margin-right:.35em}\n"
  
  output_raw(g, "<script type=\"text/javascript\" src=\"details-shim.min.js\"></script>")
  output_raw(g, "<link rel=\"stylesheet\" type=\"text/css\" href=\"details-shim.min.css\">")
  
  js = open(os.path.join(g.output_directory, "details-shim.min.js"), "w")
  js.write(details_shim_min_js)
  js.close()
  
  css = open(os.path.join(g.output_directory, "details-shim.min.css"), "w")
  css.write(details_shim_min_css)
  css.close()
  
  output_raw(g, "</head><body>")
  
  for html in g.pre_html:
    output_raw(g, html)
  now = time.localtime()
  output_raw(g, "Last updated " + str(now.tm_mon) + "/" + str(now.tm_mday) + "/" + str(now.tm_year) + ".<BR>")
  output_raw(g, "<h2>Table of Contents</h2>")
  
  page_no = 1
  for x in g.page_titles:
    title    = x[0]
    sections = x[1]
    if len(sections) == 0:
      output_raw(g, "<div style=\"margin-left:1.6em\">", newline=False)
    else:
      output_raw(g, "<details><summary>")
    
    page_name = chapter_name(title)
    output_raw(g, str(page_no) + ". <A HREF=\"" + page_name + ".html\">" + title + "</A><BR>", newline=False)
    
    if len(sections) == 0:
      output_raw(g, "</div>")
    else:
      output_raw(g, "</summary>")
    
    section_no = 1
    for x in sections:
      title       = x[0]
      subsections = x[1]
      anchor = anchor_name(title)
      output_raw(g, "<div style=\"margin-left:2.3em\">" + str(page_no) + "." + str(section_no) + " <A HREF=\"" + page_name + ".html#" + anchor + "\">" + title + "</A><BR></div>")
      
      subsection_no = 1
      for title in subsections:
        anchor = anchor_name(title)
        output_raw(g, "<div style=\"margin-left:4em\">" + str(page_no) + "." + str(section_no) + "." + str(subsection_no) + " <A HREF=\"" + page_name + ".html#" + anchor + "\">" + title + "</A><BR></div>")
        subsection_no = subsection_no + 1
      section_no = section_no + 1
    
    if len(sections) > 0:
      output_raw(g, "</details>")
    page_no = page_no + 1
  
  output_raw(g, "<BR>")
  for html in g.post_html:
    output_raw(g, html)
  output_raw(g, "</body></html>")

# Output HTML directly
def output_raw(g, line, newline = True):
  for char in line:
    if ord(char) < 32 or ord(char) > 126:
      error("Invalid character code " + str(ord(char)) + " on line " + str(g.line_number))
  g.output_stream.write(line)
  if newline:
    g.output_stream.write('\n')

# Output with character translations
def output_with_translations(g, line, start=None, end=None, newline=True):
  for char in line[(start if start else 0) : (end if end else len(line))]:
    if ord(char) < 32:
      error("Invalid character code " + str(ord(char)) + " on line " + str(g.line_number))
    elif char == '<':
      output_raw(g, "&lt;", newline=False)
    elif char == '>':
      output_raw(g, "&gt;", newline=False)
    elif char == '&':
      output_raw(g, "&amp;", newline=False)
    elif ord(char) > 126:
      output_raw(g, "&#x", newline=False)
      for i in xrange(0, 4):
        shift = 12 - 4 * i
        higit = 15 & (ord(char) >> shift)
        g.output_stream.write(chr(higit + (ord('0') if higit < 10 else ord('A') - 10)))
      g.output_stream.write(';')
    else:
      g.output_stream.write(char)
  if newline:
    g.output_stream.write('\n')

# Output with style flags and character translations
# Depends on ` and \ being encoded in one UTF-8 byte
def output_with_flags_and_translations(g, line, start=0, end=None, newline=True):
  if not end:
    end = len(line)
  pos = start
  while pos < end:
    next  = line.find('\\', pos, end)
    next2 = line.find('`', pos, end)
    if next < 0 or (next2 >= 0 and next2 < next):
      next = next2
    if next < 0:
      return output_with_translations(g, line, start=pos, end=end, newline=newline)
    else:
      if next > pos:
        output_with_translations(g, line, start=pos, end=next, newline=False)
        pos = next
      nextnext = line.find(line[pos], pos + 2, end) if pos + 2 <= end else -1  # +2 to allow ```
      if nextnext < 0:
        error("Mismatched " + line[pos] + " in " + line + " on line " + str(g.line_number))
      if line[pos] == '`':
        output_raw(g, "<TT>", newline=False)
        output_with_translations(g, line, start=pos + 1, end=nextnext, newline=False)
        output_raw(g, "</TT>", newline=False)
        pos = nextnext + 1
      elif line[pos + 1] == '\\':
        if not (nextnext < end and line[nextnext + 1] == '\\'):
          error("Mismatched \\\\ in " + line + " on line " + str(g.line_number))
        output_raw(g, "<strong>", newline=False)
        output_with_flags_and_translations(g, line, start=pos + 2, end=nextnext, newline=False)
        output_raw(g, "</strong>", newline=False)
        pos = nextnext + 2
      else:
        output_raw(g, "<em>", newline=False)
        output_with_flags_and_translations(g, line, start=pos + 1, end=nextnext, newline=False)
        output_raw(g, "</em>", newline=False)
        pos = nextnext + 1
  if newline:
    g.output_stream.write('\n')

# Error reporting
def error(message):
  sys.stderr.write("ERROR: " + message + "\n")
  sys.exit(1)

def error_output(message):
  sys.stderr.write("ERROR: " + message + "\n")

# Invoke the main program
main(sys.argv)