- `abc2svg-1.js`   
  This script is the **abc2svg** core.  
  It contains the ABC parser and the SVG generation engine.  
  It must be included in the (X)HTML header of the pages
  where ABC rendering is needed (in `<script src=` tags).

- `abcemb-1.js`   

  This script replaces the ABC or MEI sequences by SVG images of the music
  (the ABC sequences start on `X:` or `%abc` at start of line,
  and stop on any ML tag - see below for MEI).  
  See the
  [%%beginml documentation](http://moinejf.free.fr/abcm2ps-doc/beginml.xhtml)
  for an example.   
  When the URL of the (X)HTML file ends with '#' followed by a string,
  only the first tune containing this string is displayed.   
  Note that, if the ABC sequence contains the characters '<', '>' or '&',
  it must be enclosed in a XML comment (starting after the first `X:` or `%abc`).

- `abcemb1-1.js`   
  This script is to be used with the core in (X)HTML files.  
  It works quite the same as the previous script, but replaces the whole
  page by the selected tune.
  When there is no selection ('#' + string at the end of the URL),
  a list of the tunes is displayed.   
  When a tune is displayed, a menu offers the edition of the ABC source and
  the automatic scroll of the music (this is done according to the tempo -
  repeats and parts are not handled).   
  See [this tune](http://moinejf.free.fr/abc/boyvin-2-2.html)
  for an example.   

- `abcemb2-1.js`   
  This script is also to be used with the core in (X)HTML files.  
  The differences with the script `abcemb-1.js` are:
  - the ABC sequences are replaced in HTML elements with the class `abc`,
  - the string after '#' in the URL does a real %%select (i.e. this may
    select many tunes),
  - there is no menu nor list of tunes
  - if the ABC sequences contain the characters '<', '>' or '&',
    either these sequences must be enclosed in a XML comment, or the characters
    must be replaced by their XML counterparts ('&amp;lt;', '&amp;gt;' or '&amp;amp;').
  
- `abcdoc-1.js`   
  This script is also to be used in (X)HTML pages with the core.  
  Mainly used for ABC documentation, it lets the ABC source sequences
  in the page before the SVG images.  
  See the source of
  [abcm2ps/abc2svg features](http://moinejf.free.fr/abcm2ps-doc/features.xhtml)
  for an example.

- `play-1.js`   
  This script may be used with `abcemb{,1,2}-1.js` for playing the
  rendered ABC music.  
  See [this page](http://moinejf.free.fr/abcm2ps-doc/au_clair.xhtml)
  for an example.

- `abcweb2-1.js`   
  This script works the same as `abcemb2-1.js` but it must use `snd-1.js`
  for playing.
  
- `snd-1.js`   
  This script contains a other way for playing. It is used in the editor
  and it may be used with `abcweb2-1.js`.

- `follow-1.js`   
  This script may be used after `play-1.js` or `snd-1.js` for highlighting
  the notes while playing.   
  See [this page](http://moinejf.free.fr/abcm2ps-doc/tabac.xhtml)
  for an example.

- `edit-1.xhtml`   
  This is a simple web
  [ABC editor/player](http://moinejf.free.fr/js/edit-1.xhtml).

When looking at a ABC file in a web browser, you may also use a

<a href="https://en.wikipedia.org/wiki/Bookmarklet">bookmarklet</a>
as
<a href="javascript:(function(){var%20s,n=3,d=document,b=d.body;b.innerHTML='\n%25abc-2.2\n%25%3c!--\n'+b.textContent+'%25--%3e\n';function%20f(u){s=d.createElement('script');s.src='http://moinejf.free.fr/js/'+u;s.onload=function(){if(--n==0)dom_loaded()};d.head.appendChild(s)};f('play-1.js');f('follow-1.js');f('abcemb-1.js')})();void(0)">this one</a>
for rendering all tunes, or

<a href="javascript:(function(){var%20s,n=3,d=document,b=d.body;b.innerHTML='\n%25abc-2.2\n%25%3c!--\n'+b.textContent+'%25--%3e\n';function%20f(u){s=d.createElement('script');s.src='http://moinejf.free.fr/js/'+u;s.onload=function(){if(--n==0)dom_loaded()};d.head.appendChild(s)};f('play-1.js');f('follow-1.js');f('abcemb1-1.js')})();void(0)">this one</a>
for rendering the tunes one by one.

##### Notes:
- The music is rendered as SVG images. There is one image per
  music line / text block.  
  If you want to move these images to some other files,
  each one must contain the full CSS and defs. For that, insert   

  `        %%fullsvg x`   

  in the ABC file before rendering (see the
  [fullsvg documentation](http://moinejf.free.fr/abcm2ps-doc/fullsvg.xhtml)
  for more information).

- Playing uses the HTML5 audio and/or midi APIs.

- With the editor, if you want to render ABC files
  which contain `%%abc-include`, you must:
  - load the ABC file from the browse button
  - click in the include file name
  - load the include file by the same browse button  

  Then, you may edit and save both files.  

  There may be only one included file.

- The editor comes with different ways to enter the music from the keyboard.  
  If you have a US keyboard, you may try these bookmarklets:
<a href="javascript:(function(){if(typeof%20loadjs=='function'){loadjs('abckbd-1.js')}else{alert('use%20with%20abc2svg%20editor')}})();void(0)">keyboard 1</a>
and
<a href="javascript:(function(){if(typeof%20loadjs=='function'){loadjs('abckbd2-1.js')}else{alert('use%20with%20abc2svg%20editor')}})();void(0)">keyboard 2</a>

- The .js and .xhtml file names have a suffix which is the version of
  the core interface (actually '`-1`').

### nodeJS usage

Installed via **npm**, the **abc2svg** package comes with the
command line (batch) programs `abc2svg` and `abc2odt`.

These ones may be used as **abcm2ps** to generate XHTML or ODT files.   

`abc2svg` writes to standard output:   


`        abc2svg mytunes.abc > Out.xhtml`


`abc2odt` output is `abc.odt` or the file specified
by the command line argument `-o`:   


`        abc2odt my_file.abc -o my_file.odt`


### Build

If you want to build the **abc2svg** scripts in your machine,
you must first get the files from
[chisel](https://chiselapp.com/user/moinejf/repository/abc2svg),
either as a tarball or a Zip archive
(click `Timeline` and then in the top commit),
or by cloning the repository in some directory:


> `fossil clone https://chiselapp.com/user/moinejf/repository/abc2svg abc2svg.fossil`   
> `fossil open abc2svg.fossil`


Then, building is done using the tool [ninja](https://ninja-build.org/)
or [samurai](https://github.com/michaelforney/samurai).  
You may do it:

- without minification  
  This is interesting for debug purpose, the scripts being more human friendly.


  `        NOMIN=1 samu -v`


- in a standard way with minification  
  In this case, you need the tool `uglifyjs` which comes with nodeJS.


  `        samu -v`


If you also want to change or add music glyphs, you may edit the source
file `font/abc2svg.sfd`. In this case, you will need both `base64` and `fontforge`,
and run


`        samu -v font.js`


If you cannot or don't want to install `ninja` or `samurai`, you may build
the abc2svg files by `./build` which is a shell script.

### Batch

After building the **abc2svg** scripts, you will be able to generate music
sheets from the command line as you did with `abcm2ps`, thanks to the
following shell scripts (the result goes to stdout):  

- `abcqjs` with `qjs` 
   ([QuickJS by Fabrice Bellard and Charlie Gordon](https://bellard.org/quickjs/))
- `abcjs24` with `js24` (Mozilla JavaScript shell - Spidermonkey)
- `abcjs52` with `js52` (Mozilla JavaScript shell - Spidermonkey)
- `abcjs60` with `js60` (Mozilla JavaScript shell - Spidermonkey)
- `abcjsc` with `jsc-1` (webkitgtk2)
- `abcnode` with `node` (nodeJS)
- `abcv8` with `d8` (Google libv8)

#### backend scripts

By default, the batch scripts generate (XHTML+SVG) files.   
This output may be modified by backend scripts. These ones must appear
just after the command.   
There are:

- `toabc.js`   
  This script outputs back the (selected) ABC tunes of the ABC source file.   
  Transposition is applied.   
  The resulting file does not contain the formatting parameters.   
  Example:   
  `        abcqjs toabc.js my_file.abc --select X:2 > tune_2.abc`

- `toabw.js`   
  This script outputs a Abiword file (ABW+SVG) which may be read by some
  word processors (abiword, libreoffice...) and converted to many other
  formats by the batch function of abiword.   
  The abc2svg music font (`abc2svf.woff` or `abc2svg.ttf`) must be installed
  in the local system for displaying and/or converting the .abw file.   
  Example:   
  `        abcv8 toabw.js my_file.abc > my_file.abw`

- `tomei.js`   
  This script outputs the music as a [MEI](https://music-encoding.org/) file.   
  Indeed, only one tune may be translated from ABC to MEI (multi-tunes ABC
  generates bad MEI).

- `toodt.js`   
  This script creates an Open Document (ODT+SVG) which may be read by most
  word processors (abiword, libreoffice...).   
  It runs only with the npm script `abc2svg` and asks for the npm module
  `jszip` to be installed.   
  The output ODT document may be specified by the command line argument `-o`
  (default `abc.odt`).   
  Example:   
  `        abc2svg toodt.js my_file.abc -o my_file.odt`

- `toparam.js`   
  This script just outputs the abc2svg parameters.

#### PDF generation

`abctopdf` is a shell script which converts ABC to PDF using one of the
previous shell scripts and the program `rsvg-convert`.   
As a constraint, the used music font must be installed and defined by
`%%musicfont <fontname>`.   
Example:   
`        abctopdf my_file.abc -o my_file.pdf`

### MEI support

As an experimental feature, an extented core `mei2svg-1.js` may be generated.
This one may handle both the ABC and [MEI](https://music-encoding.org/) notations.

In browser mode, the script `abcemb-1.js` loads either abc2svg-1.js or
mei2svg-1.js after checking the music notation type (`%abc` or `X:` is ABC,
`<mei` is MEI - see
[this tune](http://moinejf.free.fr/abc/Czerny_op603_6.html) for an example).

In batch mode, the script `abcqjs` also loads the right abc2svg core
according to the source file extension (`.abc` or `.mei`).

	process.exit(1)
}
abc2svg.readFile = function(fname) {
    var	fs = require("fs")

	return fs.readFileSync(fname).toString()
}

abc2svg.get_mtime = function(fn) {
    var	fs = require("fs")

	return fs.statSync(fn).mtime
}

abc2svg.loadjs = function(fn, relay, onerror) {
	try {
		var geval = eval;
		geval(abc2svg.readFile(__dirname + sep + fn))
		if (relay)
			relay()

	process.exit(1)
}
abc2svg.readFile = function(fname) {
    var	fs = require("fs")

	return fs.readFileSync(fname).toString()
}

abc2svg.get_mtime = function(fn) {
    var	fs = require("fs")

	return fs.statSync(fn).mtime
}

abc2svg.loadjs = function(fn, relay, onerror) {
	try {
		var geval = eval;
		geval(abc2svg.readFile(__dirname + sep + fn))
		if (relay)
			relay()
	} catch(e) {
		if (onerror)
			onerror()
		else
			printErr('Cannot read file ' + fn)
	}
}

// load the command line
m = require("abc2svg/cmdline");

global.user = m.user;
global.abc_cmd = m.abc_cmd

// main
var args = process.argv
if (!args[2])
	usage();

#!/usr/bin/env js60
// abc2svg with js60 (Mozilla JavaScript shell - Spidermonkey
//		packages: debian: libmozjs-60-dev, voidlinux: mozjs60)

loadRelativeToScript("abc2svg-1.js")

// interpreter specific functions
abc2svg.print = function(str) {
	print(str)
}
abc2svg.printErr = function(str) {
	printErr(str)
}

abc2svg.quit = function() {
	quit(1)
}
abc2svg.readFile = function(fname) {
	return read(fname)
}
abc2svg.loadjs = function(fn, relay, onerror) {
	try {
		loadRelativeToScript(fn)
		if (relay)
			relay()
	} catch(e) {
		if (onerror)
			onerror()
		else
			printErr('Cannot read file ' + fn)
	}
} // loadjs()

loadRelativeToScript("cmdline.js")

// main
	var	args = scriptArgs

	if (/\.js$/.test(args[0])) {
		load(args[0])
		args.shift()
	}
	if (typeof abc2svg.abc_init != 'function')
		loadRelativeToScript("toxhtml.js")
	if (!args[0]) {
		printErr('ABC translator with js60 (SpiderMonkey)\
 and abc2svg-' + abc2svg.version + ' ' + abc2svg.vdate + '\n\
Usage:\n\
  abcjs60 [script.js] [g_options] ABC_file [f_options] [ABC_file [f_options]]*\n\
Arguments:\n\
  script.js  generation script to load - default: toxhtml.js (XHTML+SVG)\n\
  g_options  global ABC options\n\
  ABC_file   ABC file\n\
  f_options  file options')
		quit()
	}
	abc_cmd("abcjs60", args)

#!/bin/sh
# abc2svg with jsc (webkit2gtk)
progdir=`dirname $0`

exec jsc -e "var progdir='${progdir}/'

// function to do utf-8 work...
// uncommenting this function asks for also uncommenting its call in cmdline.js
//function utf_convert(fin) {
//	var	b1, b2, b3,
//		fout = ''
//	for (var i = 0; i < fin.length; i++) {
//		b1 = fin.charCodeAt(i)
//		if (b1 >= 0x80) {
//			b2 = fin.charCodeAt(++i);
//			if (b1 >= 0xe0) {
//				b3 = fin.charCodeAt(++i);
//				if (b1 >= 0xf0) {		// >= 0x10000
//					b1 = ((b1 & 0x07) << 18) +
//						((b2 & 0x3f) << 12) +
//						((b3 & 0x3f) << 6) +
//						(fin.charCodeAt(++i) & 0x3f);
//					fout += String.fromCharCode((b1 >> 10) + 0xd7c0,
//								(b1 & 0x3ff) + 0xdc00)
//				} else {
//					fout += String.fromCharCode(((b1 & 0x0f) << 12) +
//								((b2 & 0x3f) << 6) +
//								(b3 & 0x3f))
//				}
//			} else {
//				fout += String.fromCharCode(((b1 & 0x1f) << 6) +
//							(b2 & 0x3f))
//			}
//		} else {
//			fout += fin[i]
//		}
//	}
//	return fout
//}

load(progdir + 'abc2svg-1.js')

// interpreter specific functions
abc2svg.print = function(str) {
	print(str)
}
abc2svg.printErr = function(str) {
	printErr(str)
}
abc2svg.quit = function() {
	quit(1)
}
abc2svg.readFile = function(fname) {
	return read(fname)
}

	process.exit(1)
}
abc2svg.readFile = function(fname) {
    var	fs = require("fs");

	return fs.readFileSync(fname).toString()
}

abc2svg.get_mtime= function(fn) {
    var	fs = require("fs")

	return fs.statSync(fn).mtime
}

abc2svg.loadjs = function(fn, relay, onerror) {
	try {
		var geval = eval;
		geval(abc2svg.readFile(progdir + fn))
		if (relay)
			relay()

  g_options  global ABC options\n\
  ABC_file   ABC file\n\
  f_options  file options');
		abc2svg.quit(1)
	}
	args.shift()
	args.shift()
	global.user = user;		// (for modules/page.js)
	abc_cmd("abcnode", args)
EOF

node /tmp/toto.js "$@"

:;# shell script to convert ABC or MEI music notation to other format
# using abc2svg and quickjs (https://bellard.org/quickjs/)

test -f /tmp/abcqjs.js && exec qjs --std /tmp/abcqjs.js $0 "$@"

cat > /tmp/abcqjs.js << EOF
//javascript

    var	i,
	args = scriptArgs
	args.shift()		// remove '/tmp/abcqjs.js'
    var	core = "abc2svg-1.js",
	path = args.shift().	// the 1st argument is the script name
			match(/(.*\/).*/)

	path = path ? path[1] : ""

	i = args.length
	while (--i >= 0) {
		if (/\.mei$/.test(args[i])) {
			core = "mei2svg-1.js"
			break
		}
	}

std.loadScript(path + core)

// interpreter specific functions
function load(fn) {
	return std.loadScript(fn)
}
abc2svg.print = function(str) {
	print(str)
}
abc2svg.printErr = function(str) {
	std.err.printf("%s\n", str)
}

abc2svg.quit = function() {
	std.exit(1)
}
abc2svg.readFile = function(fname) {
    var	l, f,
	b = "",
	bt = "",
	cnt = 30

	try {
		f = std.open(fname, "r")
	} catch(e) {
		return ""
	}

	while (1) {
		if (--cnt < 0) {
			cnt = 30
			bt += b
			b = ""
		}
		l = f.getline()
		if (l == null)
			break
		b += l + "\n"
	}
	f.close()
	return bt + b
} // readfile()

abc2svg.get_mtime = function(fn) {
	return new Date(os.stat(fn)[0].mtime)
}

abc2svg.loadjs = function(fn, relay, onerror) {
	try {
		std.loadScript(path + fn)
		if (relay)
			relay()
	} catch(e) {
		if (onerror)
			onerror()
		else
			printErr('Cannot read file ' + fn)
	}
} // loadjs()

std.loadScript(path + "cmdline.js")

// main
	if (/\.js$/.test(args[0])) {
		if (args[0][0] == "/")
			std.loadScript(args[0])
		else
			std.loadScript(path + args[0])
		args.shift()
	}
	if (typeof abc2svg.abc_init != 'function')
		std.loadScript(path + "toxhtml.js")
	if (!args[0]) {
		abc2svg.printErr('ABC translator with quickjs\
 and abc2svg-' + abc2svg.version + ' ' + abc2svg.vdate + '\n\
Usage:\n\
  abcqjs [script.js] [g_options] ABC_file [f_options] [ABC_file [f_options]]*\n\
Arguments:\n\
  script.js  generation script to load - default: toxhtml.js (XHTML+SVG)\n\
  g_options  global ABC options\n\
  ABC_file   ABC file\n\
  f_options  file options')
		abc2svg.quit()
	}
	abc_cmd("abcqjs", args)
EOF
exec qjs --std /tmp/abcqjs.js $0 "$@"

The previous solution with the shebang line as
#!/usr/bin/env -S qjs --std
did not work with non-GNU versions of env

#!/bin/sh
#
# abctopdf - converts ABC to PDF using abc2svg
#
# Copyright (C) 2019 Jean-François Moine - License GPL3+

if [ $# -eq 0 ]; then
	cat << EOF
ABC to PDF translator using abc2svg
Usage:
  abctopdf [g_options] ABC_file [f_options] [ABC_file [f_options]]* [-o output_file]
Arguments:
  g_options   global ABC options
  ABC_file    ABC file
  f_options   file options
  output_file output file - default is "./abc.pdf"
EOF
	exit 1
fi

# choose a abc2svg batch script with an available JS interpreter
if [ ${0#./} != $0 ]; then
	bdir="./"
else
	bdir=`dirname $0`
	if [ $bdir != '.' ]; then
		bdir="$bdir/"
	else
		bdir=''
	fi
fi
# (sorted from fastest to slowest in ARM machines)
for c in qjs jsc js24 js52 js60 d8 abc2svg node end; do
	if [ $c = 'end' ]; then
		echo "$0: could not find a javascript interpreter - abort"
		exit 1
	fi
	if command -v $c >/dev/null 2>&1; then
		case $c in
		(qjs) c=abcqjs;;
		(jsc) c=abcjsc;;
		(js24) c=abcjs24;;
		(js52) c=abcjs52;;
		(js60) c=abcjs60;;
		(d8) c=abcv8;;
		(abc2svg) c=abc2svg;;
		(node) c=abcnode;;
		esac
		if command -v $c >/dev/null 2>&1; then
			abcscr=$c
			break
		fi
		if command -v $bdir$c >/dev/null 2>&1; then
			abcscr=$bdir$c
			break
		fi
	fi
done
echo "Using $abcscr"

# get the output file name (after '-o')
# default name
out='abc.pdf'
n=0
for a do
	if [ "$a" = "-o" ]; then
		n=1
	elif [ $n -eq 1 ]; then
		out=$a
		n=0
	else
		set -- "$@" "$a"
	fi
	shift
done

# check if some chromium-based browser is available
# test rsvg-convert
for c in chromium-browser vivaldi opera brave-browser epic google-chrome; do
	if command -v $c >/dev/null 2>&1; then
		echo "and $c"
		command $abcscr "$@" > /tmp/o.xhtml
		$c --headless --disable-gpu --print-to-pdf=$out /tmp/o.xhtml
		rm /tmp/o.xhtml
		exit 0
	fi
done

# check the required programs
if ! command -v rsvg-convert >/dev/null 2>&1; then
	echo "$0: program 'rsvg-convert' not found - abort"
	exit 1
fi
echo "and rsvg-convert"

# build a ABC file (with JS script) to change the font and page definitions
# this solves the following problems:
# - the maintainer of librsvg does not want to handle the CSS shorthand 'font:'
# - rsvg-convert always gets the SVG images at 72ppi, ignoring the -p/-d values
# - the sets of SVG images per page must be converted to a set of one SVG per page
cat > /tmp/fix.abc << EOF
%%pageheight 29.7cm
%%fullsvg 1
%%musicfont abc2svg
%%beginjs
    var fix_out
function font_bug(str) {
	return str.replace(/font:.*?["};]/g, function(p) {	// "
	    var	w = p.slice(5, -1).match(/[^ \t"]+|".+?"/g), // "
		l = w.length,
		r = 'font-family:' + w[--l] + ';font-size:' + w[--l]
		while (--l >= 0) {
			switch (w[l]) {
			case 'italic':
				r += ';font-style:italic'
				break
			case 'oblique':
				r += ';font-style:oblique'
				break
			case 'bold':
				r += ';font-weight:bold'
				break
			}
		}
		return r + p[p.length - 1]
	})
}
// install
// - front-end
	fix_out = abc2svg.page.img_out
	abc2svg.page.img_out = function(page, p) {
		fix_out(page, font_bug(p))
	}
// - back-end
    var	page_h, page_out,
	page_sty = ""

	// get the style from the image and remove it from the block
	function get_style(p) {
	    var	i,
		sty = p.match(/<style.*?>((.|\n)*?)<\/style>/)

		if (!sty)
			return p
		sty = sty[1].split('\n')
		if (!page_sty)
			page_sty = '<style type="text/css">\n</style>\n'
		for (i = 0; i < sty.length; i++) {
			if (page_sty.indexOf(sty[i]) < 0)
				page_sty = page_sty.replace('</style>\n',
						sty[i] + '\n</style>\n')
		}
		return p.replace(/<style(.|\n)*?\/style>\n/, '')
	} // get_style()

	// low level output
	abc.page.user_out = function(p) {
	    var	h, w,
		cfmt = abc.cfmt()

		switch (p.slice(0, 4)) {
		case "<div":			// new page
			page_h = 0
			page_out = ""
			break
		case "<svg":			// SVG image
			p = get_style(p)
			page_out += p
			    .replace(/<svg(.|\n)*?>/,
				'<g transform="translate(0, ' +
					page_h.toFixed(1) + ')">')
			    .replace('</svg>', '</g>\n')
			page_h += Number(p.match(/height="(\d+)px"/)[1])
			break
		case "</di":			// end of page
			w = cfmt.pagewidth
			h = cfmt.pageheight
			abc2svg.print('\
<svg xmlns="http://www.w3.org/2000/svg" version="1.1"\n\
 xmlns:xlink="http://www.w3.org/1999/xlink"\n\
 color="black" class="music" stroke-width=".7"\n\
 width="' +
				(w * .75).toFixed(0) + 'px" height="' +
				(h * .75).toFixed(0) + 'px" viewBox="0 0 ' +
					w.toFixed(0) + ' ' +
					h.toFixed(0) + '"' +
				(cfmt.bgcolor ?
					(' style="background-color: ' +
						cfmt.bgcolor + '"') : '') +
				'>\n' +
				page_sty +
				page_out + "</svg>")
			break
		}
	} // user_out()
// for tests
abc2svg.abort = function(e) {
abc2svg.printErr('abort: '+e.message+'\n'+e.stack)
abc2svg.quit()
}
%%endjs
EOF

# purge /tmp
rm -f /tmp/abc*.svg

# generate a (XHTML+SVG) file with a abc2svg batch script
# then, extract the SVG images (pages) to /tmp
n=0
command $abcscr /tmp/fix.abc "$@" | while read v; do
	case "$v" in
	"<svg"*)
		n=$(($n+1))
		fn="/tmp/abc$n.svg"
		echo $v > $fn
		;;
	"</svg"*)
		echo $v >> $fn
		fn=
		;;
	"</body"*)
		break;;
	*)
		if [ "X$fn" != "X" ]; then
			echo $v >> $fn
		fi
		;;
	esac
done

# convert the SVG images to PDF
if [ -f /tmp/abc1.svg ]; then
 rsvg-convert -f pdf $(ls -rt /tmp/abc*.svg) -o $out
else
 echo 'Errors during the generation'
fi

# cleanup
rm -f /tmp/abc*.svg /tmp/fix.abc

 core/svg.js core/tune.js core/lyrics.js core/gchord.js core/tail.js\
 core/modules.js >> $out
 echo "abc2svg.version=\"$VERSION\";abc2svg.vdate=\"$DATE\"" >> $out

cp modules/ambitus.js ambitus-$MAJOR.js
cp modules/break.js break-$MAJOR.js
cp modules/capo.js capo-$MAJOR.js
cat util/midi.js modules/clair.js >> clair-$MAJOR.js
cp modules/clip.js clip-$MAJOR.js
cp modules/combine.js combine-$MAJOR.js
cp modules/diag.js diag-$MAJOR.js
cp modules/equalbars.js equalbars-$MAJOR.js
cp modules/grid.js grid-$MAJOR.js
cp modules/grid2.js grid2-$MAJOR.js
cp modules/MIDI.js MIDI-$MAJOR.js
cat modules/page.js modules/strftime.js > page-$MAJOR.js
cp modules/perc.js perc-$MAJOR.js
cat modules/wps.js modules/psvg.js > psvg-$MAJOR.js
cp modules/soloffs.js soloffs-$MAJOR.js
cp modules/sth.js sth-$MAJOR.js
cp modules/temper.js temper-$MAJOR.js

cp editor/edit.css edit-$MAJOR.css

cp util/abcdoc.js abcdoc-$MAJOR.js
cp util/abcemb.js abcemb-$MAJOR.js
cp util/abcemb1.js abcemb1-$MAJOR.js
cp util/abcemb2.js abcemb2-$MAJOR.js
cp util/abcweb2.js abcweb2-$MAJOR.js
cp util/follow.js follow-$MAJOR.js
cp util/json.js json-$MAJOR.js
cp util/midi.js setmidi-$MAJOR.js
cp util/toaudio.js toaudio-$MAJOR.js
cat util/play.js util/toaudio.js util/toaudio5.js util/midi.js\
 util/sf2-parser.js util/tomidi5.js > play-$MAJOR.js
cat util/play.js util/sndgen.js util/sndaud.js util/midi.js\
 util/sf2-parser.js util/sndmid.js > snd-$MAJOR.js

sed "s+@MAJOR@+$MAJOR+" editor/edit.xhtml > edit-$MAJOR.xhtml
sed "s+@MAJOR@+$MAJOR+" editor/abckbd.js > abckbd-$MAJOR.js
sed "s+@MAJOR@+$MAJOR+" editor/abckbd2.js > abckbd2-$MAJOR.js
sed "s+@MAJOR@+$MAJOR+" editor/edit.js > edit-$MAJOR.js

# rules for ninja (ninja-build)

# minifying with 'jsmin' or 'uglifyjs' may be disabled by running
#	NOMIN=1 ninja -v

MAJOR=1

# ninja tool
tool=samu

rule cp
  command = cp $in $out

rule cpm
  command = sed "s+@MAJOR@+$MAJOR+" $in > $out

rule font
  command = fontforge -c 'open("font/abc2svg.sfd").generate("abc2svg.ttf")';$
   fontforge -c 'open("font/abc2svg.sfd").generate("abc2svg.woff")';$
   echo '// abc2svg music font' > font.js;$
   echo "var musicfont = 'url(\"data:application/octet-stream;base64,\\" >> font.js;$
   base64 abc2svg.ttf | sed 's/$$/\\/' >> font.js;$
   echo "\") format(\"truetype\")'" >> font.js

rule jsc
  command = VERSION=`grep '"version"' package.json|cut -d'"' -f4`;$
   if command -v fossil >/dev/null 2>&1; then $

	c=`fossil info | grep checkout:`;$
	t=`fossil info | grep tags: | awk '{print $$NF}'`;$
	if [ "$${t#v}" != "$$VERSION" ]; then $
		VERSION="$${VERSION}-$$(echo $$c | cut -d' ' -f2 | cut -c1-10)";$
	fi;$
	DATE=`echo $$c | cut -d' ' -f3`;$
   else $
	DATE=`date '+%Y-%m-%d' -r package.json`;$
   fi;$
   cp core/license $out;$
   if [ "x$$NOMIN" = "x" ]; then $
      if command -v jsmin >/dev/null 2>&1; then $
	cat $in | jsmin >> $out;$
      else $
	cat $in | uglifyjs >> $out;$
     fi;$
   else $
	cat $in >> $out;$
   fi;$
   echo "abc2svg.version=\"$$VERSION\";abc2svg.vdate=\"$$DATE\"" >> $out

rule jscu
  command = cp core/license $out;$
   if [ "x$$NOMIN" = "x" ]; then $
      if command -v jsmin >/dev/null 2>&1; then $
	cat $in | jsmin >> $out;$
      else $
	uglifyjs $in >> $out;$
      fi;$
   else $
	cat $in >> $out;$
   fi

rule edit
  command = if [ "x$$NOMIN" = "x" ]; then $
      if command -v jsmin >/dev/null 2>&1; then $
	sed "s+@MAJOR@+$MAJOR+" $in | jsmin > $out;$
      else $
	sed "s+@MAJOR@+$MAJOR+" $in | uglifyjs > $out;$
      fi;$
   else $
	sed "s+@MAJOR@+$MAJOR+" $in > $out;$
   fi

# generate all Scc1t2/n.js from sf2-Scc1t2/n.sf2
rule sf
  command = for f in sf2-Scc1t2/*.sf2; do $

build font: font | font/abc2svg.sfd
build sf: sf | Scc1t2/

build abc2svg-$MAJOR.js: jsc core/abc2svg.js core/deco.js core/draw.js $
 font.js core/format.js core/front.js core/music.js core/parse.js core/subs.js $
 core/svg.js core/tune.js core/lyrics.js core/gchord.js core/tail.js $
 core/modules.js | package.json
build mei2svg-$MAJOR.js: jsc core/abc2svg.js core/deco.js core/draw.js $
 font.js core/format.js core/front.js core/music.js core/parse.js core/subs.js $
 core/svg.js core/tune.js core/lyrics.js core/gchord.js core/mei.js core/tail.js $
 core/modules.js | package.json

build ambitus-$MAJOR.js: jscu modules/ambitus.js
build break-$MAJOR.js: jscu modules/break.js
build capo-$MAJOR.js: jscu modules/capo.js
build clair-$MAJOR.js: jscu util/midi.js modules/clair.js
build clip-$MAJOR.js: jscu modules/clip.js
build combine-$MAJOR.js: jscu modules/combine.js
build diag-$MAJOR.js: jscu modules/diag.js
build equalbars-$MAJOR.js: jscu modules/equalbars.js
build grid-$MAJOR.js: jscu modules/grid.js
build grid2-$MAJOR.js: jscu modules/grid2.js
build MIDI-$MAJOR.js: jscu modules/MIDI.js
build page-$MAJOR.js: jscu modules/page.js modules/strftime.js
build perc-$MAJOR.js: jscu modules/perc.js
build psvg-$MAJOR.js: jscu modules/wps.js modules/psvg.js
build soloffs-$MAJOR.js: jscu modules/soloffs.js
build sth-$MAJOR.js: jscu modules/sth.js
build temper-$MAJOR.js: jscu modules/temper.js

build edit-$MAJOR.css: cp editor/edit.css

build abcdoc-$MAJOR.js: jscu util/abcdoc.js
build abcemb-$MAJOR.js: jscu util/abcemb.js
build abcemb1-$MAJOR.js: jscu util/abcemb1.js
build abcemb2-$MAJOR.js: jscu util/abcemb2.js
build abcweb2-$MAJOR.js: jscu util/abcweb2.js
build follow-$MAJOR.js: jscu util/follow.js
build json-$MAJOR.js: jscu util/json.js
build setmidi-$MAJOR.js: jscu util/midi.js
build toaudio-$MAJOR.js: jscu util/toaudio.js
build play-$MAJOR.js: jscu util/play.js util/toaudio.js $
 util/toaudio5.js util/midi.js util/sf2-parser.js util/tomidi5.js
build snd-$MAJOR.js: jscu util/play.js util/sndgen.js $
 util/sndaud.js util/midi.js util/sf2-parser.js util/sndmid.js

build edit-$MAJOR.xhtml: cpm editor/edit.xhtml
build abckbd-$MAJOR.js: edit editor/abckbd.js
build abckbd2-$MAJOR.js: edit editor/abckbd2.js
build edit-$MAJOR.js: edit editor/edit.js

build all: phony abc2svg-$MAJOR.js abcdoc-$MAJOR.js $
 abcemb-$MAJOR.js abcemb1-$MAJOR.js abcemb2-$MAJOR.js $
 abcweb2-$MAJOR.js $
 json-$MAJOR.js $
 setmidi-$MAJOR.js toaudio-$MAJOR.js snd-$MAJOR.js play-$MAJOR.js psvg-$MAJOR.js $
 ambitus-$MAJOR.js break-$MAJOR.js capo-$MAJOR.js clair-$MAJOR.js clip-$MAJOR.js $
 combine-$MAJOR.js diag-$MAJOR.js equalbars-$MAJOR.js grid-$MAJOR.js grid2-$MAJOR.js $
 MIDI-$MAJOR.js page-$MAJOR.js perc-$MAJOR.js soloffs-$MAJOR.js sth-$MAJOR.js $
 temper-$MAJOR.js edit-$MAJOR.css edit-$MAJOR.js edit-$MAJOR.xhtml $
 abckbd-$MAJOR.js abckbd2-$MAJOR.js follow-$MAJOR.js
# not mei2svg-$MAJOR.js

default all

# npm/fossil new release
rule version
  command = npm version $out;$
	tag=`ag '"version"' package.json|cut -d'"' -f4`;$
	fossil commit -m "New release v$$tag" -tag v$$tag;$
	$tool -v;$
	npm publish
build minor: version
build patch: version

	// print or store the error messages
	if (typeof abc2svg.printErr == 'function')
		user.errmsg = function(msg, l, c) { abc2svg.printErr(msg) }
	else
		user.errmsg = function(msg, l, c) { user.errtxt += msg + '\n' }

var	abc				// (global for 'toxxx.js')

// treat a file
function do_file(fn) {
    var	ext, file

	try {
		file = user.read_file(fn)
	} catch (e) {

		// get the file extension
		ext = fn.slice((fn.lastIndexOf('.') - 1 >>> 0) + 2)
		if (!ext) {



			fn += ".abc"
			try {
				file = user.read_file(fn)
			} catch (e) {
			}
		}
	}
	if (!file && fn != "default.abc") {
//		abc2svg.abort(new Error("Cannot read file '" + fn + "'"))
		user.errmsg("Cannot read file '" + fn + "'")
		return
	}
//	if (typeof(utf_convert) == "function")
//		file = utf_convert(file)

	if (fn.slice(-4) == ".mei") {
		if (!abc.mei2mus)
			abc2svg.abort(new Error("No MEI support"));
		abc.mei2mus(file)
		return
	}

	// load the required modules (synchronous)
	abc2svg.modules.load(file)

	// generate
	try {
		abc.tosvg(fn, file)
	} catch (e) {
		abc2svg.abort(e)
	}
} // do_file()

function abc_cmd(cmd, args) {
	var	arg, parm, fn;

	// initialize the backend
	abc = new abc2svg.Abc(user)
	if (typeof global == "object" && !global.abc)
		global.abc = abc
	abc2svg.abc_init(args)

	// load 'default.abc'
	try {
		do_file("default.abc")


	} catch (e) {
	}

	while (1) {
		arg = args.shift()
		if (!arg)
			break

		do_file(fn);

	abc2svg.abc_end()
}

// nodejs
if (typeof module == 'object' && typeof exports == 'object') {

	exports.user = user;
	exports.abc_cmd = abc_cmd
}

// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with abc2svg-core.  If not, see <http://www.gnu.org/licenses/>.

// define the abc2svg object is not yet done
if (typeof abc2svg == "undefined")
	var abc2svg = {};

// constants
abc2svg.C = {
	BLEN: 1536,

	// symbol types
	BAR: 0,
	CLEF: 1,
	CUSTOS: 2,
	GRACE: 4,

	// slur/tie types (3 + 1 bits)
	SL_ABOVE: 0x01,
	SL_BELOW: 0x02,
	SL_AUTO: 0x03,
	SL_HIDDEN: 0x04,
	SL_DOTTED: 0x08		// (modifier bit)
    };

	// key table - index = number of accidentals + 7
abc2svg.keys = [
	new Int8Array([-1,-1,-1,-1,-1,-1,-1 ]),	// 7 flat signs
	new Int8Array([-1,-1,-1, 0,-1,-1,-1 ]),	// 6 flat signs
	new Int8Array([ 0,-1,-1, 0,-1,-1,-1 ]),	// 5 flat signs
	new Int8Array([ 0,-1,-1, 0, 0,-1,-1 ]),	// 4 flat signs
	new Int8Array([ 0, 0,-1, 0, 0,-1,-1 ]),	// 3 flat signs
	new Int8Array([ 0, 0,-1, 0, 0, 0,-1 ]),	// 2 flat signs
	new Int8Array([ 0, 0, 0, 0, 0, 0,-1 ]),	// 1 flat signs
	new Int8Array([ 0, 0, 0, 0, 0, 0, 0 ]),	// no accidental
	new Int8Array([ 0, 0, 0, 1, 0, 0, 0 ]),	// 1 sharp signs
	new Int8Array([ 1, 0, 0, 1, 0, 0, 0 ]),	// 2 sharp signs
	new Int8Array([ 1, 0, 0, 1, 1, 0, 0 ]),	// 3 sharp signs
	new Int8Array([ 1, 1, 0, 1, 1, 0, 0 ]),	// 4 sharp signs
	new Int8Array([ 1, 1, 0, 1, 1, 1, 0 ]),	// 5 sharp signs
	new Int8Array([ 1, 1, 1, 1, 1, 1, 0 ]),	// 6 sharp signs
	new Int8Array([ 1, 1, 1, 1, 1, 1, 1 ])	// 7 sharp signs
]

// base-40 representation of musical pitch
// (http://www.ccarh.org/publications/reprints/base40/)
abc2svg.p_b40 = new Int8Array(			// staff pitch to base-40
//		  C  D   E   F   G   A   B
		[ 2, 8, 14, 19, 25, 31, 37 ])
abc2svg.b40_p = new Int8Array(			// base-40 to staff pitch
//		       C		 D
		[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
//	      E		     F		       G
	2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
//	      A			B
	5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6 ])
abc2svg.b40_a = new Int8Array(			// base-40 to accidental
//		         C		     D
		[-2, -1, 0, 1, 2, 0, -2, -1, 0, 1, 2, 0,
//		E		 F		     G
	-2, -1, 0, 1, 2, -2, -1, 0, 1, 2, 0, -2, -1, 0, 1, 2, 0,
//		A		    B
	-2, -1, 0, 1, 2, 0, -2, -1, 0, 1, 2 ])
abc2svg.b40_m = new Int8Array(			// base-40 to midi
//			 C		   D
		[-2, -1, 0, 1, 2, 0, 0, 1, 2, 3, 4, 0,
//	      E		     F		       G
	2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 0, 5, 6, 7, 8, 9, 0,
//	      A			    B
	7, 8, 9, 10, 11, 0, 9, 10, 11, 12, 13 ])
abc2svg.b40k =  new Int8Array(		// base-40 interval to possible transposition
//		        C		  D
		[36, 1, 2, 3, 8, 2, 2, 7, 8,13,14, 2,
//		    37
//	       E	      F		        G
	 8,13,14,19,20,13,14,19,20,25, 2,19,24,25,30,31, 2,
//					    20
//	       A		 B
	25,30,31,36,37, 2,31,36,37,38, 3 ])
//				    2
abc2svg.b40sf = new Int8Array(		// base-40 interval to key signature
//		        C		   D
		[-2,-7, 0, 7, 2, 88, 0,-5, 2,-3, 4, 88,
//	       E	      F		        G
	 2,-3, 4,-1, 6,-3, 4,-1, 6, 1,88,-1,-6, 1,-4, 3,88,
//	       A		 B
	 1,-4, 3,-2, 5,88, 3,-2, 5, 0, 7 ])
abc2svg.isb40 = new Int8Array(		// interval with sharp to base-40 interval
	[0, 1, 6,11,12,17,18,23,28,29,34,35])
abc2svg.ifb40 = new Int8Array(		// interval with flat to base-40 interval
	[0, 5, 6,11,12,17,22,23,28,29,34,39])

abc2svg.pab40 = function(p, a) {
	p += 19				// staff pitch from C-1
   var	b40 = ((p / 7) | 0) * 40 + abc2svg.p_b40[p % 7]
	if (a && a != 3)		// if some accidental, but not natural
		b40 += a
	return b40
} // pit2b40()
abc2svg.b40p = function(b) {
	return ((b / 40) | 0) * 7 + abc2svg.b40_p[b % 40] - 19
} // b40p()
abc2svg.b40a = function(b) {
	return abc2svg.b40_a[b % 40]
} // b40a()
abc2svg.b40m = function(b) {
	return ((b / 40) | 0) * 12 + abc2svg.b40_m[b % 40]
} // b40m()

// compare pitches
// This function is used to sort the note pitches
abc2svg.pitcmp = function(n1, n2) { return n1.pit - n2.pit }

// start of the Abc object
abc2svg.Abc = function(user) {
	"use strict";

    // constants
    var	C = abc2svg.C;

	// mask some unsafe functions
    var	require = empty_function,

	IN = 96,		// resolution 96 PPI
	CM = 37.8,		// 1 inch = 2.54 centimeter
	YSTEP = 256		/* number of steps for y offsets */

// error texts
var errs = {
	bad_char: "Bad character '$1'",
	bad_grace: "Bad character in grace note sequence",
	bad_val: "Bad value in $1",
	bar_grace: "Cannot have a bar in grace notes",
	ignored: "$1: inside tune - ignored",
	misplaced: "Misplaced '$1' in %%score",
	must_note: "!$1! must be on a note",
	must_note_rest: "!$1! must be on a note or a rest",
	nonote_vo: "No note in voice overlay",
	not_ascii: "Not an ASCII character",
	not_enough_n: 'Not enough notes/rests for %%repeat',
	not_enough_m: 'Not enough measures for %%repeat',
	not_enough_p: "Not enough parameters in %%map",
	not_in_tune: "Cannot have '$1' inside a tune"
}

    var	self = this,				// needed for modules
	glovar = {
		meter: {
			type: C.METER,		// meter in tune header
			wmeasure: 1,		// no M:
			a_meter: []		// default: none
		}
	},
	info = {},			// information fields


	parse = {
		ctx: {},
		prefix: '%',
		state: 0,
		ottava: [],
		line: new scanBuf
	},
	tunes = [],		// first time symbol and voice array per tune for playing
	psvg			// PostScript

// utilities
function clone(obj, lvl) {
	if (!obj)
		return obj
	var tmp = new obj.constructor
	for (var k in obj)
	    if (obj.hasOwnProperty(k)) {
		if (lvl && typeof obj[k] == 'object')
			tmp[k] = clone(obj[k], lvl - 1)
		else
			tmp[k] = obj[k]
	    }

	}
	user.errmsg(h + txt, l, c)
}

function error(sev, s, msg, a1, a2, a3, a4) {
	var i, j, regex, tmp

	if (!sev && cfmt.quiet)
		return
	if (user.textrans) {
		tmp = user.textrans[msg]
		if (tmp)
			msg = tmp
	}
	if (arguments.length > 3)
		msg = msg.replace(/\$./g, function(a) {

// decorations - populate with standard decorations
var decos = {
	dot: "0 stc 5 1 1",
	tenuto: "0 emb 5 3 3",
	slide: "1 sld 3 7 0",
	arpeggio: "2 arp 12 10 0",
	roll: "3 roll 7 6 6",
	fermata: "3 hld 10 7 7",
	emphasis: "3 accent 7 4 4",
	lowermordent: "3 lmrd 10 5 5",
	coda: "3 coda 24 10 10",
	uppermordent: "3 umrd 10 5 5",
	segno: "3 sgno 22 8 8",
	trill: "3 trl 14 5 5",
	upbow: "3 upb 10 5 5",
	downbow: "3 dnb 9 5 5",
	gmark: "3 grm 6 5 5",
	wedge: "0 wedge 7 3 3",		// (staccatissimo or spiccato)
	turnx: "3 turnx 10 0 5",
	breath: "3 brth 0 1 20",
	longphrase: "3 lphr 0 1 1",
	mediumphrase: "3 mphr 0 1 1",
	shortphrase: "3 sphr 0 1 1",
	invertedfermata: "3 hld 10 7 7",
	invertedturn: "3 turn 10 0 5",
	invertedturnx: "3 turnx 10 0 5",
	"0": "3 fng 8 3 3 0",
	"1": "3 fng 8 3 3 1",
	"2": "3 fng 8 3 3 2",
	"3": "3 fng 8 3 3 3",
	"4": "3 fng 8 3 3 4",

	mp: "6 mp 18 6 16",
	p: "6 p 18 2 8",
	pp: "6 pp 18 5 14",
	ppp: "6 ppp 18 8 20",
	pppp: "6 pppp 18 10 25",
	pralltriller: "3 umrd 10 5 5",
	sfz: "6 sfz 18 4 10",
	ped: "4 ped 18 6 10",
	"ped-up": "4 pedoff 12 4 4",
	"ped(": "4 lped 20 1 1",
	"ped)": "4 lped 20 1 1",
	"crescendo(": "6 cresc 18 0 0",
	"crescendo)": "6 cresc 18 0 0",
	"<(": "6 cresc 18 0 0",
	"<)": "6 cresc 18 0 0",
	"diminuendo(": "6 dim 18 0 0",

//		de.y = s.y;
		return
	}
	if (s.multi)
		up = s.multi > 0
	else
		up = s.stem < 0
	if (up) {
		y = s.ymx | 0
	} else if (dd.name[0] == 'w') {
		de.inv = true
		y = s.ymn
	} else {
		y = s.ymn - dd.h
	}
	if (y > -6 && y < 24) {
		if (up)
			y += 3;
		y = (((y + 6) / 6) | 0) * 6 - 6		/* between lines */
	}
	if (up)
		s.ymx = y + dd.h
	else if (dd.name[0] == 'w')
		s.ymn = y - dd.h
	else
		s.ymn = y
	de.y = y

	if (s.type == C.NOTE)
		de.x += s.notes[s.stem >= 0 ? 0 : s.nhd].shhd
	if (dd.name[0] == 'd'			/* if dot decoration */
	 && s.nflags >= -1) {			/* on stem */
		if (up) {
			if (s.stem > 0)
				de.x += 3.5	// stem_xoff

				error(1, s,
					"!$1! must be on the last of a couple of notes",
					dd.name)
				continue
			}
			s.trem2 = true;
			s.beam_end = true;
			s.beam_st = false;
			prev.beam_st = true;
			prev.beam_end = false;
			s.ntrem = prev.ntrem = Number(dd.name[4]);
			for (j = 0; j <= s.nhd; j++)
				s.notes[j].dur *= 2;
			for (j = 0; j <= prev.nhd; j++)
				prev.notes[j].dur *= 2
			continue
		case 35:		/* xstem */

			 || stv_g.st < 0)	// or not staff scale
// || voice_tb[s.v].scale != 1)
				out_deco_val(x, y, f, de.val / stv_g.scale, de.defl)
			else
				out_deco_val(x, y, f, de.val, de.defl)
			if (de.defl.noen)
				new_de.push(de.start)	// to be continued next line
		} else if (dd.str != undefined) {

			str = dd.str
			if (str[0] == '@') {
				a = str.match(/^@([0-9.-]+),([0-9.-]+);?/);
				x += Number(a[1]);
				y += Number(a[2]);
				str = str.replace(a[0], "")
			}

			} else if (dd.dd_st) {
				de.lden = true;
				de.defl.nost = true
			}
		}
	} // create_dh()

	// create all decorations of a note (chord and heads)
	function create_all(s) {
		var m

		if (s.a_dd)
			create_deco(s)
		if (s.notes) {
			for (m = 0; m < s.notes.length; m++) {

//	- chord symbols
//	- repeat brackets
/* (the staves are not yet defined) */
/* (unscaled delayed output) */
function draw_deco_staff() {
	var	s, first_gchord, p_voice, x, y, w, i, v, de, dd,
		gch, gch2, ix, top, bot,
		minmax = new Array(nstaff + 1),
		nd = a_de.length

	/* draw the repeat brackets */
	function draw_repbra(p_voice) {
		var s, s1, y, y2, i, p, w, wh, first_repeat;

		/* search the max y offset */

			if (gch.type != 'g')
				continue
			gch2 = gch	// chord closest to the staff
			if (gch.y < 0)
				break
		}
		if (gch2) {
			w = gch2.wh[0]
			if (gch2.y >= 0) {
				y = y_get(s.st, true, s.x, w)
				if (y > minmax[s.st].ymax)
					minmax[s.st].ymax = y
			} else {
				y = y_get(s.st, false, s.x, w)
				if (y < minmax[s.st].ymin)

			y = y_get(st, true, 0, 20)
			if (y < staff_tb[st].topbar + 14)
				y = staff_tb[st].topbar + 14;
			xy_str(0, y, bar_num.toString());
			y_set(st, true, 0, 20, y + gene.curfont.size + 2)
		} else if (bar_num % cfmt.measurenb == 0) {
			for ( ; ; s = s.ts_next) {
				switch (s.type) {
				case C.TIMESIG:
				case C.CLEF:
				case C.KEYSIG:
				case C.FMTCHG:
				case C.STBRK:
					continue
				}
				break
			}



			// don't display the number twice
		     if (s.type != C.BAR || !s.bar_num) {
			if (s.prev)
				s = s.prev;
			x = s.x + s.wr;
			any_nb = true;
			w = w0
			if (bar_num >= 10)
				w *= bar_num >= 100 ? 3 : 2
			if (gene.curfont.box)
				w += 4;
			y = y_get(st, true, x, w)

					break
			}
			set_dscale(st)
			continue
		default:
			continue
		case C.BAR:
			if (!s.bar_num || s.bar_num <= 1)
				continue
			break
		}

		bar_num = s.bar_num
		if (cfmt.measurenb == 0
		 || (bar_num % cfmt.measurenb) != 0

	}
	gene.nbar = bar_num

	if (font_size)
		param_set_font("measurefont", "* " + font_size.toString());
}



























































































































/* -- draw the parts and the tempo information -- */
/* (the staves are being defined) */
function draw_partempo(st, top) {
	var	s, some_part, some_tempo, h, w, y,
		dy = 0,		/* put the tempo indication at top */
		ht = 0

	/* get the minimal y offset */
	var	ymin = staff_tb[st].topbar + 8,
		dosh = 0,
		shift = 1,
		x = -100	// (must be negative for %%soloffs)

	for (s = tsfirst; s; s = s.ts_next) {
		if (s.type != C.TEMPO || s.del)
			continue
		if (!some_tempo)
			some_tempo = s;
		w = s.tempo_wh[0]
		if (s.time == 0 && s.x > 40)	// at start of tune and no %%soloffs,
			s.x = 40;	// shift the tempo over the key signature
		y = y_get(st, true, s.x - 16, w)
		if (y > ymin)
			ymin = y
		if (x >= s.x - 16 && !(dosh & (shift >> 1)))
			dosh |= shift;
		shift <<= 1;
		x = s.x - 16 + w
	}
	if (some_tempo) {
		set_sscale(-1);
		set_font("tempo");
		ht = gene.curfont.size + 8;
		y = 2 - ht;
		h = y - ht
		if (dosh != 0)
			ht *= 2
		if (top < ymin + ht)
			dy = ymin + ht - top

		/* draw the tempo indications */
		for (s = some_tempo; s; s = s.ts_next) {
			if (s.type != C.TEMPO
			 || s.del)		// (displayed by %%titleformat)
				continue
			if (user.anno_start || user.anno_stop) {
				s.wl = 16;
				s.wr = 30;
				s.ymn = (dosh & 1) ? h : y;
				s.ymx = s.ymn + 14;
				anno_start(s)
			}
			writempo(s, s.x - 16, (dosh & 1) ? h : y);
			anno_stop(s);
			dosh >>= 1
		}
	}

	/* then, put the parts */
/*fixme: should reduce vertical space if parts don't overlap tempo...*/

	STEM_CH_MIN	= 14,	/* min stem height for chords under beams */
	STEM_CH_MIN2	= 10,	/* ... for notes with two beams */
	STEM_CH_MIN3	= 9,	/* ... for notes with three beams */
	STEM_CH_MIN4	= 9,	/* ... for notes with four beams */
	BEAM_DEPTH	= 3.2,	/* width of a beam stroke */
	BEAM_OFFSET	= .25,	/* pos of flat beam relative to staff line */
	BEAM_SHIFT	= 5,	/* shift of second and third beams */

	BEAM_STUB	= 8,	/* length of stub for flag under beam */ 
	SLUR_SLOPE	= .5,	/* max slope of a slur */
	GSTEM		= 15,	/* grace note stem length */
	GSTEM_XOFF	= 2.3	/* x offset for grace note stem */

    var cache

	d1 = rnd6(top - BEAM_OFFSET);
	d2 = rnd6(bot + BEAM_OFFSET)
	return d1 * d1 > d2 * d2 ? d2 : d1
}

/* duplicate a note for beaming continuation */
function sym_dup(s) {
    var	m, note


	s = clone(s)
	s.invis = true
	delete s.extra;
	delete s.text
	delete s.a_gch
	delete s.a_ly
	delete s.a_dd;
	s.notes = clone(s.notes)
	for (m = 0; m <= s.nhd; m++) {
		note = s.notes[m] = clone(s.notes[m])
		delete note.a_dcn
	}
	return s
}

/* -- calculate a beam -- */
/* (the staves may be defined or not) */
var min_tb = [
	[STEM_MIN, STEM_MIN,
		STEM_MIN2, STEM_MIN3, STEM_MIN4, STEM_MIN4],
	[STEM_CH_MIN, STEM_CH_MIN,
		STEM_CH_MIN2, STEM_CH_MIN3, STEM_CH_MIN4, STEM_CH_MIN4]
]

// (possible hook)
Abc.prototype.calculate_beam = function(bm, s1) {
    var	s, s2, g, notes, nflags, st, v, two_staves, two_dir,
		x, y, ys, a, b, stem_err, max_stem_err,
		p_min, p_max, s_closest,
		stem_xoff, scale,
		visible, dy

	if (!s1.beam_st) {	/* beam from previous music line */
		s = sym_dup(s1);
		lkvsym(s, s1);
		lktsym(s, s1);
		s.x -= 12
		if (s.x > s1.prev.x + 12)
			s.x = s1.prev.x + 12;
		s.beam_st = true
		delete s.beam_end;
		s.tmp = true
		delete s.sls;

		s1 = s
	}

	/* search last note in beam */
	notes = nflags = 0;	/* set x positions, count notes and flags */
	two_staves = two_dir = false;
	st = s1.st;

			if (s.ts_next)
				s.ts_next.ts_prev = s;
			s2.ts_next = s;
			s.ts_prev = s2
			delete s.beam_st;
			s.beam_end = true;
			s.tmp = true
			delete s.sls;

			s.x += 12
			if (s.x < realwidth - 12)
				s.x = realwidth - 12;
			s2 = s;
			notes++
			break
		}

			}
		}
		s.xs = s.x + x * scale;
		if (s == s2)
			break
	}

	// have flat beams on grace notes when asked
	if (s.grace && cfmt.flatbeams)
		a = 0

	// if a note inside the beam is the closest to the beam, the beam is flat
	else if (!two_dir
	      && notes >= 3
	      && s_closest != s1 && s_closest != s2)
		a = 0

	y = s1.ys + staff_tb[st].y
	if (a == undefined)
		a = (s2.ys + staff_tb[s2.st].y - y) / (s2.xs - s1.xs)

	if (a != 0)
		a = cfmt.beamslope * a /
			(cfmt.beamslope + Math.abs(a)) // max steepness for beam




	// pivot around the middle of the beam
	b = (y + s2.ys + staff_tb[s2.st].y) / 2 - a * (s2.xs + s1.xs) / 2

/*fixme: have a look again*/
	/* have room for the symbols in the staff */
	max_stem_err = 0;		/* check stem lengths */

			xygl(x, y, "acc" + acc + '_' + micro_n + '_' + micro_d)
			return
		}
	}
	xygl(x, y, "acc" + acc)
}

// draw helper lines
//fixme: double lines when needed for different voices
// (possible hook)
Abc.prototype.draw_hl = function(x, s, hltype) {
    var	i, j, n,
	hla = [],
	st = s.st,
	p_staff = staff_tb[st]

	// check if any helper line
	if (!p_staff.hll)
		return			// no helper line (no line)
	for (i = 0; i <= s.nhd; i++) {
		if (!p_staff.hlmap[s.notes[i].pit - p_staff.hll])
			hla.push((s.notes[i].pit - 18) * 3)
	}
	n = hla.length
	if (!n)
		return			// no

	// handle the helper lines out of the staff
    var	staffb = p_staff.y,
	stafflines = p_staff.stafflines,
	top = (stafflines.length - 1) * 6,
	bot = p_staff.botline,
	yl = bot,


	yu = top

	for (i = 0; i < hla.length; i++) {
		if (hla[i] < yl) {
			yl = (((hla[i] + 51) / 6) | 0) * 6 - 48;

			n--



		} else if (hla[i] > yu) {
			yu = ((hla[i] / 6) | 0) * 6;

			n--





		}
	}
	for (; yl < bot; yl += 6)
		xygl(x, staffb + yl, hltype)
	for (; yu > top; yu -= 6)
		xygl(x, staffb + yu, hltype)
	if (!n)
		return			// no more helper lines

	// draw the helper lines inside the staff
	i = yl;
	j = yu
	while (i > bot && stafflines[i / 6] == '-')
		i -= 6
	while (j < top && stafflines[j / 6] == '-')
		j += 6
	for ( ; i < j; i += 6) {
		if (stafflines[i / 6] == '-')
			xygl(x, staffb + i, hltype)	// hole
	}
}

/* -- draw a key signature -- */
// (possible hook)
var	sharp_cl = new Int8Array([24, 9, 15, 21, 6, 12, 18]),
	flat_cl = new Int8Array([12, 18, 24, 9, 15, 21, 6]),
	sharp1 = new Int8Array([-9, 12, -9, -9, 12, -9]),
	sharp2 = new Int8Array([12, -9, 12, -9, 12, -9]),
	flat1 = new Int8Array([9, -12, 9, -12, 9, -12]),
	flat2 = new Int8Array([-12, 9, -12, 9, -12, 9])

Abc.prototype.draw_keysig = function(x, s) {
	if (s.k_none || s.k_play)
		return
	var	old_sf = s.k_old_sf,
		st = s.st,
		staffb = staff_tb[st].y,
		i, shift, p_seq,
		clef_ix = s.k_y_clef

			}
		}
	} else if (s.k_a_acc.length) {

		/* explicit accidentals */
		var	acc,
			last_acc = s.k_a_acc[0].acc,
			last_shift = 100,
			s2 = {
				st: st,
				nhd: 0,
				notes: [{}]
			}

		for (i = 0; i < s.k_a_acc.length; i++) {
			acc = s.k_a_acc[i];
			shift = (s.k_y_clef	// clef shift
				+ acc.pit - 18) * 3
			if (i != 0
			 && (shift > last_shift + 18
			  || shift < last_shift - 18))
				x -= 5.5		// no clash
			else if (acc.acc != last_acc)
				x += 3;
			last_acc = acc.acc;
			s2.notes[0].pit = shift / 3 + 18;
			self.draw_hl(x, s2, "hl");
			last_shift = shift;
			draw_acc(x, staffb + shift,
				 acc.acc, acc.micro_n, acc.micro_d);
			x += 5.5
		}
	}
}

/* (the staves are defined) */
var rest_tb = [
	"r128", "r64", "r32", "r16", "r8",
	"r4",
	"r2", "r1", "r0", "r00"]

function draw_rest(s) {
    var	s2, i, j, x, y, yb, bx,
	p_staff = staff_tb[s.st]

	// if rest alone in the measure or measure repeat,
	// change the head and center
	if (s.dur_orig == s.p_v.meter.wmeasure
	 || (s.rep_nb && s.rep_nb >= 0)) {
		if (s.dur < C.BLEN * 2)
			s.nflags = -2		// semibreve / whole
		else if (s.dur < C.BLEN * 4)
			s.nflags = -3
		else
			s.nflags = -4;
		s.dots = 0;

		/* don't use next/prev: there is no bar in voice overlay */
		s2 = s.ts_next
		while (s2 && s2.time != s.time + s.dur)
			s2 = s2.ts_next;
		x = s2 ? s2.x : realwidth;
		s2 = s

		anno_stop(s)
		return
	}

	set_scale(s);
	anno_start(s);

	if (s.notes[0].color)
		set_color(s.notes[0].color);

	y = s.y;

	i = 5 - s.nflags		/* rest_tb index (5 = C_XFLAGS) */
	if (i == 7 && y == 12
	 && p_staff.stafflines.length <= 2)
		y -= 6				/* semibreve a bit lower */

	// draw the rest
	xygl(x, y + yb, s.notes[0].head || rest_tb[i])

	/* output ledger line(s) when greater than minim */
	if (i >= 6) {
		j = y / 6
		switch (i) {
		default:
			switch (p_staff.stafflines[j + 1]) {

		x += 8;
		y += yb + 3
		for (i = 0; i < s.dots; i++) {
			xygl(x, y, "dot");
			x += 3.5
		}
	}
	set_color();
	anno_stop(s)
}

/* -- draw grace notes -- */
/* (the staves are defined) */
function draw_gracenotes(s) {
    var	yy, x0, y0, x1, y1, x2, y2, x3, y3, bet1, bet2, slur,
	dy1, dy2, g, last, note,
	bm = {}

	/* draw the notes */
//	bm.s2 = undefined			/* (draw flags) */
	for (g = s.extra; g; g = g.next) {
		if (g.beam_st && !g.beam_end) {
			if (self.calculate_beam(bm, g))
				draw_beams(bm)
		}
		anno_start(g);
		draw_note(g, !bm.s2)
		if (g == bm.s2)
			bm.s2 = null			/* (draw flags again) */
		anno_stop(g)
		if (g.sls || g.sl2)
			slur = true
		if (!g.next)
			break			/* (keep the last note) */
	}

	// if an acciaccatura, draw a bar 
	if (s.sappo) {
		g = s.extra

				x1, y1, g.stem > 0)
	}

	/* slur */
//fixme: have a full key symbol in voice
	if (s.p_v.key.k_bagpipe			/* no slur when bagpipe */
	 || !cfmt.graceslurs
	 || slur				// explicit slur
	 || s.tie_s				// some tie
	 || !s.next
	 || s.next.type != C.NOTE)
		return
	last = g
	if (((g.stem >= 0 || s.multi < 0) && g.notes[0].pit <= 28)
	 || g.notes[0].pit < 16) {		// slur below
		yy = 127
		for (g = s.extra; g; g = g.next) {
			if (g.y < yy) {
				yy = g.y;
				last = g
			}
		}
		x0 = last.x;
		y0 = last.y - 5
		if (s.extra != last) {
			x0 -= 4;
			y0 += 1
		}
		s = s.next;
		x3 = s.x - 1
		if (s.stem < 0 && s.nflags > -2)
			x3 -= 4;
		y3 = 3 * (s.notes[0].pit - 18) - 5;
		dy1 = (x3 - x0) * .4
		if (dy1 > 3)
			dy1 = 3;
		dy2 = dy1;
		bet1 = .2;

			dy2 = (y0 - y3) * .2;
			bet1 = 0
		} else if (y3 > y0 + 4) {
			y3 = y0 + 4;
			x0 = last.x + 2;
			y0 = last.y - 4
		}
	} else {				// slur above
		yy = -127
		for (g = s.extra; g; g = g.next) {
			if (g.y > yy) {
				yy = g.y;
				last = g
			}
		}
		x0 = last.x;
		y0 = last.y + 5
		if (s.extra != last) {
			x0 -= 4;
			y0 -= 1
		}
		s = s.next;
		x3 = s.x - 1
		if (s.stem >= 0 && s.nflags > -2)
			x3 -= 2;
		y3 = 3 * (s.notes[s.nhd].pit - 18) + 5;
		dy1 = (x0 - x3) * .4
		if (dy1 < -3)
			dy1 = -3;
		dy2 = dy1;
		bet1 = .2;

	return staff_tb[s.st].y + 3 * (note.pit - 18)
}

/* -- draw m-th head with accidentals and dots -- */
/* (the staves are defined) */
// sets {x,y}_note
function draw_basic_note(x, s, m, y_tb) {
	var	i, p, yy, dotx, doty, inv,
		old_color = false,
		note = s.notes[m],
		staffb = staff_tb[s.st].y,	/* bottom of staff */
		y = 3 * (note.pit - 18),	/* note height on staff */
		shhd = note.shhd * stv_g.scale,
		x_note = x + shhd,
		y_note = y + staffb

		default:			// black note
			p = "hd"
			break
		}
	}
	if (note.color != undefined)
		old_color = set_color(note.color)


	if (p) {
		if (inv) {
			g_open(x_note, y_note, 0, 1, -1);
			x_note = y_note = 0
		}
		if (!self.psxygl(x_note, y_note, p))
			xygl(x_note, y_note, p)

		dotx = x + (7.7 + s.xmx) * stv_g.scale
		if (y_tb[m] == undefined) {
			y_tb[m] = 3 * (s.notes[m].pit - 18)
			if ((s.notes[m].pit & 1) == 0)
				y_tb[m] += 3
		}
		doty = y_tb[m] + staffb
		i = (note.dur / 12) >> ((5 - nflags) - dots)
		while (dots-- > 0) {
			xygl(dotx, doty, (i & (1 << dots)) ? "dot" : "dot+")
			dotx += 3.5
		}
	}

	/* draw the accidental */
	if (note.acc) {
		x -= note.shac * stv_g.scale

	note = s.notes[s.stem < 0 ? s.nhd : 0];	// master note head
	x_hl = x = x_head(s, note);
	staffb = staff_tb[s.st].y

	/* output the ledger lines */
	if (s.grace) {
		hltype = "ghl";
		x_hl += 1.5
	} else {
		hltype = "hl"
		switch (s.head) {
		case C.OVALBARS:
		case C.OVAL:
			x_hl -= .3;
			hltype = "hl1"
			break
		case C.SQUARE:
			x_hl -= 2;
			hltype = "hl1"
			break
		}
	}

	self.draw_hl(x_hl, s, hltype)

	/* draw the stem and flags */
	y = y_head(s, note)
	if (!s.stemless) {
		slen = s.ys - s.y;
		nflags = s.nflags
		if (s.ntrem)

			out_stem(x, y, slen, s.grace,
				 nflags, cfmt.straightflags)
		}
	} else if (s.xstem) {				/* cross-staff stem */
		s2 = s.ts_prev;
		slen = (s2.stem > 0 ? s2.y : s2.ys) - s.y;
		slen += staff_tb[s2.st].y - staffb;


		out_stem(x, y, slen)
	}

	/* draw the tremolo bars */
	if (fl && s.trem1) {
		var	ntrem = s.ntrem || 0,
			x1 = x;

	/* draw the note heads */
	x = s.x
	for (m = 0; m <= s.nhd; m++)
		draw_basic_note(x, s, m, y_tb)
}

// find where to start a long decoration












function prev_scut(s) {
	while (s.prev) {
		s = s.prev
		if (s.rbstart)
			return s
	}

	/* return a symbol of any voice starting before the start of the voice */
	s = s.p_v.sym
	while (s.type != C.CLEF)
		s = s.ts_prev		/* search a main voice */
	if (s.next && s.next.type == C.KEY)
		s = s.next
	if (s.next && s.next.type == C.METER)
		return s.next
	return s
}

/* -- decide whether a slur goes up or down (same voice) -- */
function slur_direction(k1, k2) {
    var	s, some_upstem, low, dir

	// check if slur sequence in a multi-voice staff
	function slur_multi(s1, s2) {
//		while (1) {
//			if (s1.multi)		// if multi voice
//				//fixme: may change
//				return s1.multi
//			if (s1 == s2)
//				break
//			s1 = s1.next
//		}
		if (s1.multi)
			return s1.multi
		if (s2.multi)
			return s2.multi
		return 0
	} // slur_multi()

	if (k1.grace && k1.stem > 0)
		return -1

	dir = slur_multi(k1, k2)
	if (dir)
		return dir

	for (s = k1; ; s = s.next) {
		if (s.type == C.NOTE) {
			if (!s.stemless) {
				if (s.stem < 0)
					return 1
				some_upstem = true
			}
			if (s.notes[0].pit < 22)	/* if under middle staff */
				low = true
		}
//		if (s == k2)
		if (s.time == k2.time)		// (k2 may be a grace note)
			break
	}
	if (!some_upstem && !low)
		return 1
	return -1
}

//		dx = 10.
//	dy = 1.6 * dir
	dy = 2 * dir;
	dz = .2 + .001 * (x2 - x1)
	if (dz > .6)
		dz = .6;
	dz *= dir

//	var scale_y = stv_g.st < 0 ? stv_g.scale : 1
	var scale_y = 1			// (see set_dscale())
	if (!dotted)
		output += '<path d="M'
	else
		output += '<path class="stroke" stroke-dasharray="5,5" d="M';
	out_sxsy(x1, ' ', y1);
	output += 'c' +
		((xx1 - x1) / stv_g.scale).toFixed(1) + ' ' +
		((y1 - yy1) / scale_y).toFixed(1) + ' ' +
		((xx2 - x1) / stv_g.scale).toFixed(1) + ' ' +

			((xx1 + dx - x2) / stv_g.scale).toFixed(1) + ' ' +
			((y2 + dz - yy1 - dy) / scale_y).toFixed(1) + ' ' +
			((x1 - x2) / stv_g.scale).toFixed(1) + ' ' +
			((y2 + dz - y1) / scale_y).toFixed(1);
	output += '"/>\n'
}














// draw a slur between two chords / notes
/* (the staves are not yet defined) */
/* (delayed output) */
/* (not a pretty routine, this) */
function draw_slur(path,	// list of symbols under the slur
		not1,		// note if start on a note head
		sl) {		// ending variables: type, note, end on a note
    var	i,
	k, g, x1, y1, x2, y2, height, addy,
	a, y, z, h, dx, dy,
	ty = sl.ty,




	dir = (ty & 0x07) == C.SL_ABOVE ? 1 : -1,
	n = path.length,

	i1 = 0,
	i2 = n - 1,
	k1 = path[0],
	k2 = path[i2]

/*fixme: if two staves, may have upper or lower slur*/

	var	nn = 1,
		upstaff = k1.st,
		two_staves = false

	set_dscale(k1.st)

	for (i = 1; i < n; i++) {
		k = path[i]

		if (k.type == C.NOTE || k.type == C.REST) {
			nn++
			if (k.st != upstaff) {
				two_staves = true
				if (k.st < upstaff)
					upstaff = k.st
			}
		}



	}

/*fixme: KO when two staves*/
if (two_staves) error(2, k1, "*** multi-staves slurs not treated yet");

	/* fix endpoints */
	x1 = k1.x
	if (k1.notes && k1.notes[0].shhd)
		x1 += k1.notes[0].shhd;

	x2 = k2.x
	if (k2.notes)
		x2 += k2.notes[0].shhd







	if (not1) {					// start on a note

		y1 = 3 * (not1.pit - 18) + 2 * dir
		x1 += 3
	} else {					// start on a chord
		y1 = dir > 0 ? k1.ymx + 2 : k1.ymn - 2
		if (k1.type == C.NOTE) {
			if (dir > 0) {
				if (k1.stem > 0) {
					x1 += 5
					if (k1.beam_end
					 && k1.nflags >= -1	/* if with a stem */

					}
//				} else {
//					y1 = k1.y - 8
				}
			}
		}
	}

	if (sl.is_note) {				// end on a note
		y2 = 3 * (sl.note.pit - 18) + 2 * dir
		x2 -= 3
	} else {					// end on a chord
		y2 = dir > 0 ? k2.ymx + 2 : k2.ymn - 2
		if (k2.type == C.NOTE) {
			if (dir > 0) {
				if (k2.stem > 0) {
					x2 += 1
					if (k2.beam_st
					 && k2.nflags >= -1

		else
			y2 = y1
		if (k1 != k2)
			x2 = k2.x - k2.wl * .3
	}

	if (nn >= 3) {
		k = path[1]
		if (k.type != C.BAR
		 && k.x < x1 + 48) {
			if (dir > 0) {
				y = k.ymx - 2
				if (y1 < y)
					y1 = y
			} else {
				y = k.ymn + 2
				if (y1 > y)
					y1 = y
			}
		}
		k = path[i2 - 1]
		if (k.type != C.BAR
		 && k.x > x2 - 48) {
			if (dir > 0) {
				y = k.ymx - 2
				if (y2 < y)
					y2 = y
			} else {
				y = k.ymn + 2
				if (y2 > y)
					y2 = y
			}
		}
	}

	a = (y2 - y1) / (x2 - x1)		/* slur steepness */

		x2 = k2.x + GSTEM_XOFF * 1.5;

	h = 0;
	a = (y2 - y1) / (x2 - x1)
	if (k1 != k2
	 && k1.v == k2.v) {
	    addy = y1 - a * x1
	    for (i = 1; i < i2; i++) {
		k = path[i]
		if (k.st != upstaff)
			continue
		switch (k.type) {
		case C.NOTE:
		case C.REST:
			if (dir > 0) {
				y = 3 * (k.notes[k.nhd].pit - 18) + 6

	} else {
		if (height > -.8 * y)
			height = -.8 * y
	}
	height *= cfmt.slurheight;

//	anno_start(k1_o, 'slur');
	slur_out(x1, y1, x2, y2, dir, height, ty & C.SL_DOTTED);
//	anno_stop(k1_o, 'slur');

	/* have room for other symbols */
	dx = x2 - x1;
	a = (y2 - y1) / dx;
/*fixme: it seems to work with .4, but why?*/
//	addy = y1 - a * x1 + .4 * height
//fixme: the following code seems better!
	addy = y1 - a * x1
	if (height > 0)
		addy += 4 * Math.sqrt(height) - 2
	else
		addy -= 4 * Math.sqrt(-height) - 2
	for (i = 0; i < i2; i++) {
		k = path[i]
		if (k.st != upstaff)
			continue
		y = a * k.x + addy
		if (k.ymx < y)
			k.ymx = y
		else if (k.ymn > y)
			k.ymn = y
		if (i == i2 - 1) {
			dx = x2
			if (k2.sl1)
				dx -= 5;
			y -= height / 3
		} else {
			dx = path[i + 1].x
		}
		if (i != 0)
			x1 = k.x
		else
			y -= height / 3
		dx -= x1;
		y_set(upstaff, dir > 0, x1, dx, y)
	}

}

/* -- draw the slurs between 2 symbols --*/
function draw_slurs(s, last) {
    var	gr1, i, m, note, sls, nsls

	// draw a slur knowing the start and stop elements
	function draw_sls(s,		// start symbol
			sl,		// stop note
			snote) {	// optional start note
	    var	k, v, i, dir,
		path = [],
		enote = sl.note,
		s2 = enote.s			// end of slur

		if (last && s2.time > last.time)
			return			// will be drawn next time

		// if the slur continues on the next music line,
		// stop it on the invisible bar at end of current line
		if (tsnext && s2.time >= tsnext.time) {
			s.p_v.sls.push(sl);		// continuation on next line
			s2 = s.p_v.s_next.prev		// one voice
			while (s2.next)
				s2 = s2.next;		// search the ending bar
			sl = Object.create(sl);		// new slur
			sl.note = {
				s: s2
			}
		}

		// set the slur position
		switch (sl.ty & 0x07) {
		case C.SL_ABOVE: dir = 1; break
		case C.SL_BELOW: dir = -1; break
		default:
			if (s.v != s2.v)
				dir = -1	// always above ?
			else
				dir = slur_direction(s, s2);
			sl.ty &= ~0x07;
			sl.ty |= dir > 0 ? C.SL_ABOVE : C.SL_BELOW
			break
		}

		// build the path of the symbols under the slur
		if (dir *			// if slur on first voice
			(cur_sy.voices[s.v].range <= cur_sy.voices[s2.v].range ?
				1 : -1) > 0)
			v = s.v
		else
			v = s2.v

		if (gr1				// if start on a grace note
		 && !(s2.grace			// and not end in the same
		   && s.v == s2.v		// grace note sequence
		   && s.time == s2.time)) {
			do {
				path.push(s);	// add all grace notes
				s = s.next
			} while (s);
			s = gr1.next
		} else {
			path.push(s);
			if (s.grace)
				s = s.next
			else
				s = s.ts_next
		}

		if (!s2.grace) {		// if end on a normal note
			while (1) {
				if (s.v == v)
					path.push(s)
				if (s == s2)
					break
				s = s.ts_next
			}
		} else if (s.grace) {		// if start/end in the same sequence
			while (1) {
				if (s.v == v)
					path.push(s)
				if (s == s2)
					break
				s = s.next
			}
		} else {			// end on a grace note
			k = s2
			while (k.prev)
				k = k.prev	// .extra pointer
			while (1) {
				if (s.v == v)
					path.push(s)
				if (s.extra == k)
					break
				s = s.ts_next
			}
			s = k
			while (1) {
				path.push(s)
				if (s == s2)
					break
				s = s.next
			}
		}

		// if some nested slurs/tuplets, draw them
		for (i = 1; i < path.length - 1; i++) {
			s = path[i]
			if (s.sls || s.sl1)
				draw_slurs(s, last)
			if (s.tp)
				draw_tuplet(s)
		}
		draw_slur(path, snote, sl)
		return 1			// slur drawn, remove it
	} // draw_sls()

	// code of draw_slurs()
	while (1) {
		if (!s || s == last) {
			if (!gr1		// if end of grace notes
			 || !(s = gr1.next)	// return to normal notes
			 || s == last)
				break
			gr1 = null
		}
		if (s.type == C.GRACE) {	// if start of grace notes
			gr1 = s;		// continue in the grace note sequence
			s = s.extra
			continue
		}


		if (s.sls) {			// slurs from the chord
			sls = s.sls









			s.sls = null


















			nsls = []








			for (i = 0; i < sls.length; i++) {












				if (!draw_sls(s, sls[i]))






					nsls.push(sls[i])


			}
			if (nsls.length)


				s.sls = nsls



		}
		if (s.sl1) {			// slurs from the note heads



















			for (m = 0; m <= s.nhd; m++) {
				note = s.notes[m]


				if (note.sls) {
					sls = note.sls

					note.sls = null
					nsls = []





					for (i = 0; i < sls.length; i++) {
						if (!draw_sls(s, sls[i], note))


							nsls.push(sls[i])
					}









					if (nsls.length)





						note.sls = nsls





				}



			}
		}




		s = s.next
	}
}

/* -- draw a tuplet -- */
/* (the staves are not yet defined) */
/* (delayed output) */
/* See http://moinejf.free.fr/abcm2ps-doc/tuplets.xhtml
 * for the value of 'tp.f' */
function draw_tuplet(s1, tp) {

    var	s2, s3, g, upstaff, nb_only, some_slur,
	x1, x2, y1, y2, xm, ym, a, s0, yy, yx, dy, a, dir, r,
	tp = s1.tp.shift()		// tuplet parameters

	if (!s1.tp.length)
		delete s1.tp		// last tuplet

	// treat the slurs and the nested tuplets
	upstaff = s1.st
	set_dscale(s1.st)
	for (s2 = s1; s2; s2 = s2.next) {
		if (s2.type != C.NOTE && s2.type != C.REST) {
			if (s2.type == C.GRACE) {
				for (g = s2.extra; g; g = g.next) {
					if (g.sls || g.sl1)
						draw_slurs(g)
				}
			}
			continue
		}

		if (s2.sls || s2.sl1)
			draw_slurs(s2)
		if (s2.st < upstaff)
			upstaff = s2.st

		if (s2.tp)
			draw_tuplet(s2)
		if (s2.tpe)
			break


	}

	if (!s2) {
		error(1, s1, "No end of tuplet in this music line")




		return
	}




	s2.tpe--








	if (tp.f[0] == 1)			/* if 'when' == never */

		return

	dir = tp.f[3]				// 'where'
	if (!dir) {				// if auto


		s3 = s1
		while (s3.type != C.NOTE)
			s3 = s3.next



		dir = s3.stem > 0 ? C.SL_ABOVE : C.SL_BELOW


	}




	if (s1 == s2				// tuplet with 1 note (!)
	 || tp.f[1] == 2) {			// what == nothing
		nb_only = true
	} else if (tp.f[1] == 1) {			/* 'what' == slur */
		nb_only = true;
		draw_slur([s1, s2], null, {ty: dir})
	} else {

		/* search if a bracket is needed */
		if (tp.f[0] != 2		// if 'when' != always
		 && s1.type == C.NOTE && s2.type == C.NOTE) {


			nb_only = true
			for (s3 = s1; ; s3 = s3.next) {
				if (s3.type != C.NOTE
				 && s3.type != C.REST) {
					if (s3.type == C.GRACE
					 || s3.type == C.SPACE)
						continue

				}
			}
		}
	}

	/* if number only, draw it */
	if (nb_only) {
		if (tp.f[2] == 1)		/* if 'which' == none */
			return
		xm = (s2.x + s1.x) / 2



		a = s2.x - s1.x			// width around the middle


		if (dir == C.SL_ABOVE)
			ym = y_get(upstaff, 1, xm - a / 2, a) + 2



		else
			ym = y_get(upstaff, 0, xm - a / 2, a) - 10








		if (s1.stem * s2.stem > 0) {
			if (s1.stem > 0)
				xm += 1.5
			else
				xm -= 1.5
		}

		if (tp.f[2] == 0)		/* if 'which' == number */
			out_bnum(xm, ym, tp.p)
		else
			out_bnum(xm, ym, tp.p + ':' + tp.q)

		for (s3 = s1; ; s3 = s3.next) {
			if (s3.x >= xm)
				break
		}
		if (dir == C.SL_ABOVE) {
			ym += 10
			if (s3.ymx < ym)
				s3.ymx = ym;
			y_set(upstaff, true, xm - 3, 6, ym)
		} else {
			if (s3.ymn > ym)
				s3.ymn = ym;
			y_set(upstaff, false, xm - 3, 6, ym)
		}
		return
	}

	// here, what is square bracket


/*fixme: two staves not treated*/
/*fixme: to optimize*/



    if (dir == C.SL_ABOVE) {

	/* sole or upper voice: the bracket is above the staff */
	if (s1.st == s2.st) {
		y1 = y2 = staff_tb[upstaff].topbar + 4
	} else {
		y1 = s1.ymx;

		for (s3 = s2; !s3.dur; s3 = s3.prev)
			;
		ym = y_get(upstaff, 1, s3.x - 4, 8)
		if (ym > y2)
			y2 = ym
	}

	// end the bracket according to the last note duration
	if (s2.dur > s2.prev.dur) {
		if (s2.next)
			x2 = s2.next.x - s2.next.wl - 5
		else
			x2 = realwidth - 6
	} else {
		x2 = s2.x + 4;

			y_set(upstaff, false, s3.x, s3.next.x - s3.x, yy)
		}
		if (s3 == s2)
			break
	}
    } /* lower voice */

	if (tp.f[2] == 1) {			/* if 'which' == none */
		out_tubr(x1, y1 + 4, x2 - x1, y2 - y1, dir == C.SL_ABOVE);
		return
	}
	out_tubrn(x1, y1, x2 - x1, y2 - y1, dir == C.SL_ABOVE,
		tp.f[2] == 0 ? tp.p.toString() : tp.p + ':' +  tp.q);


	if (dir == C.SL_ABOVE)
		y_set(upstaff, true, xm - 3, 6, yy + 2)
	else
		y_set(upstaff, false, xm - 3, 6, yy)
}

/* -- draw the ties between two notes/chords -- */
function draw_note_ties(not1, job) {
    var	m, x1, x2, s, y, h, time,
	not2 = not1.tie_n,
	p = job == 2 ? not1.pit : not2.pit,
	dir = (not1.tie_ty & 0x07) == C.SL_ABOVE ? 1 : -1,
	s1 = not1.s,
	st = s1.st,
	s2 = not2.s,
	x2 = s2.x,

	sh = not1.shhd			// head shift

	for (m = 0; m < s1.nhd; m++)
		if (s1.notes[m] == not1)
			break
	if (dir > 0) {
		if (m < s1.nhd && p + 1 == s1.notes[m + 1].pit)
			if (s1.notes[m + 1].shhd > sh)
				sh = s1.notes[m + 1].shhd
	} else {
		if (m > 0 && p == s1.notes[m - 1].pit + 1)
			if (s1.notes[m - 1].shhd > sh)
				sh = s1.notes[m - 1].shhd
	}
	x1 = s1.x + sh * .6


	if (job != 2) {
		for (m = 0; m < s2.nhd; m++)
			if (s2.notes[m] == not2)
				break
		sh = s2.notes[m].shhd
		if (dir > 0) {
			if (m < s2.nhd && p + 1 == s2.notes[m + 1].pit)
				if (s2.notes[m + 1].shhd < sh)
					sh = s2.notes[m + 1].shhd
		} else {
			if (m > 0 && p == s2.notes[m - 1].pit + 1)
				if (s2.notes[m - 1].shhd < sh)
					sh = s2.notes[m - 1].shhd
		}
		x2 += sh * .6
	}


	switch (job) {
	case 0:

		p = (not1.pit & 1) ? not1.pit : not2.pit
		break
	case 3:				/* clef or staff change */
		dir = -dir
		// fall thru
	case 1:				/* no starting note */
		x1 = s1.x
		if (x1 > x2 - 20)
			x1 = x2 - 20
		p = not2.pit
		st = s2.st
		break
/*	case 2:				 * no ending note */
	default:
		if (s1 != s2) {
			x2 -= s2.wl
			if (s2.type == C.BAR)
				x2 += 5
		} else {
			time = s1.time + s1.dur
			for (s = s1.ts_next; s; s = s.ts_next)
//(fixme: must check if the staff continues??)
				if (s.time > time)
					break
			x2 = s ? s.x : realwidth
		}
		if (x2 < x1 + 16)
			x2 = x1 + 16
		break
	}
	if (x2 - x1 > 20) {
		x1 += 3.5
		x2 -= 3.5
	} else {
		x1 += 1.5
		x2 -= 1.5
	}

	if (s1.dots && !(not1.pit & 1)
	 && ((dir > 0 && !s1.dot_low)
	  || (dir < 0 && s1.dot_low)))
		x1 += 5

	y = staff_tb[st].y + 3 * (p - 18)

	h = (.03 * (x2 - x1) + 16) * dir
//	anno_start(k1, 'slur')
	slur_out(x1, y, x2, y, dir, h, not1.tie_ty & C.SL_DOTTED)


//	anno_stop(k1, 'slur')

}

/* -- draw ties between neighboring notes/chords -- */
function draw_ties(k1, k2,
			job) {	// 0: normal
				// 1: no starting note
				// 2: no ending note
				// 3: no start for clef or staff change
    var	k3, i, j, not1, not3, time, pit, pit2,


	mhead3 = [],
	nh1 = k1.nhd


	/* half ties from last note in line or before new repeat */
	if (job == 2) {
		for (i = 0; i <= nh1; i++) {
			not1 = k1.notes[i]
			if (not1.tie_ty) {
				k3 = not1.tie_n
				not1.tie_n = { s: k2 || k1 }
				draw_note_ties(not1, job)
				not1.tie_n = k3
			}

		}
		return
	}

	// draw the ties or memorize the ones without ending
	for (i = 0; i <= nh1; i++) {
		not1 = k1.notes[i]

		if (!not1.tie_ty)









			continue
		if (!not1.s)
			not1.s = k1




		if (not1.tie_n)

			draw_note_ties(not1, job)
		else
			mhead3.push(not1)	/* no match */
	}





	/* if any bad tie, try an other voice of the same staff */
	if (!mhead3.length)
		return				/* no bad tie */

	time = k1.time + k1.dur
	k3 = k1.ts_next
	if (job != 1)
		job = 0
	while (k3 && k3.time < time)
		k3 = k3.ts_next
	while (k3 && k3.time == time) {
		if (k3.type != C.NOTE
		 || k3.st != k1.st) {
			k3 = k3.ts_next
			continue
		}


		for (i = mhead3.length; --i >= 0; ) {
			not1 = mhead3[i]
			pit = not1.opit || not1.pit
			for (j = k3.nhd; j >= 0; j--) {
				not3 = k3.notes[j]
				pit2 = not3.opit || not3.pit
				if (pit2 == pit) {
					not1.tie_n = not3
					if (!not3.s)
						not3.s = k3
					draw_note_ties(not1, job)
					mhead3.splice(i, 1)
					break
				}
			}
		}




		if (!mhead3.length)
			break

		k3 = k3.ts_next
	}

	if (mhead3.length)
		error(1, k1, "Bad tie")
}





















/* -- draw all ties between neighboring notes -- */
function draw_all_ties(p_voice) {
    var s, s1, s2, clef_chg, time, x, dx, s_next, m

	function draw_ties_g(s1, s2, job) {


		if (s1.type == C.GRACE) {
			for (var g = s1.extra; g; g = g.next) {
				if (g.tie_s)
					draw_ties(g, s2, job)
			}
		} else {
			draw_ties(s1, s2, job)
		}
	} // draw_ties_g()



































	/* search the start of ties */
//	clef_chg = false
	s_next = p_voice.sym
	set_color(s_next.color)
	while (1) {
		for (s1 = s_next; s1; s1 = s1.next) {
			if (s1.ti2			// if no tie start
			 && (s1 != s_next
			  || !s_next.prev)) {		// (at start of line)
				s = s1.ti2
				s.x = s1.x
				s2 = s.next
				s.next = s1
				s.st = s1.st
				s.time = s1.time - s.dur
				draw_ties(s, s1, 1)
				s.next = s2	// restore the linkage for play
			}
			if (s1.tie_s)



				break










		}
		if (!s1)
			break

		// check if the tied note is in this line
		s2 = s1.tie_s				// ending note of the tie
		if (s2.v == s1.v) {
			s_next = s2
			s = s1
			while (1) {
				if (!s.next) {
					s2 = s
					s = null
					break

				}
				s = s.next
				if (s == s2)
					break

			}
		} else {

			s_next = s1.next
			s = s1
			while (1) {
				if (!s.ts_next) {


					s = null
					break
				}
				s = s.ts_next
				if (s == s2)
					break
			}
			if (!s) {
				s2 = s1
				while (s2.next)
					s2 = s2.next
			}
		}

		if (!s) {				// end of line
			draw_ties_g(s1, s2, 2);

			break
		}












		// check if some clef changes (may occur in an other voice)
		time = s1.time + s.dur


		for (s = s1.ts_next; s != s2; s = s.ts_next) {
			if (s.st != s1.st)
				continue
			if (s.time > time)
				break
			if (s.type == C.CLEF) {
				clef_chg = true
				break
			}
		}

		/* ties with clef or staff change */
		if (clef_chg || s1.st != s2.st) {
			clef_chg = false;
			dx = (s2.x - s1.x) * .4;

				s1.x = s2.x - 24.;
			draw_ties(s1, s2, 3);
			s1.x = x
			continue
		}
		draw_ties_g(s1, s2, s2.type == C.NOTE ? 0 : 2)
	}




































































}

/* -- draw the symbols near the notes -- */
/* (the staves are not yet defined) */
/* order:
 * - scaled
 *   - beams
 *   - decorations near the notes
 *   - measure bar numbers

 *   - decorations tied to the notes
 *   - tuplets and slurs
 * - not scaled
 *   - chord symbols
 *   - staff decorations
 *   - lyrics
 *   - measure numbers
 * The buffer output is delayed until the definition of the staff system
 */
function draw_sym_near() {
    var	p_voice, p_st, s, v, st, y, g, w, i, st, dx, top, bot,

	output_sav = output;

	output = ""

	/* calculate the beams but don't draw them (the staves are not yet defined) */
	for (v = 0; v < voice_tb.length; v++) {
		var	bm = {},
			first_note = true;

			else
				y -= 5
			if (s.ymn > y)
				s.ymn = y;
			y_set(s.st, false, s.x, 0, y)
		}
	}

	draw_deco_note()

	for (v = 0; v < voice_tb.length; v++) {
		p_voice = voice_tb[v];
		s = p_voice.sym
		if (!s)
			continue
		set_color(s.color);
		st = p_voice.st;
//  if (st == undefined) {
//error(1, s, "BUG: no staff for voice " + p_voice.id)
//    continue
//  }

		// draw the slurs and tuplets
		for ( ; s; s = s.next) {
			if (s.tp)
				draw_tuplet(s)





			if (s.sls || s.sl1)
				draw_slurs(s)
		}
	}
	set_color()

	/* set the top and bottom out of the staves */
	for (st = 0; st <= nstaff; st++) {
		p_st = staff_tb[st];
		top = p_st.topbar + 2;
		bot = p_st.botbar - 2
/*fixme:should handle stafflines changes*/
		for (i = 0; i < YSTEP; i++) {
			if (top > p_st.top[i])
				p_st.top[i] = top
			if (bot < p_st.bot[i])
				p_st.bot[i] = bot
		}
	}



	if (cfmt.measurenb >= 0)
		draw_measnb();
	draw_deco_staff();

	/* if any lyric, draw them now as unscaled */
	set_dscale(-1)
//	set_sscale(-1)

	set_dscale(-1);
	output = output_sav
}

/* -- draw the name/subname of the voices -- */
function draw_vname(indent) {
    var	p_voice, n, st, v, a_p, p, y, name_type, h, h2,
	staff_d = []

	for (st = cur_sy.nstaff; st >= 0; st--) {
		if (cur_sy.st_print[st])
			break
	}
	if (st < 0)
		return

	// check if full or sub names
	for (v = 0; v < voice_tb.length; v++) {
		p_voice = voice_tb[v]
		if (!p_voice.sym || !cur_sy.voices[v])
			continue
		st = cur_sy.voices[v].st
		if (!cur_sy.st_print[st])
			continue
		if (p_voice.new_name) {
			name_type = 2
			break
		}
		if (p_voice.snm)
			name_type = 1
	}
	if (!name_type)
		return
	for (v = 0; v < voice_tb.length; v++) {
		p_voice = voice_tb[v]
		if (!p_voice.sym || !cur_sy.voices[v])
			continue
		st = cur_sy.voices[v].st
		if (!cur_sy.st_print[st])
			continue
		if (p_voice.new_name)
			delete p_voice.new_name;
		p = name_type == 2 ? p_voice.nm : p_voice.snm
		if (!p)
			continue







		if (!staff_d[st])
			staff_d[st] = p
		else
			staff_d[st] += "\\n" + p
	}
	if (staff_d.length == 0)
		return
	set_font("voice");
	h = gene.curfont.size
	h2 = h / 2
	indent = -indent * .5			/* center */
	for (st = 0; st < staff_d.length; st++) {
		if (!staff_d[st])
			continue
		a_p = staff_d[st].split('\\n');
		y = staff_tb[st].y
			+ staff_tb[st].topbar * .5
				* staff_tb[st].staffscale
			+ h2 * (a_p.length - 2)

		// if instrument with 2 staves, center the voice name
		if ((cur_sy.staves[st].flags & OPEN_BRACE)



		 && (cur_sy.staves[st + 1].flags & CLOSE_BRACE)


		 && !staff_d[st + 1])
			y -= (staff_tb[st].y - staff_tb[st + 1].y) * .5
		for (n = 0; n < a_p.length; n++) {
			p = a_p[n];
			xy_str(indent, y, p, "c");
			y -= h
		}
	}
}

// -- set the y offset of the staves and return the height of the whole system --
function set_staff() {
	var	s, i, st, prev_staff, v,

/* -- draw the staff systems and the measure bars -- */
function draw_systems(indent) {
	var	s, s2, st, x, x2, res, sy,
		staves_bar, bar_force,
		xstaff = [],
		bar_bot = [],
		bar_height = [],
		ba = [],		// bars [symbol, bottom, height]
		sb = [],
		thb = []



	/* -- set the bottom and height of the measure bars -- */
	function bar_set() {
		var	st, staffscale, top, bot,
			dy = 0

		for (st = 0; st <= cur_sy.nstaff; st++) {

		if (!/[\[|]/.test(stafflines))
			return				// no line
		w = x2 - x1;
		set_sscale(st);
		ws = w / stv_g.scale

		// check if default staff
		if (cache && cache.st_l == stafflines
		 && cache.st_ws == (ws | 0)) {
			xygl(x1, staff_tb[st].y, 'stdef' + cfmt.fullsvg)
			return
		}
		for (i = 0; i < l; i++, y -= 6) {
			if (stafflines[i] == '.')
				continue
			dy = 0

						'h' + ws.toFixed(1);
					dy = 0
					continue
				}
				if (ty != undefined)
					ln += '"/>\n';
				ty = stafflines[i]
				ln += '<path class="' +
					(ty == '[' ? 'slthW' : 'slW') +
					'" d="m0 ' + y + 'h' + ws.toFixed(1);
				dy = 0
			}
			ln += '"/>'
		}
		y = staff_tb[st].y
		if (!cache
		 && w > get_lwidth() - 10) {
			cache = {
				st_l: stafflines,
				st_ws: ws | 0
			}
			i = 'stdef' + cfmt.fullsvg;
			if (ln.indexOf('<path', 1) < 0)
				glyphs[i] = ln.replace('path', 'path id="' + i + '"')
			else
				glyphs[i] = '<g id="' + i + '">\n' + ln + '\n</g>';
			xygl(x1, y, i)
			return
		}
		out_XYAB('<g transform="translate(X, Y)">\n' + ln + '\n</g>\n', x1, y)
	} // draw_staff()

	// draw a measure bar
	function draw_bar(s, bot, h) {
	    var	i, s2, yb, w,
		bar_type = s.bar_type,
		st = s.st,
		p_staff = staff_tb[st],
		x = s.x

		// don't put a line between the staves if there is no bar above
		if (st != 0
		 && s.ts_prev
//fixme: 's.ts_prev.st != st - 1' when floating voice in lower staff
//	 && (s.ts_prev.type != C.BAR || s.ts_prev.st != st - 1))
		 && s.ts_prev.type != C.BAR)
			h = p_staff.topbar * p_staff.staffscale;

		s.ymx = s.ymn + h;

		anno_start(s)
		if (s.color)
			set_color(s.color);

		// compute the middle vertical offset of the staff
		yb = p_staff.y + 12;
		if (p_staff.stafflines != '|||||')
			yb += (p_staff.topbar + p_staff.botbar) / 2 - 12 // bottom

		// if measure repeat, draw the '%' like glyphs
		if (s.bar_mrep) {
			set_sscale(st)
			if (s.bar_mrep == 1) {
				for (s2 = s.prev; s2.type != C.REST; s2 = s2.prev)
					;
				xygl(s2.x, yb, "mrep")
			} else {
				xygl(x, yb, "mrep2")
				if (s.v == cur_sy.top_voice)
					xy_str(x, yb + p_staff.topbar - 9,
						s.bar_mrep.toString(), "c")
			}
		}

		if (bar_type == '||:')
			bar_type = '[|:'

		for (i = bar_type.length; --i >= 0; ) {
			switch (bar_type[i]) {
			case "|":
				if (s.bar_dotted) {
					set_sscale(-1);
					w = (5 * p_staff.staffscale).toFixed(1);
					out_XYAB(
			'<path class="bW" stroke-dasharray="A,A" d="MX Yv-G"/>\n',
						x, bot, w, h)
				} else if (s.color) {
					out_XYAB('<path class="bW" d="MX Yv-F"/>\n',
						x, bot, h)
				} else {
					sb.push(new Float32Array([x, bot, h]))
				}
				break
			default:
//			case "[":
//			case "]":
				x -= 3;
				if (s.color)
					out_XYAB('<path class="bthW" d="MX Yv-F"/>\n',
						x + 1.5, bot, h)
				else
					thb.push(new Float32Array([x + 1.5, bot, h]))
				break
			case ":":
				x -= 2;
				set_sscale(st);
				xygl(x + 1, yb - 12, "rdots")
				break
			}
			x -= 3
		}
		set_color();
		anno_stop(s)
	} // draw_bar()

	// output all the bars
	function out_bars() {
	    var	i, b, bx,
		l = ba.length

		set_font("annotation");
		if (gene.curfont.box) {
			gene.curfont.box = false
			bx = true
		}
		for (i = 0; i < l; i++) {
			b = ba[i];		// symbol, bottom, height
			draw_bar(b[0], b[1], b[2])
		}
		if (bx)
			gene.curfont.box = true

		set_sscale(-1)
		l = sb.length
		if (l) {			// single bars [x, y, h]
			output += '<path class="bW" d="'
			for (i = 0; i < l; i++) {
				b = sb[i];
				out_XYAB('MX Yv-F', b[0], b[1], b[2])
			}
			output += '"/>\n'
		}












		l = thb.length
		if (l) {			// thick bars [x, y, h]
			output += '<path class="bthW" d="'
			for (i = 0; i < l; i++) {
				b = thb[i];
				out_XYAB('MX Yv-F', b[0], b[1], b[2])
			}
			output += '"/>\n'
		}

























	} // out_bars()

	// draw_systems()
	draw_vname(indent)

	/* draw the staff, skipping the staff breaks */
	for (st = 0; st <= nstaff; st++)

				draw_staff(st, x, x2)
				if (sy.st_print[st])
					xstaff[st] = x2
			}
			cur_sy = sy;
			bar_set()
			continue
		case C.BAR:		// display the bars after the staves
			if (s.second || s.invis || !s.bar_type)
				break

			ba.push([s, bar_bot[s.st], bar_height[s.st]])
			break
		case C.STBRK:
			if (cur_sy.voices[s.v]
			 && cur_sy.voices[s.v].range == 0) {
				if (s.xmx > 14) {

					/* draw the left system if stbrk in all voices */
					var nv = 0
					for (var i = 0; i < voice_tb.length; i++) {
						if (cur_sy.voices[i]
						  && cur_sy.voices[i].range > 0)
							nv++
					}
					for (s2 = s.ts_next; s2; s2 = s2.ts_next) {
						if (s2.type != C.STBRK)
							break
						nv--
					}

		if (x < 0 || x >= realwidth)
			continue
		draw_staff(st, x, realwidth)
	}

	// and the bars
	out_bars()
//	set_sscale(-1)
}

/* -- draw remaining symbols when the staves are defined -- */
// (possible hook)
Abc.prototype.draw_symbols = function(p_voice) {
	var	bm = {},
		s, g, x, y, st;

//	bm.s2 = undefined
	for (s = p_voice.sym; s; s = s.next) {
		if (s.invis) {
			switch (s.type) {

			if (s.second
			 || s.invis
			 || !staff_tb[s.st].topbar)
				break
			set_color();
			set_sscale(s.st);
			anno_start(s);
			self.draw_keysig(x, s);
			anno_stop(s)
			break
		case C.MREST:
			set_scale(s);
			x += 32;
			anno_start(s);
			xygl(x, staff_tb[s.st].y + 12, "mrest");

	}

	draw_all_deco();
	set_sscale(-1)				/* restore the scale */
}

/* -- set the tie directions for one voice -- */
function set_tie_dir(s) {
    var i, ntie, dir, sec, pit, ty

	for ( ; s; s = s.next) {
		if (!s.tie_s)
			continue

		/* if other voice, set the ties in opposite direction */
		if (s.multi != 0) {
			dir = s.multi > 0 ? C.SL_ABOVE : C.SL_BELOW
			for (i = 0; i <= s.nhd; i++) {
				ty = s.notes[i].tie_ty
				if (!((ty & 0x07) == C.SL_AUTO))
					continue
				s.notes[i].tie_ty = (ty & C.SL_DOTTED) | dir
			}
			continue
		}

		/* if one note, set the direction according to the stem */
		sec = ntie = 0;
		pit = 128
		for (i = 0; i <= s.nhd; i++) {
			if (s.notes[i].tie_ty) {
				ntie++
				if (pit < 128
				 && s.notes[i].pit <= pit + 1)
					sec++;
				pit = s.notes[i].pit
			}
		}
		if (ntie <= 1) {
			dir = s.stem < 0 ? C.SL_ABOVE : C.SL_BELOW
			for (i = 0; i <= s.nhd; i++) {
				ty = s.notes[i].tie_ty
				if (ty) {
					if ((ty & 0x07) == C.SL_AUTO)
						s.notes[i].tie_ty =
							(ty & C.SL_DOTTED) | dir
					break
				}
			}
			continue
		}
		if (sec == 0) {
			if (ntie & 1) {
/* in chords with an odd number of notes, the outer noteheads are paired off
 * center notes are tied according to their position in relation to the
 * center line */
				ntie = (ntie - 1) / 2;
				dir = C.SL_BELOW
				for (i = 0; i <= s.nhd; i++) {
					ty = s.notes[i].tie_ty
					if (!ty)
						continue
					if (ntie == 0) {	/* central tie */
						if (s.notes[i].pit >= 22)
							dir = C.SL_ABOVE
					}
					if ((ty & 0x07) == C.SL_AUTO)
						s.notes[i].tie_ty =
							(ty & C.SL_DOTTED) | dir
					if (ntie-- == 0)
						dir = C.SL_ABOVE
				}
				continue
			}
/* even number of notes, ties divided in opposite directions */
			ntie /= 2;
			dir = C.SL_BELOW
			for (i = 0; i <= s.nhd; i++) {
				ty = s.notes[i].tie_ty
				if (!ty)
					continue
				if ((ty & 0x07) == C.SL_AUTO)
					s.notes[i].tie_ty =
						(ty & C.SL_DOTTED) | dir
				if (--ntie == 0)
					dir = C.SL_ABOVE
			}
			continue
		}
/*fixme: treat more than one second */
/*		if (nsec == 1) {	*/
/* When a chord contains the interval of a second, tie those two notes in
 * opposition; then fill in the remaining notes of the chord accordingly */
			pit = 128
			for (i = 0; i <= s.nhd; i++) {
				if (s.notes[i].tie_ty) {
					if (pit < 128
					 && s.notes[i].pit <= pit + 1) {
						ntie = i
						break
					}
					pit = s.notes[i].pit
				}
			}
			dir = C.SL_BELOW
			for (i = 0; i <= s.nhd; i++) {
				ty = s.notes[i].tie_ty
				if (!ty)
					continue
				if (ntie == i)
					dir = C.SL_ABOVE
				if ((ty & 0x07) == C.SL_AUTO)
					s.notes[i].tie_ty =
						(ty & C.SL_DOTTED) | dir
			}
/*fixme..
			continue
		}
..*/
/* if a chord contains more than one pair of seconds, the pair farthest
 * from the center line receives the ties drawn in opposition */

		if (!s)
			continue
		s = s.next
		if (!s)
			continue
		set_tie_dir(s)
		for ( ; s; s = s.next) {
			if (!s.tie_s)
				continue
			if (s.notes[0].pit < 20
			 && s.notes[0].tie_ty
			 && (s.notes[0].tie_ty & 0x07) == C.SL_BELOW)
				;
			else if (s.notes[s.nhd].pit > 24
			      && s.notes[s.nhd].tie_ty
			      && (s.notes[s.nhd].tie_ty & 0x07) == C.SL_ABOVE)
				;
			else
				continue
			s2 = s.next
			while (s2 && s2.type != C.NOTE)
				s2 = s2.next
			if (s2) {

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with abc2svg-core.  If not, see <http://www.gnu.org/licenses/>.

var	font_tb = [],
	font_st = {},	// font style => font_tb index for incomplete user fonts
	font_scale_tb = {
		serif: 1,
		serifBold: 1,
		'sans-serif': 1,
		'sans-serifBold': 1,
		Palatino: 1.1,
		monospace: 1.35
	},
	fmt_lock = {}

var cfmt = {
	annotationfont: {name: "sans-serif", size: 12 },
	aligncomposer: 1,
	beamslope: .4,			// max slope of a beam
//	botmargin: .7 * IN,		// != 1.8 * CM,
	breaklimit: .7,
	breakoneoln: true,
	cancelkey: true,
	composerfont: { name: "serif", style: "italic", size: 14 },
	composerspace: 6,
//	contbarnb: false,
	dblrepbar: ':][:',
	decoerr: true,
	dynalign: true,
	footerfont: { name: "serif", size: 16 },
	fullsvg: '',
	gchordfont: { name: "sans-serif", size: 12 },
	gracespace: new Float32Array([4, 8, 11]), // left, inside, right
	graceslurs: true,
	headerfont: { name: "serif", size: 16 },
	historyfont: { name: "serif", size: 16 },
	hyphencont: true,
	indent: 0,
	infofont: {name: "serif", style: "italic", size: 14 },
	infoname: 'R "Rhythm: "\n\
B "Book: "\n\
S "Source: "\n\
D "Discography: "\n\
N "Notes: "\n\
Z "Transcription: "\n\
H "History: "',
	infospace: 0,
	keywarn: true,
	leftmargin: 1.4 * CM,
	lineskipfac: 1.1,
	linewarn: true,
	maxshrink: .65,		// nice scores
	maxstaffsep: 2000,
	maxsysstaffsep: 2000,

	measurefont: {name: "serif", style: "italic", size: 10},
	measurenb: -1,
	musicspace: 6,
//	notespacingfactor: 1.33
	partsfont: {name: "serif", size: 15},
	parskipfac: .4,
	partsspace: 8,
//	pageheight: 29.7 * CM,
	pagewidth: 21 * CM,









	printmargin: 0,
	rightmargin: 1.4 * CM,
	rbdbstop: true,
	rbmax: 4,
	rbmin: 2,
	repeatfont: {name: "serif", size: 13},
	scale: 1,
	slurheight: 1.0,
	staffsep: 46,
	stemheight: 21,			// one octave
	stretchlast: .25,
	stretchstaff: true,
	subtitlefont: {name: "serif", size: 16},
	subtitlespace: 3,
	sysstaffsep: 34,
	tempofont: {name: "serif", weight: "bold", size: 12},
	textfont: {name: "serif", size: 16},
//	textoption: undefined,
	textspace: 14,
	titlefont: {name: "serif", size: 20},
//	titleleft: false,
	titlespace: 6,
	titletrim: true,
//	transp: 0,			// global transpose
//	topmargin: .7 * IN,
	topspace: 22,
	tuplets: [0, 0, 0, 0],
	vocalfont: {name: "serif", weight: "bold", size: 13},
	vocalspace: 10,
	voicefont: {name: "serif", weight: "bold", size: 13},
//	voicescale: 1,
	writefields: "CMOPQsTWw",
	wordsfont: {name: "serif", size: 16},
	wordsspace: 5
}

function get_bool(param) {

	if (!scale)
		scale = 1.1;
	font.swfac = font.size * scale
}

// %%xxxfont fontname|* [encoding] [size|*]
function param_set_font(xxxfont, p) {
    var	font, n, a

	// "setfont-<n>" goes to "u<n>font"
	if (xxxfont[xxxfont.length - 2] == '-') {
		n = xxxfont[xxxfont.length - 1]
		if (n < '1' || n > '9')
			return
		xxxfont = "u" + n + "font"
	}

	// create a new font
	font = cfmt[xxxfont];
	if (!font) {			// set-font-<n> or new element
		font = {}
	} else {
		font = {
			name: font.name,
			size: font.size,
			box: font.box
		}
	}


	cfmt[xxxfont] = font;

	// fill the values
	a = p.match(/\s+(no)?box(\s|$)/)
	if (a) {				// if box
		if (a[1])
			font.box = false	// nobox
		else
			font.box = true;
		p = p.replace(a[0], a[2])
	}

	a = p.match(/\s+class=(.*?)(\s|$)/)
	if (a) {
		font.class = a[1];
		p = p.replace(a[0], a[2])
	}
	a = p.match(/\s+wadj=(.*?)(\s|$)/)
	if (a) {
	    if (typeof document == "undefined")	// useless if in browser
		switch (a[1]) {
		case 'none':
			font.wadj = ''
			break
		case 'space':
			font.wadj = 'spacing'
			break
		case 'glyph':
			font.wadj = 'spacingAndGlyphs'
			break
		default:
			syntax(1, errs.bad_val, "%%" + xxxfont)
			break
		}
		p = p.replace(a[0], a[2])
	}

	// the font size is the last item
	a = p.match(/\s+([0-9.]+|\*)$/)
	if (a) {
		if (a[1] != "*") {
			font.size = Number(a[1])
			font.swfac = 0
		}
		p = p.replace(a[0], "")
	}

	a = p.match(/[- ]?[nN]ormal/)
	if (a) {
		font.normal = true
		p = p.replace(a[0], '')
	}

	a = p.match(/[- ]?[bB]old/)
	if (a) {
		font.weight = "bold"
		p = p.replace(a[0], '')
	}
	a = p.match(/[- ]?[iI]talic/)
	if (a) {
		font.style = "italic"
		p = p.replace(a[0], '')
	}
	a = p.match(/[- ]?[oO]blique/)
	if (a) {
		font.style = "oblique"
		p = p.replace(a[0], '')
	}
	switch (p) {
	case "":
	case "*": return
	case "Times-Roman":
	case "Times":	p = "serif"; break
	case "Helvetica": p = "sans-serif"; break
	case "Courier": p = "monospace"; break


	}








	font.swfac = 0



	font.name = p
}

// get a length with a unit - return the number of pixels
function get_unit(param) {
	var v = parseFloat(param)

	switch (param.slice(-2)) {

}

/* -- set the position of elements in a voice -- */
function set_pos(k, v) {		// keyword, value
	k = k.slice(0, 3)
	if (k == "ste")
		k = "stm"
	set_v_param("pos", k + ' ' + v)
}

// set/unset the fields to write
function set_writefields(parm) {
	var	c, i,
		a = parm.split(/\s+/)

			if (cfmt.writefields.indexOf(c) >= 0)
				cfmt.writefields = cfmt.writefields.replace(c, '')
		}
	}
}

// set a voice specific parameter

function set_v_param(k, v) {
	if (curvoice) {
		self.set_vp([k + '=', v])
		return
	}
	k = [k + '=', v];
	var vid = '*'

		img.width = img.lm + img.rm + 150
	}
	set_posx()
} // set_page()

// set a format parameter
// (possible hook)
Abc.prototype.set_format = function(cmd, param) {
	var f, f2, v, i

//fixme: should check the type and limits of the parameter values





	if (/.+font(-[\d])?$/.test(cmd)) {
		param_set_font(cmd, param)
		return
	}

	switch (cmd) {
	case "aligncomposer":
	case "barsperstaff":
	case "infoline":

	case "measurenb":
	case "rbmax":
	case "rbmin":
	case "shiftunison":
		v = parseInt(param)
		if (isNaN(v)) {
			syntax(1, "Bad integer value");
			break
		}
		cfmt[cmd] = v
		break
	case "microscale":
		f = parseInt(param)
		if (isNaN(f) || f < 4 || f > 256 || f % 1) {
			syntax(1, errs.bad_val, "%%" + cmd)
			break
		}
		set_v_param("uscale", f)
		break
	case "bgcolor":
	case "fgcolor":
	case "dblrepbar":
	case "titleformat":
		cfmt[cmd] = param
		break
	case "beamslope":
	case "breaklimit":			// float values
	case "lineskipfac":
	case "maxshrink":
	case "pagescale":
	case "parskipfac":
	case "scale":
	case "slurheight":

	case "dynalign":
	case "flatbeams":
	case "graceslurs":
	case "graceword":
	case "hyphencont":
	case "keywarn":
	case "linewarn":
	case "quiet":
	case "rbdbstop":
	case "singleline":
	case "squarebreve":
	case "splittune":
	case "straightflags":
	case "stretchstaff":
	case "timewarn":

		set_pos(cmd, param)
		break
	case "font":
		get_font_scale(param)
		break
	case "fullsvg":
		if (parse.state != 0) {
			syntax(1, errs.not_in_tune, "%%fullsvg")
			break
		}
//fixme: should check only alpha, num and '_' characters
		cfmt[cmd] = param
		break
	case "gracespace":
		v = param.split(/\s+/)

		else
			cfmt[cmd] = v
		break
	case "combinevoices":
		syntax(1, "%%combinevoices is deprecated - use %%voicecombine instead")
		break
	case "voicemap":
		set_v_param("map", param)
		break
	case "voicescale":
		set_v_param("scale", param)
		break
	default:		// memorize all global commands
		if (parse.state == 0)		// (needed for modules)
			cfmt[cmd] = param
		break
	}
}

// font stuff

// build a font style
function st_font(font) {
    var	n = font.name,
	r = ""


	if (font.weight)
		r += font.weight + " "



	if (font.style)
		r += font.style + " "



	if (n.indexOf(' ') > 0)

		n = '"' + n.replace(/"/g, "") + '"'	// '
	return r + font.size.toFixed(1) + 'px ' + n
}
function style_font(font) {
	return 'font:' + st_font(font)
}
Abc.prototype.style_font = style_font

// build a font class
function font_class(font) {
	if (font.class)
		return 'f' + font.fid + cfmt.fullsvg + ' ' + font.class

		}
		font_style += "\n.f" + font.fid + cfmt.fullsvg +
			" {" + style_font(font) + "}"
	}
}

// get the font of the 'xxxfont' parameter
function get_font(fn) {
    var	font, font2, fid, st

	fn += "font"
	font = cfmt[fn]
	if (!font) {
		syntax(1, "Unknown font $1", '$' + fn[1]);
		return gene.curfont
	}

	if (!font.name || !font.size) {		// if incomplete user font
		font2 = Object.create(gene.curfont)
		if (font.name)
			font2.name = font.name
		if (font.normal) {
			if (font2.weight)	// !! don't use delete !!
				font2.weight = null
			if (font2.style)
				font2.style = null
		} else {
			if (font.weight)
				font2.weight = font.weight
			if (font.style)
				font2.style = font.style
		}
		if (font.class)
			font2.class = font.class
		if (font.size)
			font2.size = font.size
		st = st_font(font2)
		fid = font_st[st]
		if (fid != undefined)
			return font_tb[fid]
		font_st[st] = font_tb.length
		font2.fid = font2.used = undefined
		font = font2
	}
	use_font(font)
	return font
}

// abc2svg-core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with abc2svg-core.  If not, see <http://www.gnu.org/licenses/>.

    var	sav = {},	// save global (between tunes) definitions
	mac = {},	// macros (m:)
	maci = {}	// first letters of macros

// translation table from the ABC draft version 2.2
var abc_utf = {
	"=D": "Đ",
	"=H": "Ħ",
	"=T": "Ŧ",
	"=d": "đ",

	"5": "𝄫"
}

// convert the escape sequences to utf-8
function cnv_escape(src) {
	var	c, c2,
		dst = "",
		i, j = 0

	while (1) {
		i = src.indexOf('\\', j)
		if (i < 0)
			break
		dst += src.slice(j, i);
		c = src[++i]

				j = i + 3
				continue
			}
			break
		case 'u':
			j = Number("0x" + src.slice(i + 1, i + 5));
			if (isNaN(j) || j < 0x20) {
				dst += src[++i] + "\u0306"	// breve accent
				j = i + 1
				continue
			}



			dst += String.fromCharCode(j);




			j = i + 5


			continue
		case 't':			// TAB
			dst += ' ';
			j = i + 1
			continue
		default:
			c2 = abc_utf[src.slice(i, i + 2)]
			if (c2) {
				dst += c2;
				j = i + 2
				continue
			}

			// try unicode combine characters
			c2 = src[i + 1]
			if (!/[A-Za-z]/.test(c2))
				break
			switch (c) {
			case '`':
				dst += c2 + "\u0300"	// grave
				j = i + 2
				continue
			case "'":
				dst += c2 + "\u0301"	// acute
				j = i + 2
				continue
			case '^':
				dst += c2 + "\u0302"	// circumflex
				j = i + 2
				continue
			case '~':
				dst += c2 + "\u0303"	// tilde
				j = i + 2
				continue
			case '=':
				dst += c2 + "\u0304"	// macron
				j = i + 2
				continue
			case '_':
				dst += c2 + "\u0305"	// overline
				j = i + 2
				continue
			case '.':
				dst += c2 + "\u0307"	// dot
				j = i + 2
				continue
			case '"':
				dst += c2 + "\u0308"	// dieresis
				j = i + 2
				continue
			case 'o':
				dst += c2 + "\u030a"	// ring
				j = i + 2
				continue
			case 'H':
				dst += c2 + "\u030b"	// hungarumlaut
				j = i + 2
				continue
			case 'v':
				dst += c2 + "\u030c"	// caron
				j = i + 2
				continue
//			case ',':
//				dst += c2 + "\u0326"	// comma below
//				j = i + 2
//				continue
			case 'c':
				dst += c2 + "\u0327"	// cedilla
				j = i + 2
				continue
			case ';':
				dst += c2 + "\u0328"	// ogonek
				j = i + 2
				continue
			}
			break
		}
		dst += '\\' + c;
		j = i + 1
	}

	return dst + src.slice(j)











}

// ABC include
var include = 0

function do_include(fn) {
	var file, parse_sav

	if (!user.read_file) {
		syntax(1, "No read_file support")
		return
	}
	if (include > 2) {
		syntax(1, "Too many include levels")
		return
	}

	file = user.read_file(fn)
	if (!file) {
		syntax(1, "Cannot read file '$1'", fn)
		return
	}
	include++;
	parse_sav = clone(parse);
	tosvg(fn, file);
	parse_sav.state = parse.state;
	parse = parse_sav;
	include--
}

// parse ABC code
function tosvg(in_fname,		// file name
		file,			// file content
		bol, eof) {		// beginning/end of file
	var	i, c, eol, end,
		select,
		line0, line1,
		last_info, opt, text, a, b, s,


		pscom,
		txt_add = '\n'		// for "+:"

	// check if a tune is selected
	function tune_selected() {
		var	re, res,
			i = file.indexOf('K:', bol)

		else
			eol = eof
		return false
	} // tune_selected()

	// remove the comment at end of text
	function uncomment(src, do_escape) {

		if (!src)
			return src
		if (src.indexOf('%') >= 0)
			src = src.replace(/([^\\])%.*/, '$1')
				 .replace(/\\%/g, '%');
		src = src.replace(/\s+$/, '')
		if (do_escape && src.indexOf('\\') >= 0)
			return cnv_escape(src)
		return src
	} // uncomment()

	function end_tune() {
		generate()
		if (info.W)
			put_words(info.W);
		put_history();
		blk_flush();
		parse.state = 0;		// file header
		cfmt = sav.cfmt;
		info = sav.info;
		char_tb = sav.char_tb;
		glovar = sav.glovar;
		maps = sav.maps;
		mac = sav.mac;
		maci = sav.maci;
		parse.tune_v_opts = null;
		parse.scores = null;
		init_tune()
		img.chg = true;
		set_page();
	} // end_tune()

	// get %%voice
	function do_voice(select, in_tune) {
	    var	opt, bol
		if (select == "end")
			return		// end of previous %%voice

		// get the options
		if (in_tune) {
			if (!parse.tune_v_opts)
				parse.tune_v_opts = {};
			opt = parse.tune_v_opts
		} else {
			if (!parse.voice_opts)
				parse.voice_opts = {};
			opt = parse.voice_opts
		}
		opt[select] = []
		while (1) {
			bol = ++eol
			if (file[bol] != '%')
				break
			eol = file.indexOf('\n', eol);
			if (file[bol + 1] != line1)
				continue
			bol += 2
			if (eol < 0)
				text = file.slice(bol)
			else
				text = file.slice(bol, eol);
			a = text.match(/\S+/)
			switch (a[0]) {
			default:
				opt[select].push(uncomment(text, true))
				continue
			case "score":
			case "staves":
			case "tune":
			case "voice":
				bol -= 2
				break
			}
			break
		}
		eol = parse.eol = bol - 1
	} // do_voice()

	// apply the options to the current tune
	function tune_filter() {
	    var	o, opts, j, pc, h,
		i = file.indexOf('K:', bol)

		i = file.indexOf('\n', i);
		h = file.slice(parse.bol, i)	// tune header

		for (i in parse.tune_opts) {
			if (!parse.tune_opts.hasOwnProperty(i))
				continue
			if (!(new RegExp(i)).test(h))
				continue
			opts = parse.tune_opts[i]
			for (j = 0; j < opts.t_opts.length; j++) {
				pc = opts.t_opts[j]
				switch (pc.match(/\S+/)[0]) {
				case "score":
				case "staves":
					if (!parse.scores)
						parse.scores = [];
					parse.scores.push(pc)
					break
				default:
					self.do_pscom(pc)
					break
				}
			}
			opts = opts.v_opts
			if (!opts)
				continue
			for (j in opts) {
				if (!opts.hasOwnProperty(j))
					continue
				if (!parse.tune_v_opts)
					parse.tune_v_opts = {};
				if (!parse.tune_v_opts[j])
					parse.tune_v_opts[j] = opts[j]
				else
					parse.tune_v_opts[j] =
						parse.tune_v_opts[j].
								concat(opts[j])
			}
		}
	} // tune_filter()

	// export functions and/or set module hooks
	if (abc2svg.modules
	 && (abc2svg.modules.hooks.length || abc2svg.modules.g_hooks.length))
		set_hooks()

	// initialize
	parse.file = file;		// used for errors

			pscom = true
		}

		// pseudo-comments
		if (pscom) {
			pscom = false;
			bol += 2		// skip %%/I:









			text = file.slice(bol, eol)
			a = text.match(/([^\s]+)\s*(.*)/)
			if (!a || a[1][0] == '%')
				continue

			switch (a[1]) {
			case "abcm2ps":
			case "ss-pref":
				parse.prefix = a[2]	// may contain a '%'
				continue
			case "abc-include":
				do_include(uncomment(a[2]))
				continue
			}

			// beginxxx/endxxx
			if (a[1].slice(0, 5) == 'begin') {
				b = a[1].substr(5);
				end = '\n' + line0 + line1 + "end" + b;
				i = file.indexOf(end, eol)
				if (i < 0) {
					syntax(1, "No $1 after %%$2",
							end.slice(1), a[1]);
					parse.eol = eof
					continue
				}
				self.do_begin_end(b, uncomment(a[2]),
					file.slice(eol + 1, i).replace(
						new RegExp('^' + line0 + line1, 'gm'),
										''));
				parse.eol = file.indexOf('\n', i + 6)
				if (parse.eol < 0)
					parse.eol = eof
				continue
			}
			switch (a[1]) {
			case "select":
				if (parse.state != 0) {
					syntax(1, errs.not_in_tune, "%%select")
					continue
				}
				select = uncomment(text.slice(7))
				if (select[0] == '"')
					select = select.slice(1, -1);
				if (!select) {
					delete parse.select
					continue
				}
				select = select.replace(/\(/g, '\\(');
				select = select.replace(/\)/g, '\\)');
//				select = select.replace(/\|/g, '\\|');
				parse.select = new RegExp(select, 'm')
				continue
			case "tune":



				if (parse.state != 0) {
					syntax(1, errs.not_in_tune, "%%tune")
					continue
				}
				select = uncomment(a[2])

				// if void %%tune, free all tune options
				if (!select) {
					parse.tune_opts = {}



					continue
				}
				
				if (select == "end")
					continue	// end of previous %%tune



				if (!parse.tune_opts)
					parse.tune_opts = {};
				parse.tune_opts[select] = opt = {


						t_opts: []
//						v_opts: {}
					};

				while (1) {
					bol = ++eol
					if (file[bol] != '%')
						break
					eol = file.indexOf('\n', eol);
					if (file[bol + 1] != line1)
						continue
					bol += 2
					if (eol < 0)
						text = file.slice(bol)
					else
						text = file.slice(bol, eol);
					a = text.match(/([^\s]+)\s*(.*)/)
					switch (a[1]) {
					case "tune":
						break
					case "voice":
						do_voice(uncomment(a[2],
								true), true)
						continue
					default:
						opt.t_opts.push(
							uncomment(text, true))
						continue






					}
					break
				}
				if (parse.tune_v_opts) {
					opt.v_opts = parse.tune_v_opts;
					parse.tune_v_opts = null
				}
				parse.eol = bol - 1
				continue
			case "voice":
				if (parse.state != 0) {
					syntax(1, errs.not_in_tune, "%%voice")
					continue
				}
				select = uncomment(a[2])

				/* if void %%voice, free all voice options */
				if (!select) {
					parse.voice_opts = null
					continue
				}
				
				do_voice(select)
				continue
			}
			self.do_pscom(uncomment(text, true))
			continue
		}

		// music line (or free text)
		if (line1 != ':' || !/[A-Za-z+]/.test(line0)) {

				eol = file.indexOf('\nX:', parse.eol)
				if (eol < 0)
					eol = eof;
				parse.eol = eol
				continue
			}

			sav.cfmt = clone(cfmt);

			sav.info = clone(info, 2)	// (level 2 for info.V[])
			sav.char_tb = clone(char_tb);
			sav.glovar = clone(glovar);
			sav.maps = clone(maps, 1);
			sav.mac = clone(mac);
			sav.maci = clone(maci);
			info.X = text;
			parse.state = 1			// tune header
			if (parse.tune_opts)
				tune_filter()
			continue
		case 'T':
			switch (parse.state) {
			case 0:
				continue
			case 1:
			case 2:
				if (info.T == undefined)	// (keep empty T:)
					info.T = text
				else
					info.T += "\n" + text
				continue
			}
			s = new_block("title");

			break

		case 'm':
			if (parse.state >= 2) {
				syntax(1, errs.ignored, line0)
				continue
			}



			a = text.match(/(.*?)[= ]+(.*)/)
			if (!a || !a[2]) {
				syntax(1, errs.bad_val, "m:")
				continue
			}
			mac[a[1]] = a[2];
			maci[a[1][0]] = true	// first letter
			break

		// info fields in tune body only
		case 's':
			if (parse.state != 3
			 || cfmt.writefields.indexOf(line0) < 0)
				break

				last_info = line0
				continue
			}
			break
		case '|':			// "|:" starts a music line
			if (parse.state < 2)
				continue
			parse.line.buffer = text
			parse_music_line()
			continue
		default:
			if ("ABCDFGHNOSZ".indexOf(line0) >= 0) {
				if (parse.state >= 2) {
					syntax(1, errs.ignored, line0)
					continue

	}
}

// transpose a chord symbol
var	note_names = "CDEFGAB",
	acc_name = ["bb", "b", "", "#", "##"]

	function gch_tr1(p, transp) {
	    var	i, o, n, a, ip, b40,
		csa = p.split('/')

		for (i = 0; i < csa.length; i++) {	// main and optional bass
			p = csa[i];
			o = p.search(/[ABCDEFG]/);
			if (o < 0)



				continue		// strange chord symbol!
			ip = o + 1

			a = 0
			while (p[ip] == '#') {
				a++;
				ip++
			}
			while (p[ip] == 'b') {
				a--;
				ip++
			}





			n = note_names.indexOf(p[o]) + 16

			b40 = (abc2svg.pab40(n, a) + transp + 200) % 40



			b40 = abc2svg.b40k[b40]



			csa[i] = p.slice(0, o) +
					note_names[abc2svg.b40_p[b40]] +
					acc_name[abc2svg.b40_a[b40] + 2] +
					p.slice(ip)






		}










		return csa.join('/')
	} // gch_tr1

function gch_transp(s) {
    var	gch,
	i = s.a_gch.length


	while (--i >= 0) {
		gch = s.a_gch[i]
		if (gch.type == 'g')
			gch.text = gch_tr1(gch.text, curvoice.vtransp)
	}
}

// -- build the chord indications / annotations --
// (possible hook)
Abc.prototype.gch_build = function(s) {

	/* split the chord indications / annotations
	 * and initialize their vertical offsets */
	var	gch, wh, xspc, ix,
		pos = curvoice.pos.gch == C.SL_BELOW ? -1 : 1,
		y_above = 0,
		y_below = 0,

			if (cfmt.chordnames) {
				gch.otext = gch.text;	// save for %%diagram
				gch.text = gch.text.replace(/A|B|C|D|E|F|G/g,
					function(c){return cfmt.chordnames[c]})
				if (cfmt.chordnames.B == 'H')
					gch.text = gch.text.replace(/Hb/g, 'Bb')
			}
			gch.text = gch.text.replace(/##|#|=|bb|b|  /g,
				function(x) {
					switch (x) {
					case '##': return "𝄪"
					case '#': return "\u266f"
					case '=': return "\u266e"
					case 'b': return "\u266d"
					case '  ': return '  '
					}
					return "𝄫"
				});


		} else {



			if (gch.type == '@'
			 && !user.anno_start && !user.anno_stop) {
				gch.wh = [0, 0]
				continue		/* no width */
			}
		}

		/* set the offsets and widths */
		set_font(gch.font);
		wh = strwh(gch.text);
		gch.wh = wh
		if (gch.font.box)
			wh[1] += 4
		switch (gch.type) {
		case '@':
			break
		case '^':			/* above */
			xspc = wh[0] * GCHPRE
			if (xspc > 8)

	}
}

// -- draw the chord symbols and annotations
// (the staves are not yet defined)
// (unscaled delayed output)
// (possible hook)
Abc.prototype.draw_gchord = function(s, gchy_min, gchy_max) {
    var	gch, text, ix, x, y, y2, hbox, h, y_above, y_below,

	// adjust the vertical offset according to the chord symbols
	w = 0,
		yav = s.dur ?
			(((s.notes[s.nhd].pit + s.notes[0].pit) >> 1) - 18) * 3 :
			12		// fixed offset on measure bars

	for (ix = 0; ix < s.a_gch.length; ix++) {
		gch = s.a_gch[ix]
		if (gch.wh[0] > w)
			w = gch.wh[0]
	}
	y_above = y_get(s.st, 1, s.x - 3, w);
	y_below = y_get(s.st, 0, s.x - 3, w)
	if (y_above < gchy_max)
		y_above = gchy_max
	if (y_below > gchy_min)
		y_below = gchy_min;

	set_dscale(s.st);
	for (ix = 0; ix < s.a_gch.length; ix++) {
		gch = s.a_gch[ix];
		use_font(gch.font);
		set_font(gch.font);
		h = gch.font.size;
		hbox = gch.font.box ? 2 : 0;
		w = gch.wh[0];
		x = s.x + gch.x;
		text = gch.text
		switch (gch.type) {
		case '_':			/* below */
			y = gch.y + y_below;
			y_set(s.st, 0, x, w, y - hbox)

	return y / sc
}

// -- draw all the lyrics --
/* (the staves are not yet defined) */
function draw_all_lyrics() {
	var	p_voice, s, v, nly, i, x, y, w, a_ly, ly,
		lyst_tb = new Array(nstaff+ 1),
		nv = voice_tb.length,
		h_tb = new Array(nv),
		nly_tb = new Array(nv),
		above_tb = new Array(nv),
		rv_tb = new Array(nv),
		top = 0,
		bot = 0,

// abc2svg - mei.js - MEI front-end
//
// Copyright (C) 2019 Jean-Francois Moine
//
// This file is part of abc2svg-core.
//
// abc2svg-core is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// abc2svg-core is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with abc2svg-core.  If not, see <http://www.gnu.org/licenses/>.

// convert the xml source into a tree
function xml2tree(xml) {
    var	i, j, item, n, no, an,
	e = 0,
	stack = [],
	root = {
		name: "root"
	},
	o = root

	while (1) {
		i = xml.indexOf('<', e)		// start of tag
		if (i < 0)
			break
		if (i > e + 1) {		// if some content
			item = xml.slice(e + 1, i)
				.replace(/\s*/, '') // remove left spaces
			if (item) {
				if (!o.children)
					o.children = []
				o.children.push({
					name: "text",
					content: item
				})
			}
		}
		e = xml.indexOf('>', i)		// end
		if (e < 0)
//fixme: error
			return root

		switch (xml[i + 1]) {
		case '?':
			continue		// XML header
		case '!':
			e = xml.indexOf('-->', i) // XML comment
			if (e < 0)
				return root
			continue
		case '/':
			item = xml.slice(i + 2, e)
			if (item != o.name) {
				error(1, null, 'Found tag </' + item +
					'> instead of </'+o.name + '>')
				continue
			}
			o = stack.pop()
			if (!o)
				error(1, null, 'No start tag "' + item + '"')
			continue
		}
		item = xml.slice(i + 1, e)
		n = item.match(/(\w+)[\s]*([^]*)/)
		no = {
			name: n[1],
			ix: i
		}
		if (!o.children)
			o.children = []
		o.children.push(no)
		if (n[2].slice(-1) != '/') {	// if some content
			stack.push(o)
			o = no
		} else {
			n[2] = n[2].slice(0, -1)
		}
		if (!n[2])
			continue
		n = n[2].match(/[^\s"=]+=?|".*?"/g)	// "
		for (j = 0; j < n.length; j += 2) {
			an = n[j].slice(0, -1)
			no[an] = n[j + 1].slice(1, -1)
		}
	}
	return root
}

// convert MEI to music suitable to the abc2svg generator
Abc.prototype.mei2mus = function(mei) {
    var	curr = {	// various elements while parsing the MEI source
		beam: 0,
		delayed: {},
		fnt: {},
		ftn: 0,
		ids: {},
		meastim: 0,
		mu: C.BLEN / 4,
		pt: .01,		// default unit ! en cm
		tp: []			// tuplets
	},
	acc_ty = {
		"ff": -2,
		"f": -1,
		"s": 1,
		"x": 2,
//		"ss": 2,
		"n": 3
	},
	bar_ty = {
		dashed: ".|",
		dbl: "||",
		dbldashed: ".||",
		dbldotted: ".||",
		dotted: ".|",
		end: "|]",
		invis: "[]",
		rptstart: "|:",
		rptboth: "::",
		rptend: ":|",
		single: "|"
	},
	fn = "",

	// --- functions associated to the start of MIE tags
	fns = {

	// accidental
	accid: function(tag) {
	    var	s = curr.s,
		note = s.notes[s.nhd]

		if (acc_ty[tag.accid])
			note.acc = acc_ty[tag.accid]
	}, // accid()

	arpeg: function(tag) {
	    var	s
		if (!tag.plist)
			return
// plist = list of notes of the chord
		s = tag.plist.split(/\s+/)[0].slice(1)	// top note
		s = curr.ids[s]			// always defined
		s = s.s				// chord
		add_dcn(s, "arpeggio")
	}, // arpeg()

	// articulation inside chord or note
	artic: function(tag) {
		artic(curr.chord || curr.s, tag)
	}, // artic()

	barLine: function(tag) {
	    var	s, ty

		if (tag.form)
			ty = bar_ty[tag.form]
		if (!ty)
			ty = "|"
		s = {
			type: C.BAR,
			istart: tag.ix,
			bar_type: ty,
			dur: 0,
			multi: 0
		}
		sym_link(s)
		if (ty[0] == '.') {
			s.bar_type = ty.slice(1)
			s.bar_dotted = true
		}
	}, // barLine()

	// start of beam
	beam: function(tag) {
		curr.beam = 1
	}, // beam()

	// beam crossing staves or measure bars
	beamSpan: function(tag) {
	    var	s = get_ref(tag),
		s2 = get_ref(tag, s)
		if (!s || !s2)
			return
		s.beam_st = true
		if (s.st == s2.st) {
			while (s != s2) {
				if (s.type == C.BAR)
					s.beam_on = true
			}
//		} else {
//fixme: beams on 2 voices do not work!
		}
		s2.beam_end = true
	}, // beamSpan()

	breath: function(tag) {
	    var	s = get_ref(tag)
		if (!s)
			return
		if (s.s)		// !
			s = s.s
//		tag.place above/below
		add_dcn(s, "breath")
	}, // breath()

	// start of chord
	chord: function(tag) {
	    var	dur = durcnv(tag),
		s = {
			type: C.NOTE,
			istart: tag.ix,
			stem: 0,
			multi: 0,
			nhd: -1,
			xmx: 0,
			dur: dur,
			dur_orig: dur,
			notes: []
		}
		switch (tag["stem.dir"]) {
		case "up": s.stem = 1; break
		case "down": s.stem = -1; break
		}
		switch (curr.beam) {
		case 0:
			s.beam_st = true
			s.beam_end = true
			break
		case 1:
			s.beam_st = true
			curr.beam = 2
			break
		}
//if (0) {
//		switch (tag.tie) {
//		case "i":
//		case "m":
//			curvoice.tie_s = s
//			break
//		}
//}
		if (tag.artic)
			artic(s, tag)
//fixme:cross-staff chord
//		tag.stem.with
//fixme: staff change?
//		tag.staff
		if (tag.grace)
			s.grace = true
		sym_link(s)
		curr.chord = s
	}, // chord()

	clef: function(tag) {
	    var	s = new_clef(tag.shape + tag.line)
		if (s)
			get_clef(s)
	}, // clef()

	composer: set_text,

	// annotation
	dir: set_text,

	// start of division
	div: set_text,

	dynam: set_text,

	// variant ending
	ending: function(tag) {
		curr.ending = tag.n	// "1", "2"
	}, // ending()

	// single element of figured bass - in <harm>
	f: function(tag) {
		if (curr.text)
			curr.text += "\n"
	}, // f()

//	figured bass - in <harm>
//	fb: function(tag) {
//	}, // fb()

	fileDesc: function(tag) {
		return true	// skip
	}, // fileDesc()

	fing: set_text,

	fermata: function(tag) {
	    var	s = get_ref(tag)
		if (!s)
			return
		if (s.s)
			s = s.s
//		tag.place above/below
		add_dcn(s, tag.form != "inv" ? "fermata" : "invertedfermata")
	}, // fermata()

	// group of grace notes
	graceGrp: function(tag) {
//		tag.attach	pre
	},

	// crescendo, diminuendo
	hairpin: function(tag) {
	    var	s = get_ref(tag),
		s2 = get_ref(tag, s)

		if (!s || !s2)
			return
		if (s.s)			// on notes!
			s = s.s
		if (s2.s)
			s2 = s2.s

		switch (tag.place) {
		case "above": s.pos.dyn = C.SL_ABOVE; break
		case "below": s.pos.dyn = C.SL_BELOW; break
		}
		switch (tag.form) {
		default:
//		case "cres":
			add_dcn(s, "<(")
			add_dcn(s2, "<)")
			break
		case "dim":
			add_dcn(s, ">(")
			add_dcn(s2, ">)")
			break
		}
	}, // hairpin()

	// chord symbol (harmony)
	harm: set_text,

	// start of incipit
	incip: function(tag) {
//fixme: skip
return true
//		tosvg(fn, "X:1")
//		parse.state = 1		// inside tune
	}, // incip()

	// start of line or start of line group
	l: function(tag) {
		if (curr.text)
			curr.text += "\n"
	}, // l()

	// start of label or labelAbbr
	label: function(tag) {
		if (curr.st == undefined	// not in staff definition
		 && !curr.staffGrp)		// not in staffGrp
			return true
		set_text(tag)
	}, // label()

	// layer (voice) - must be inside staff
	layer: function(tag) {
	    var	v, p_v, old_sy, s, vid, t,
		st = curr.st,			// ABC staff number
		staff = par_sy.staves[st],
		n = tag.n

		// set the (ABC) start of tune
		if (parse.state < 2) {
			staves_found = 0// don't generate a dummy staff system
			if (staff["meter.sym"] || staff["meter.count"]) {
				new_meter(metercnv(staff))
				curr.mu = meteru(staff)
				delete staff["meter.sym"]
				delete staff["meter.count"]
			}
			get_key(staff["key.sig"] ? keycnv(staff) : "C")
		}

		// build the voice ID = "#staff[#layer]"
		vid = (curr.st + 1).toString()
		if (n && n != "1")
			vid += n

		// if the voice is not in the current staff system, update it
		p_v = new_voice(vid)

		// if a new voice, do a full definition
		if (p_v.new) {
			v = p_v.v
			p_v.st = p_v.cst = st
			p_v.time = curr.meastim

//			// if inside tune, add a new staff system
//			if (voice_tb[v].time != 0 && !curr.newsy) {
//				curr.newsy = true
//				old_sy = par_sy
//				par_sy = clone(par_sy)
//				par_sy.voices = clone(par_sy.voices)
//				par_sy.staves = clone(par_sy.staves)
//				old_sy.next = par_sy
//			}

			if (!par_sy.voices[0])
				par_sy.top_voice = v	// first voice
			if (n)
				n = Number(n) - 1
			else
				n = 0
			par_sy.voices[v] = {
				st: st
//				range: // set below
//				sep:
//				maxsep:
			}

			// sort the voices
			if (!par_sy.rv)
				par_sy.rv = []
			par_sy.rv.push({
				v: v,
				r: st * 10 + n
			})
			par_sy.rv.sort(function(n1, n2) {
				return n1.r - n2.r
			})
			for (n = 0; n < par_sy.rv.length; n++) {
				v = par_sy.rv[n].v
				par_sy.voices[v].range = n
			}
			v = p_v.v
			while (--v >= 0) {
				if (par_sy.voices[v].st == st) {
					p_v.second =
						par_sy.voices[p_v.v].second = true
					break
				}
			}
		}
		if (tag.label) {
			t = tag
		} else if (staff.label) {
			t = staff.label
			staff.label = null
		}
		if (t) {
			p_v.nm = t.label
			p_v.new_name = true
			if (t["label.abbr"])
				p_v.snm = t["label.abbr"]
		}

		get_voice(vid)

		if (staff["clef.shape"]) {		// if clef change
			s = new_clef(clefcnv(staff))
			delete staff["clef.shape"]	// one clef per staff
			if (s) {
				get_clef(s)

				// put the clef before the measure bar
				if (s.prev && s.prev.bar_type) {
					s.next = s.prev
					if (s.prev.prev)
						s.prev.prev.next = s
					else
						s.p_v.sym = s
					s.prev = s.prev.prev
					s.next.prev = s
					s.next.next = null
					curvoice.last_sym = s.next
				}
			}
		}

//if (0) {
//		// if a new voice inside tune, add a measure bar
//		if (new_v)
//			sym_link({
//				type: C.BAR,
//				meas: curr.meas,
////fixme: the bar type depends on the previous measure
//				bar_type: "|",
//				dur: 0,
//				multi: 0
//			})
//}
	}, // layer()

	lb: function(tag) {
//fixme: here for chord symbol/annotation
// may be for page header/footer or ...
//		curr.text += ";"
		curr.text += "\n"
	}, // lb()

	mei: function(tag) {
		if (!tag.meiversion || tag.meiversion[0] != "4")
			error(0, null, "Bad MEI version " + tag.meiversion)
	},

	meter: function(tag) {
	    var	m
		if (tag.count) {
			m = tag.count
			if (tag.unit)
				m += "/" + tag.unit
			new_meter(m)
			m = C.BLEN / (tag.unit ? Number(tag.unit) : 1)
		} else switch (tag.sym) {
			case "common": new_meter("C"); m = 4; break
			case "cut": new_meter("C|"); m = 2; break
		}
		if (m)
			curr.mu = C.BLEN / m
	}, // meter()

	mRest: function(tag) {
	    var	s = {
			type: C.REST,
			istart: tag.ix,
			stem: 0,
			multi: 0,
			nhd: 0,
			xmx: 0,
			dur: curvoice.wmeasure,
			dur_orig: curvoice.wmeasure
		}
//		tag.cutout
		sym_link(s)
		if (curvoice.wmeasure == 1)		// if no meter
			curr.mrest = true
		if (par_sy.staves[s.st].invis)
			s.invis = true
	}, // mRest()

	// new measure
	measure: function(tag) {
		// anacrusis when n="0" type="upbeat"
		curr.meas = tag.n			// for errors
	}, // measure()

	mordent: function(tag) {
//fixme: handle note in chord
	    var	ty,
		s = get_ref(tag)

		if (!s)
			return
		if (s.s)
			s = s.s
//fixme: handle mordent in chord

		switch (tag.form) {
		default:
//		case "upper":
				ty = "uppermordent"; break
		case "lower": ty = "lowermordent"; break
		}
		add_dcn(s, ty)
	}, // mordent()

	multiRest: function(tag) {
	    var	dur = curvoice.wmeasure * tag.num,
		s = {
			type: C.MREST,
			istart: tag.ix,
			stem: 0,
			multi: 0,
			nhd: 0,
			xmx: 0,
			dur: dur,
			dur_orig: dur
		}
		sym_link(s)
	}, // multiRest()

	// start of the tune
	music: function(tag) {
		info.X = "1"
		parse.fname = "mei"
		parse.state = 1		// inside tune
	}, // music()

	note: function(tag) {
	    var	note, s, acc, pit, dur, v, i, vi, gr, ref, st,
		oct = tag.oct,
		id = tag["xml:id"]

		if (!tag.pname) {
			if (tag["pname.ges"]) {
				tag.pname = tag["pname.ges"]	//fixme
//				return
			} else if (tag.sameas) {
				ref = tag.sameas
				if (ref[0] == '#')
					ref = ref.slice(1)
				s = clone(curr.ids[ref])	// always defined
				if (!s.type) {			// if in chord
					note = s
					s = null
				} else {
					s.notes = clone(s.notes)
					s.notes[0] = note = clone(s.notes[0])
					note = s
				}
			} else {
// may be
// <note cue="true" head.shape="slash" stem.dir="up"/>
				return
			}
		}

		if (!note) {
			if (!oct)
				oct = curr.oct
			note = {
				pit: "cdefgab".indexOf(tag.pname.toLowerCase()) +
					oct * 7 - 12,
				shhd: 0,
				shac: 0
			}
		}
		if (curr.chord) {
			s = curr.chord
			dur = s.dur
//fixme: tie in chord?
//			if (s.tie_s)
//				note.tie_ty = C.SL_AUTO
			s.notes[++s.nhd] = note
		} else {
			dur = durcnv(tag)
			if (!s) {
				s = {
					type: C.NOTE,
					stem: 0,
					multi: 0,
					nhd: 0,
					xmx: 0,
					dur: dur,
					dur_orig: dur,
					notes: [note]
				}
			}
			s.istart = tag.ix

			switch (tag["stem.dir"]) {
			case "up": s.stem = 1; break
			case "down": s.stem = -1; break
			}
			if (tag.grace) {	// if in a grace note sequence
				gr = curvoice.last_sym
				if (gr && gr.type != C.GRACE) {
					gr = {			// new grace note
						type: C.GRACE,
						istart: tag.ix,
						dur: 0,
						stem: 0,
						multi: 0
					}
//fixme
//					if (tag["stem.mod"] == "1slash")
//						gr.sappo = true
					sym_link(gr)
					gr.extra = s
				} else {
					gr = gr.extra
					while (gr.next)		// add the note
						gr = gr.next
					gr.next = s
					s.prev = gr
				}
				s.cst = s.st = curvoice.st
				s.v = curvoice.v
				s.p_v = curvoice
			} else {
				switch (curr.beam) {
				case 0:
					s.beam_st = true
					s.beam_end = true
					break
				case 1:
					s.beam_st = true
					curr.beam = 2
					break
				}
				sym_link(s)
			}
		}
		if (id) {
			note.s = s
			do_delayed(id, curr.chord ? note : s)
		}
		note.dur = dur
		if (acc_ty[tag.accid])
			note.acc = acc_ty[tag.accid]

//fixme: may have notes of the chord on different staves
		if (tag.staff)
			s.st = curr.st_cnv[tag.staff - 1] // ABC staff number

//fixme:
//		head.auth
//			"smufl"
//fixme:
// if auth == smufl,
//   head.shape is a glyph reference as "#xE000" or "U+E000"
//		switch (tag["head.shape"]) {
//		case "slash":			// ??
//		}
//fixme:
//		switch (tag["head.fill"]) {
//		case "void":
//		case "solid":
//		case "top":
//		case "bottom":
//		case "left":
//		case "right":
//		}
//fixme:
//		tag["head.visible"]
		if (tag.grace)
			s.grace = true
		switch (tag.tuplet) {
		case "i1":
			curr.tp.push(s)
			break
//		case "m1":
//			ignored
		case "t1":
			if (curr.tp.length)
				tp_set(curr.tp.pop(), {
						num: 3,
						numbase: 2
						})
//fixme: else error
			break
		}

//fixme: always <tie> ?
//if (0) {
//		switch (tag.tie) {
//		case "t":
//		case "m":
//			s.tie_s = curvoice.tei_s
////fixme: KO if chord
//			s.notes[0].tie_m = s.notes.length - 1
//			if (tag.tie == "t")
//				break
//			// fall thru
//		case "i":
//			note.tie_ty = C.SL_AUTO
//			curvoice.tei_s = s
//			break
//		}
//}

// used for play ?
//		if (tag.slur) {
//		}

		if (tag.color)
			s.color = tag.color

		curr.s = s			// last note
		curr.oct = oct			// last octave

		// other attributes
		if (tag.artic)
			artic(s, tag)
//fixme:cross-staff chord
//		tag.stem.with
		switch (tag.breaksec) {
		case "1": s.beam_br1 = true; break
		case "2": s.beam_br2 = true; break
		}
//fixme: tag.staff may be used in chords for cross-staff chords
//		tag.staff	# new staff

//fixme: not visual?
//		if (tag.fermata)
//			add_dcn(s, "fermata")
	}, // note()

//	part: function(tag) {
//	}, // part()

//	parts: function(tag) {
//	}, // parts()

	// new page for text
	pb: function(tag) {
	    var	s
//fixme: tag.n (page number)
		if (parse.state == 3) {
			s = new_block("newpage")
			s.param = tag.n || ""
		} else {
			blk_flush()
			block.newpage = true
		}
	}, // pb()

	pedal: function(tag) {
	    var	dcn,
		s = get_ref(tag)
		if (!s)
			return
		if (s.s)
			s = s.s
		switch (tag.dir) {
		default:
//		case "up":
				dcn = "ped)"; break
		case "down": dcn = "ped("; break
		}
		add_dcn(s, dcn)
	}, // pedal()

	rend: function(tag) {
	    var	font, n,
		f = ""

		if (tag.fontfam)
			f += " " + tag.fontfam
		if (tag.fontname)
			f += " " + tag.fontname
		if (tag.fontweight)
			f += " " + tag.fontweight
		if (tag.fontstyle)
			f += " " + tag.fontstyle
		if (!f)
			f = "*"
		else
			f = f.slice(1)
		if (tag.fontsize) {
			n = parseInt(tag.fontsize) * 1.33	// 72 -> 96 DPI
			f += " " + n.toString()
		} else {
			f += " *"
		}
		if (f != "* *") {
			n = curr.fnt[f]
			if (!n) {
				n = ++curr.ftn
				curr.fnt[f] = n
				param_set_font("setfont-" + n, f)
			}
			curr.text += '$' + n
			curr.rend = true
		}
	}, // rend()

	rest: function(tag) {
	    var	id = tag["xml:id"],
		dur = durcnv(tag),
		s = {
			type: C.REST,
			istart: tag.ix,
			stem: 0,
			multi: 0,
			nhd: 0,
			xmx: 0,
			dur: dur,
			dur_orig: dur
		}

		if (tag.name == "rest") {
			switch (curr.beam) {
			case 0:
				s.beam_st = true
				s.beam_end = true
				break
			case 1:
				s.beam_st = true
				curr.beam = 2
				break
			}
		} else {			// space
			s.invis = true
		}

		sym_link(s)

		if (id)
			do_delayed(id, s)

		switch (tag.tuplet) {
		case "i1":
			curr.tp.push(s)
			break
//		case "m1":
//			ignored
		case "t1":
			if (curr.tp.length)
				tp_set(curr.tp.pop(), {
						num: 3,
						numbase: 2
						})
//fixme: else error
			break
		}
	}, // rest()

	revisionDesc: function(tag) {
		return true	// skip
	}, // revisionDesc()

	// newline for music
	sb: function(tag) {
		curvoice.last_sym.eoln = true
	}, // sb()

//	score: function(tag) {
//		tag.n
//		tag.id
//	}, // score()

	// score definition (= new staff system)
	// may contain a staffGrp (no staffGrp in <section>?)
	// may appear in section/(ending?) or between section/ending (in score/part)
	scoreDef: function(tag) {
	    var	w, h, v, tmp

		curr.scoreDef = tag

		if (parse.state >= 2) {
//			if (tag["clef.shape"]) {
//				s = new_clef(clefcnv(tag))
//				if (s) {
//					get_clef(s)
////fixme: move the clef - see layer:
//				}
//			}
			if (tag["key.sig"]) {
				tmp = keycnv(tag)
				for (v = 0; v < voice_tb.length; v++) {
					curvoice = voice_tb[v]
					get_key(tmp)
				}
			}
//			if (tag["meter.count"]) {
//				new_meter(metercnv(tag))
//				curr.mu = meteru(tag)
//			}
		}

//		// init the staff system
//		if (!curr.st_cnv)
//			curr.st_cnv = []

		// page layout
//fixme: the value of vu.height is odd!
		// recompute the height/width conversion
		if (tag["page.height"] && tag["page.width"]) {
			h = tag["page.height"]
			w = tag["page.width"]
			if (/^\d+$/.test(h + w))
				curr.pt = h / w > 1.3 ?
						1123.66 / h :	// A4
						1056 / h	// US letter
		}

//		if (tag["page.botmar"])
//			module
//		if (tag["page.height"])
//			module
		if (tag["page.leftmar"])
			self.set_format("leftmargin",
					unitcnv(tag["page.leftmar"]))
		if (tag["page.rightmar"])
			self.set_format("rightmargin",
					unitcnv(tag["page.rightmar"]))
		if (tag["page.scale"])
			self.set_format("pagescale", tag["page.scale"])
//		if (tag["page.topmar"])
//			module
		if (tag["page.width"])
			self.set_format("pagewidth",
					unitcnv(tag["page.width"]))

//		if (tag["music.name"])
//			musicfont = tag["music.name"]
//		if (tag["music.size"])
//fixme

	}, // scoreDef()

//	section: function(tag) {
//	}, // section()

	slur: function(tag) {
	    var	sl,
		s1 = get_ref(tag),
		s2 = get_ref(tag, s1),
		ty = C.SL_AUTO

		if (!s1 || !s2)
			return

		switch (tag.curvedir) {
		case "above": ty = C.SL_ABOVE; break
		case "below": ty = C.SL_BELOW; break
		}
		switch (tag.lform) {
		case "dashed":
		case "dotted": ty |= C.SL_DOTTED; break
		}

		sl = { ty: ty }
		if (s2.s) {
			sl.is_note = true	// to note
			sl.note = s2
		} else {
			s2.notes[0].s = s2
			sl.note = s2.notes[0]	// to chord
		}

		if (!s1.sls)
			s1.sls = []
		s1.sls.push(sl)
		if (s1.s)			// if from note of chord
			s1.s.sl1 = true
//fixme: ko if grace note
	}, // slur()

	sourceDesc: function(tag) {
		return true	// skip
	},

	// staff - must be inside measure and must contain layers
	staff: function(tag) {
		curr.st = curr.st_cnv[tag.n - 1]	// ABC staff number
		if (curr.st == undefined) {
			error(1, null, "Unknown staff " + tag.n)
			return true
		}
	    var	staff = par_sy.staves[curr.st]
		switch (tag.visible) {
		case "false":
			staff.invis = true
			break
		case "true":
			staff.invis = false
			break
		}
	}, // staff()

	// staff definition
	// the order in the staffGrp is the (ABC) staff number
	// may appear in scoreDef, measure, staffGrp
	//	between measures (in section/ending)
	//	and between section/ending (in score/part)
	staffDef: function(tag) {
	    var	k, st, def, staff, sy,
		n = tag.n - 1,			// MEI staff number
		grp = curr.staffGrp

		if (!curr.st_cnv)
			curr.st_cnv = []
		else
			st = curr.st_cnv[n]	// ABC staff number
		if (st == undefined) {		// if new staff
			staff = {
				stafflines: '|||||',
				staffscale: 1,
				flags: 0
			}
			if (grp) {
				staff.flags = grp.flags
				grp.flags &= STOP_BAR
			}

			if (parse.state == 3 && !curr.newsy) {
				curr.newsy = true
				sy = par_sy
				par_sy = clone(sy)
				sy.next = par_sy
				par_sy.voices = clone(par_sy.voices)
				par_sy.staves = clone(par_sy.staves)
			}

			st = par_sy.staves.length	// ABC staff number
			par_sy.staves.push(staff)	// new staff
			par_sy.nstaff = st
			curr.st_cnv[n] = st		// MEI to ABC staff conversion
		} else {
			staff = par_sy.staves[st]
		}

		// set the default values from the scoreDef
		def = curr.scoreDef
		if (def) {
			for (k in def) {
				switch (k.slice(0, 3)) {
				case "cle":
				case "key":
				case "met":
					staff[k] = def[k]
					break
				}
			}
		}
		// set the values from the current element
		for (k in tag) {
			switch (k.slice(0, 3)) {
			case "cle":
			case "key":
			case "met":
				staff[k] = tag[k]
				break
			}
		}

//fixme
//		if (!staff["clef.shape"]) {
//			error(1, null, "No clef in staff " + tag.n)
//			staff["clef.shape"] = "G"
//			staff["clef.line"] = "2"
//			staff.lines = "5"
//		}

		if (tag.label) {
			staff.label = tag
		} else if (grp && grp.label) {
			staff.label = {
				label: grp.label
			}
			delete grp.label
		}

//		if (tag["music.name"])
//fixme
//		if (tag["music.size"])
//fixme
		if (tag.spacing) {
//fixme: no unit is 10th of mm ?
		    var	v = tag.spacing.slice(-1)
			if (v >= '0' && v <= '9')
				staff.maxsep = Number(tag.spacing) / 100 * CM
			else
				staff.maxsep = get_unit(tag.spacing)
		}
		if (tag.children)
			curr.st = st
	}, // staffDef()

	// group of staves
	// may be contained in a scoreDef
	staffGrp: function(tag) {
		if (!tag.symbol)
			return			// unused?
	    var	grp = curr.staffGrp
		if (!grp) {
			curr.staffGrp = grp = {
				lvl: 0,
				flags: 0
			}
			switch (tag.symbol) {
			case "brace": grp.flags |= OPEN_BRACE; break
			case "bracket": grp.flags |= OPEN_BRACKET; break
			}
		} else {
			grp.lvl++
			switch (tag.symbol) {
			case "brace": grp.flags |= OPEN_BRACE2; break
			case "bracket": grp.flags |= OPEN_BRACKET2; break
			}
		}
		if (tag["bar.thru"] == "false")
			grp.flags |= STOP_BAR
	}, // staffGrp()

	syl: set_text,

	// start of tempo and title
	tempo: function(tag) {
		set_text(tag)
		if (!tag.children)
			fne[tag.name](tag)
	}, // tempo()

	text: function(tag) {
		if (curr.text != undefined)
			curr.text += tag.content.replace(/[ \t\n]+/g, ' ')
	},

	// tie
	tie: function(tag) {
	    var	s1 = get_ref(tag),
		s2 = get_ref(tag, s1),
		ty = C.SL_AUTO

		if (!s1 || !s2)
			return
		switch (tag.curvedir) {
		case "above": ty = C.SL_ABOVE; break
		case "below": ty = C.SL_BELOW; break
		}
		switch (tag.lform) {
		case "dashed":
		case "dotted": ty |= C.SL_DOTTED; break
		}
		if (s1.s) {
			s1.tie_ty = ty
			if (s2.s) {			// note - note
				s1.s.tie_s = s2.s
				s1.tie_n = s2
				s2.s.ti2 = s1.s
			} else {			// note - single note
				s1.s.tie_s = s2
				s1.tie_n = s2.notes[0]
				s2.ti2 = s1.s
			}
		} else {
			s1.notes[0].tie_ty = ty
			if (s2.s) {			// single note - note
				s1.tie_s = s2.s
				s1.notes[0].tie_n = s2
				s2.s.ti2 = s1
			} else {			// single note - single note
				s1.tie_s = s2
				s1.notes[0].tie_n = s2.notes[0]
				s2.ti2 = s1
			}
		}
	}, // tie()

	trill: function(tag) {
	    var	s2,
		s = get_ref(tag)

		if (!s)
			return
		if (tag.dur || tag["dur.ges"] || tag.endid || tag.tstamp2) {
			s2 = get_ref(tag, s)
			if (!s2)
				return
		}
		if (s.s)			// on note
			s = s.s
		switch (tag.place) {
		case "above": s.pos.orn = C.SL_ABOVE; break
		case "below": s.pos.orn = C.SL_BELOW; break
		}
		if (!s2) {
			add_dcn(s, "trill")
			return
		}
		if (s.time >= s2.time) {
			error(1, null, "Bad trill endings")
			return
		}
		add_dcn(s, "trill(")
		add_dcn(s2, "trill)")
	}, // trill()

	// start of tuplet (one nested level only)
	tuplet: function(tag) {
		curr.tp.push(curvoice.last_sym || true)
	}, //tuplet()

	// start of tupletSpan
	tupletSpan: function(tag) {
	    var	last, next, f,
		s = get_ref(tag),
		s2 = get_ref(tag, s)

		if (!s || !s2)
			return

		if (s.tp.length) {
			tp_fl(s.tp[0].f, tag)
			return
		}

		last = curvoice.last_sym
		curvoice.last_sym = s2
		next = s2.next
		s2.next = null
		tp_set(s, tag)
		s2.next = next
		curvoice.last_sym = last
	}, // tupletSpan()

	verse: function(tag) {
		curr.verse = tag
	}, // verse()

	work: function(tag) {
		curr.work = true
	}, // work()

	}, // fns

	// --- functions associated to the end of MIE tags
	fne = {

	// end of beam
	beam: function(tag) {
		curr.s.beam_end = true
		curr.beam = 0
	}, // beam()

	// end of chord
	chord: function(tag) {
	    var	id = tag["xml:id"]
		if (id)
			do_delayed(id, curr.chord)
		curr.chord = null
	}, // chord()

	// end of composer
	composer: function(tag) {
		if (!curr.text)
			return
		if (info.C == undefined)
			info.C = curr.text
		else
			info.C += "\n" + curr.text
		curr.text = undefined
	}, // composer()

	// end of annotation (dir) / chord symbol (harm) / annotation (dynam)
	dir: function(tag) {
	    var	gch, ty, t, i,
		font = gene.deffont,
		s = get_ref(tag)

		if (!s)
			return
		if (s.s)
			s = s.s
		switch (tag.name) {
		case "dir":
		case "dynam":
			switch (tag.place) {
			default:
//			case "above":
					ty = "^"; break
			case "below": ty = "_"; break
			}
			break
		default:
			ty = "g"
			switch (tag.place) {
			default:
//			case "above":
					s.pos.gch = C.SL_ABOVE; break
			case "below": s.pos.gch = C.SL_BELOW; break
			}
			break
		}
		a_gch = s.a_gch || []
		t = curr.text.split('\n')
		if (t[0][0] == ' ')
			t[0] = t[0].slice(1)
		for (i = 0; i < t.length; i++) {
			gch = {
				type: ty,
				font: font,
				text: t[i]
			}
			a_gch.push(gch)
		}
		self.gch_build(s)
		curr.text = undefined
	}, // dir()

	// end of division
	div: function(tag) {
	    var s
		switch (tag.type) {
		case undefined:
			s = new_block("text")
			s.text = curr.text
			break
		case "verse":
			if (info.W == undefined)
				info.W = ""
			if (tag.label)
				info.W += tag.label + " "
			info.W += curr.text + "\n\n"
			break
		default:
			error(1, null, "Tag <div> type "+ tag.type + "not treated")
			break
		}
		curr.text = undefined
	}, // div()

	// end of dynam
	dynam: function(tag) {
	    var	t,
		s = get_ref(tag)
		if (!s)
			return
		if (s.s)
			s = s.s
		t = curr.text.replace(/[ \t\n]+/g, ' ')
		if (t[0] == ' ')
			t = t.slice(1)
		switch (tag.place) {
		case "above": s.pos.dyn = C.SL_ABOVE; break
		case "below": s.pos.dyn = C.SL_BELOW; break
		}
		add_dcn(s, t, tag)
		curr.text = undefined
	}, //dynam()

	// end of variant ending
	ending: function(tag) {
	    var	v = voice_tb.length
		while (--v >= 0) {
			if (voice_tb[v].last_sym)
				voice_tb[v].last_sym.rbstop = 2
		}
	}, // ending()

	fing: function(tag) {
	    var	s = get_ref(tag)
		if (!s)
			return
		if (s.s)
			s = s.s
		switch (tag.place) {
		case "above": s.pos.orn = C.SL_ABOVE; break
		case "below": s.pos.orn = C.SL_BELOW; break
		}
		add_dcn(s, curr.text)
		curr.text = undefined
	}, // fing()

//	// end of incipit
//	incip: function(tag) {
//		tosvg(fn, "\n")			// generate
//		curr.st_cnv = null
//		curr.meastim = 0
//		curr.mu = C.BLEN / 4
//	}, // incip()

	// end of label (voice name)
	label: function(tag) {
		if (!curr.text)
			return
	    var	grp = curr.staffGrp,
		st = curr.st			// ABC staff number
		if (st  == undefined) {
			if (grp) {
				grp.label = curr.text
				curr.text = undefined
			}
			return
		}
	    var	staff = par_sy.staves[st]
		if (!staff.label)
			staff.label = {}
		staff.label.label = curr.text
		curr.text = undefined
	}, // label()

	labelAbbr: function(tag) {
		if (!curr.text)
			return
	    var	st = curr.st,			// ABC staff number
		staff = par_sy.staves[st]
		if (!staff.label)
			staff.label = {}
		staff.label["label.abbr"] = curr.text
		curr.text = undefined
	}, // labelAbbr()

	// end of measure
	measure: function(tag) {
	    var	v, s, s2, s3, p_v, tim, ty, dotted,
		n = voice_tb.length

		if (curr.tp.length) {
			error(1, null, "No end of tuplet")
			curr.tp = []
		}

		// change the bars at start of the measure (or start of tune)
		if (tag.left) {
			ty = bar_ty[tag.left]
			if (ty && ty[0] == '.') {
				ty = ty.slice(1)
				dotted = true
			}
		}
		if (ty || curr.ending) {
			for (v = 0; v < n; v++) {
				p_v = voice_tb[v]
				s2 = s = p_v.last_sym
				if (s)
					s = s.prev
				while (s && !s.bar_type)
					s = s.prev
				if (!s) {	// start of tune: add a measure bar
					s3 = p_v.sym
					p_v.last_sym = p_v.sym = null
					curvoice = p_v
					sym_link({
						type: C.BAR,
						istart: tag.ix,
						bar_type: ty || "|",
						dur: 0,
						multi: 0
					})
					s = p_v.last_sym
					p_v.last_sym = s2
					s.next = s3
					if (s3)
						s3.prev = s
					s.time = curr.meastim
				} else if (ty) {
					s.bar_type = ty
				}
				if (dotted)
					s.bar_dotted = true
				if (curr.ending) {
					s.rbstop = 2
					s.rbstart = 2
					s.text = curr.ending
				}
			}
			dotted = false
			ty = null
			delete curr.ending
		}

		// add the ending bar
		if (tag.right)
			ty = bar_ty[tag.right]
		if (!ty)
			ty = "|"

		// if a new staff system, add it at start of the measure
//		// (before the - previous - measure bar)
		// (just after the - previous - measure bar)
		if (curr.newsy) {
			curr.newsy = false
			for (s = voice_tb[par_sy.top_voice].last_sym;
			     s;
			     s = s.prev) {
				if (s.type == C.BAR)
					break
			}
			if (s) {			// ?
				s2 = clone(s)
				s2.type = C.STAVES
				s2.bar_type = 0
				s2.sy = par_sy

//				s2.prev = s.prev
//				s2.prev.next = s2
//				s2.next = s
//				s.prev = s2
				s2.next = s.next
				if (s.next)
					s2.next.prev = s2
				s.next = s2
				s2.prev = s
			}
		}

		// synchronize the voices
		// adjust the duration of the full measure rests
		// add the measure bars
		tim = 0
		for (v = 0; v < n; v++) {
			p_v = voice_tb[v]
			if (p_v.time > tim)
				tim = p_v.time
		}
		if (curr.mrest) {		// if some full measure rests
			curr.mrest = false
			for (v = 0; v < n; v++) {
				p_v = voice_tb[v]
				s = p_v.last_sym // there may be only rest and bar
				if (s && s.type == C.BAR)
					s = s.prev
				if (!s || s.type != C.REST || s.time != curr.meastim)
					continue
				s.dur = s.dur_orig = tim - curr.meastim
//fixme: should set a flag saying 'full measure rest'
				if (s.next)
					s.next.time = tim	// bar time
			}
		}
		if (ty[0] == '.') {
			ty = ty.slice(1)
			dotted = true
		}
		for (v = 0; v < n; v++) {
			p_v = voice_tb[v]
			p_v.time = tim

			s = p_v.last_sym
			if (s && s.time == tim && s.bar_type)
				continue
//			get_voice(p_v.id)
			curvoice = p_v
			s = {
				type: C.BAR,
				istart: tag.ix,
				bar_type: ty,
				dur: 0,
				multi: 0
			}
			if (dotted)
				s.bar_dotted = true
			if (v == par_sy.top_voice)
				s.bar_num = Number(tag.n) + 1
			sym_link(s)
		}
		curr.meastim = tim
	}, // measure()

	// end of the tune
	music: function(tag) {
		sanitize()

//fixme: copy of end_tune()
		generate()
		if (info.W)
			put_words(info.W)
		put_history()
		blk_flush()
	}, // music()

//	// end of page footer
//	pgFoot: function(tag) {
//		<p>
//	}, // pgFoot()

//	// end of page header
//	pgHead: function(tag) {
//		<title>
//		<persName role>
//	}, // pgHead()

	// end of rendition
	rend: function(tag) {
		if (curr.rend) {
			curr.rend = false
			curr.text += "$0"
		}
	}, // rend()

	// end of score definition
	scoreDef: function(tag) {
		curr.scoreDef = null
	}, //scoreDef()

	// end of staff definition
	staffDef: function(tag) {
		delete curr.st
	}, //staffDef()

	// end of staff group
	staffGrp: function(tag) {
	    var	grp = curr.staffGrp,
		st = par_sy.staves.length - 1,	// last staff
		staff = par_sy.staves[st]

		if (!grp)
			return
		if (--grp.lvl < 0) {
			curr.staffGrp = null
			switch (tag.symbol) {
			case "brace": staff.flags |= CLOSE_BRACE; break
			case "bracket": staff.flags |= CLOSE_BRACKET; break
			}
			return
		}
		switch (tag.symbol) {
		case "brace": staff.flags |= CLOSE_BRACE2; break
		case "bracket": staff.flags |= CLOSE_BRACKET2; break
		}
	}, // staffGrp()

	// end of syllabe
	syl: function(tag) {
	    var	t = curr.text.replace(/[ \t\n]+/g, ' ')
		curr.text = undefined

		if (t[0] == ' ')
			t = t.slice(1)

	    var	l, wh, c,
		s = curr.s		// note
		curvoice.have_ly = true
		wh = strwh(t)

		if (curr.verse && curr.verse.n)
			l = curr.verse.n - 1	// verse number (0...n-1)
		else
			l = 0			// ('n' omitted)

		if (t.slice(-1) == '-')
			t = t.slice(0, -1) + '\n'
		switch (tag.con) {		// connector
		case "s":
			t += ' '
			break
		case "d":
			t += '-'
			break
		case "u":
			t += '_'
			break
//		case "t":
//			c = '~'
//			break
//		case "c":
//			break
//		case "v":
//			break
//		case "i":
//			break
//		case "b":
//			break
		}
		switch (tag.wordpos) {
		case "i":			// initial
		case "m":			// middle
			if (t.slice(-2) != "\n") {
				if (c == '_')
					t += c
				t += "\n"
			}
			break
//		case "t":
//			break
		}

		if (!s.a_ly)
			s.a_ly = []
		s.a_ly[l] = {
			t: t,
			font: gene.curfont,
			wh: wh
		}
	}, // syl()

	// end of tempo
	tempo: function(tag) {
	    var	t = curr.text.replace(/[ \t\n]+/g, ' ')
		curr.text = undefined

//		if (t[0] == ' ')
//			t = t.slice(1)
//		if (!t || t == "undefined")
//			return

	    var	s,
		s2 = {
			type: C.TEMPO,
			dur: 0
		}
		if (t)
			s2.tempo_str1 = t
		if (tag.mm) {
			s2.tempo_notes = [curr.mu]
			s2.tempo = tag.mm
		}
		if (parse.state <= 1) {
			info.Q = '"' + t + '"'
			glovar.tempo = s2
			return
		}

		// insert the tempo before the reference
		s = get_ref(tag)
		if (!s)
			return
		s2.prev = s.prev
		s.prev = s2
		s2.next = s
		if (s2.prev)
			s2.prev.next = s2
		else
			s.p_v.sym = s2
		s2.v = s.v
		s2.p_v = s.p_v
		s2.st = s.st
		s2.time = s.time
	}, // tempo()

	// end of title
	title: function(tag) {
	    var	t = curr.text.replace(/[ \t]+/g, ' ')
		curr.text = undefined
		if (t[0] == ' ')
			t = t.slice(1)
		if (parse.state != 3) {
			if (info.T == undefined)
				info.T = t
			else
				info.T += "\n" + t
		} else {
		    var	s = new_block("title")
			s.text = t
		}
	}, // title()

	// end of tuplet
	tuplet: function(tag) {
	   var	s = curr.tp.pop() // symbol before the start of the tuplet
				  // or 'true' if the tune starts with a tuplet

		if (s && (tag.dur || tag.num))
			tp_set(s == true ? curvoice.sym : s.next, tag)
	}, // tuplet()

	// end of work
	work: function(tag) {
		curr.work = false
	}, // work()

	} // fne

	// common code
	fns.lg = fns.l			// start of line group
	fns.labelAbbr = fns.label	// start of labelAbbr
	fns.space = fns.rest		// space
	fns.title = fns.tempo

	fne.harm = fne.dir		// end of chord symbol (harmony)

	// add a decoration into a symbol
	function add_dcn(s, dcn, tag) {
	    var	dd = dd_tb[dcn]

		// build a dynamic decoration
		function build_dyn(t) {
		    var	i,
			str = "",
			dd = {
				name: t,
				func: 6,
				glyph: t,
				h: 18,
				wl: t.length * .3,
				wr: t.length * .7
			}
			for (i = 0; i < t.length; i++) {
				switch (t[i]) {
				case 'f': str += "\ue522"; break
				case 'p': str += "\ue520"; break
				case 'r': str += "\ue523"; break
				case 's': str += "\ue524"; break
				}
			}
			tgls[t] = {
				x: -4,
				y: -6,
				c: str
			}
			return dd
		} // build_dyn()

		if (!dd) {
			if (decos[dcn]) {		// if known decoration
				dd = deco_def(dcn)
			} else {
				if (!tag)
//fixme: error
					return
				if (tag.name != "dynam"
				 || /[^fprs]/.test(dcn)) {
					fne.dir(tag)	// display as annotation
					return
				}
				dd_tb[dcn] = dd = build_dyn(dcn)
			}
		}
		if (!s.a_dd)
			s.a_dd = []
//		switch (tag.place) {
//		default:
////		case "above":
//		case "below":
//fixme: how to force the place of the decoration?
//		}
		s.a_dd.push(dd)
	} // add_dcn()

	// articulation (inside a chord/note)
	function artic(s, tag) {
	    var	dcn, i,
		d_tb = {
		acc: "accent",
		dnbow: "downbow",
		marc: "marcato",
		open: "open",
		snap: "snap",
		spic: "wedge",
		stacc: "dot",
		ten: "tenuto",
		upbow: "upbow",
		},
		d = tag.artic.split(/\s+/)

		switch (tag.place) {
		case "above": s.pos.orn = C.SL_ABOVE; break
		case "below": s.pos.orn = C.SL_BELOW; break
		}
		for (i = 0; i < d.length; i++) {
			dcn = d_tb[d[i]]
			if (dcn)
				add_dcn(s, dcn)
			else
				error(1, null, "Articulation " + d[i] + " not handled")
		}
	} // artic()

	// define a new element reference and
	// resolve its definition in the associated elements
	function do_delayed(id, s) {
	    var	i, n, tag,
		delayed_a = curr.delayed[id]

		curr.ids[id] = s
		if (!delayed_a)
			return		// no element is waiting for this element
		curr.delayed[id] = null

		n = delayed_a.length
		for (i = 0; i < n; i++) {
			tag = delayed_a[i]
			fns[tag.name](tag)
		}
	}

	// convert a clef
	function clefcnv(tag) {
	    var clef = {"G": "G",
			"GG": "G",
			"F": "F",
			"C": "C",
			"perc": "P",
			"TAB": "tab"}[tag["clef.shape"]]
		if (tag["clef.line"])
			clef += tag["clef.line"]
		if (tag["clef.dis"]) {
			if (tag["clef.dis.place"] == "above")
				clef += '+' + tag["clef.dis"]
			else
				clef += '-' + tag["clef.dis"]
		}
		return clef
	} // clefcnv()

	// convert a (CMN) duration
	function durcnv(tag) {
	    var dur

		switch (tag.dur) {
		case "breve": dur = C.BLEN * 2; break
		case "long": dur = C.BLEN * 4; break
//fixme: beat?
		case undefined: dur = C.BLEN / 4; break
		default: dur = C.BLEN / tag.dur
		}
		switch (tag.dots) {
		case "1": dur *= 3/2; break
		case "2": dur *= 7/4; break
		case "3": dur *= 15/8; break
		}
if (isNaN(dur))
error(1, null, "Bad duration " + tag.dur + " tag:" + tag.name)
		return dur
	} // durcnv()

	// change the source reference in error messages
    var	err_old
	function error_new(sev, s, msg, a1, a2, a3, a4) {
		if (!s)
			s = {}
		if (!s.fname)
			s.fname = "(no ref)"
		if (!s.istart)
			s.istart = parse.istart
		err_old(sev, s, msg, a1, a2, a3, a4)
	}
	err_old = error
	error = error_new

	// get the symbol (chord, note or rest) pointed to
	// by startid/endid or tstamp/tstamp2
	// @end is the pointer to the start symbol
	function get_ref(tag, end) {
	    var	s, st, v_rg, v, voice, tim,
		rg = 100,
		ref = tag[end ? "endid" : "startid"]

		if (ref) {
			if (ref[0] == '#')
				ref = ref.slice(1)
			s = curr.ids[ref]	// symbol or note
			if (!s) {		// the symbol is not defined yet
				if (!curr.delayed[ref])
					curr.delayed[ref] = []
				curr.delayed[ref].push(tag)
				return // null
			}
		} else {			// try a time stamp
			ref = end ? tag.tstamp2 : tag.tstamp
			if (!ref) {
				error(1, null, "No "+ (end ? "end" : "start") +
					" reference tag:" + tag.name)
				return //
			}

			if (ref[1] == 'm') {
				if (ref[0] == '0' && ref[2] == '+')
					ref = ref.slice(3)
				else
//fixme: tstamp2 may have more values
					return
			}

			// convert the beat into internal time
			tim = curr.meastim + curr.mu * (ref - 1)

			// search the voice
			st = curr.st_cnv[tag.staff ? (tag.staff - 1) : 0]
//fixme: may be simplified using the voice ID (main voice of the staff is V:<#staff>
			for (v = 0; v < par_sy.voices.length; v++) {
				voice = par_sy.voices[v]
				if (!voice || voice.st != st)
					continue
				if (voice.range < rg) {
					v_rg = v
					rg = voice.range
				}
			}

			if (rg >= 100) {
				error(1, null, "No voice in staff " + st +
					" tag:" + tag.name)
				return
			}

			// and the symbol
			for (s = voice_tb[v_rg].last_sym; s; s = s.prev) {
				if (s.time <= tim) {
					if (ref != 0)
						break
					while (s && s.type != C.BAR)
						s = s.prev
					break
				}
			}
		}

		if (!s) {
			error(1, null, "No symbol at beat " + ref +
				" in staff " + tag.staff + " tag:" + tag.name)
			return
		}

		if (!end)
			return s

		if (s == end) {
			error(1, s, "References on a same element")
			if (!s.next)
				return
			s = s.next
		}
		if (s.time <= end.time) {
			error(0, s, "References going back in time")
			return
		}
		return s
	} // get_ref()

	// convert a key
	function keycnv(tag) {
	    var	sig2kM = {
			"0" : "C",
			"1s": "G",
			"2s": "D",
			"3s": "A",
			"4s": "E",
			"5s": "B",
			"6s": "F#",
			"7s": "C#",
			"1f": "F",
			"2f": "Bb",
			"3f": "Eb",
			"4f": "Ab",
			"5f": "Db",
			"6f": "Gb",
			"7f": "Cb"
		},
		sig2km = {
			"0" : "Am",
			"1s": "Em",
			"2s": "Bm",
			"3s": "F#m",
			"4s": "C#m",
			"5s": "G#m",
			"6s": "D#m",
			"7s": "A#m",
			"1f": "Dm",
			"2f": "Gm",
			"3f": "Cm",
			"4f": "Fm",
			"5f": "Bbm",
			"6f": "Ebm",
			"7f": "Abm"
		}
		return tag["key.mode"] != "minor" ?
			sig2kM[tag["key.sig"]] :
			sig2km[tag["key.sig"]]
	} // keycnv()

	// convert a meter
	function metercnv(tag) {
		switch (tag["meter.sym"]) {
		case "common": return "C"
		case "cut": return "C|"
		}
		if (tag["meter.unit"])
			return tag["meter.count"] + "/" + tag["meter.unit"]
		return tag["meter.count"]
	} // metercnv()

	// get the unit of a meter
	function meteru(tag) {
	    var	mu = 1
		switch (tag["meter.sym"]) {
		case "common": mu = 4; break
		case "cut": mu = 2; break
		}
		if (tag["meter.unit"])
			mu = Number(tag["meter.unit"])
		return C.BLEN / mu
	} // meteru()

	function set_text(tag) {
	    var	f
		switch (tag.name) {
		case "dir": f = "annotation"; break
		case "dynam": f = "dynam"; break
//		case "fing": f = null; break
		case "harm": f = "gchord"; break
		case "syl": f = "vocal"; break
//		case "tempo": f = null; break
		case "title": f = "title"; break
		}
		if (f)
			set_font(f)
		curr.text = ""
	}

	// set tuplet flags
	function tp_fl(f, tag) {
		if (tag["num.visible"] == "false") {
			f[0] = 1			// when = never
		} else {
			if (tag["bracket.visible"] == "false")
				f[1] = 2		// what = nothing
			if (tag["num.format"] == "ratio")
				f[2] = 2		// which = ratio
		}
		switch (tag["bracket.place"]) {
		case "above": f[3] = 1; break		// where = above
		case "below": f[3] = 2; break		// where = below
		}
	} // tp_fl()

	// handle the end of one tuplet
	function tp_set(s, tag) {
	    var	fact, s2, s3, n,
		nbas = tag.numbase || 2,	// numbas default = 2 ?
		f = Object.create(cfmt.tuplets)

		while (s.grace)
			s = s.next

		if (!s.tp)
			s.tp = []
		s.tp.push({
			p: tag.num,
			q: nbas,
			f: f
		})

		tp_fl(f, tag)

		// adjust the duration of the symbols
		if (tag.dur)
			fact = durcnv(tag) / (curvoice.time - s1.time)
		else
			fact = nbas / tag.num

		tp_adj(s, fact)

		s2 = curvoice.last_sym
		if (!s2.dur) {	// if some odd element at end of the tuplet
			for (s3 = s2; !s3.dur; s3 = s3.prev)
				;
			s3.tpe = s2.tpe	// move the end of tuplet
			delete s2.tpe
		}

		n = 0
		for (s3 = s; s3; s3 = s3.next) {
			if (s3.dur)
				n++
		}
		s.tp[s.tp.length - 1].ro = n	// (needed for toabc)
	} // tp_set()

//fixme: no unit is 10th of mm ?
	function unitcnv(v) {
	    var	nv = v.slice(-1)
		if (nv >= '0' && nv <= '9')
			return (v * curr.pt).toString()
		return v
	}

	// check for bugs in the source
	function sanitize() {
	    var	i, v,
		used_st = []

		// check for used staves
		for (v = 0; v < voice_tb.length; v++) {
			i = voice_tb[v].st
			if (i)
				used_st[i] = true
		}
		for (i = par_sy.nstaff; i > 0; i--) {
			if (used_st[i])
				break
		}
		if (i != par_sy.nstaff)
			error(1, null, "Unused staves "+(i+1)+".."+par_sy.nstaff)
		par_sy.nstaff = i
	} // sanitize()

	// convert to music
	function parse_mei(tag) {
		if (fns[tag.name]) {
			parse.istart = tag.ix
			if (fns[tag.name](tag))
				return			// skip when error
		}
		if (!tag.children)
			return
	    var	i,
		n = tag.children.length
		for (i = 0; i < n; i++)
			parse_mei(tag.children[i])
		if (fne[tag.name])
			fne[tag.name](tag)
	} // parse_mei()

	// main code of mei2mus()

	parse.file = mei
	cfmt.graceslurs = false
	glovar.ulen = C.BLEN / 4
	param_set_font("dynamfont", "serifItalicBold 16")

	parse_mei(xml2tree(mei)) // convert to internal music representation
} // mei2mus()