LaTeX representation in the memory + Scanner + Generator + Operations on document objects
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

358 lines
9.6 KiB

namespace LAview {
/**
* LaTeX Parsers.
*/
namespace Parsers {
/**
* LaTeX Parser Error Type.
*/
public errordomain ParseError {
/**
* Undefined Error.
*/
UNDEFINED,
/**
* Cann't find end of subdoc.
*/
ORPHAN_BEGIN,
/**
* End tag without begin tag.
*/
ORPHAN_END,
/**
* Error in subdoc parsing.
*/
SUBDOC,
}
abstract class Parser : Object {
protected string err_str = "";
/* links to group of scanners */
protected unowned Array<Link> links = null;
/* escaped TeX document */
protected unowned string contents = null;
/* standard GLib Scanner */
protected Scanner scanner = new Scanner (null);
/* tokens_sequence->class table */
protected Node<uint> tokens = new Node<uint> ();
protected Node<uint> stop_tokens = new Node<uint> ();
/* local tokens_sequence->class table */
protected Node<uint> local_tokens_to_class_start = new Node<uint> ();
protected Node<uint> local_tokens_to_class_stop = new Node<uint> ();
/* contents location in global document */
protected size_t line = 0;
protected long position = 0;
/* fifo-queue of tokens */
protected Queue<SymbPos?> symb_fifo = new Queue<SymbPos?> ();
protected struct SymbPos {
public TokenType token;
public uint line;
public long pos;
public uint abspos;
public uint length;
}
/* Last symbol position pushed to fifo */
protected SymbPos last_symb_pos;
/* Last symbol position pushed to fifo */
protected SymbPos subdoc_start;
/* child class and level */
protected uint child_tag = 0;
protected uint child_level = 0;
protected bool in_child_params = false;
protected uint child_param_branch_level = 0;
/* back-slash counter for one-line comments */
protected uint back_slash_counter = 0;
protected Parser (Array<Link> links) {
/* initializing scanner links */
this.links = links;
/* adjust lexing behaviour to suit our needs */
scanner.config.cset_skip_characters = "";
scanner.config.cset_identifier_first = CharacterSet.a_2_z + CharacterSet.DIGITS + "\\";
scanner.config.cset_identifier_nth = CharacterSet.a_2_z + CharacterSet.A_2_Z + CharacterSet.DIGITS;
scanner.config.cpair_comment_single = "%\n";
scanner.config.scan_float = false;
scanner.config.symbol_2_token = true;
scanner.config.scan_string_sq = false; // See bug #448
scanner.config.scan_string_dq = false; // See bug #448
/* set custom error message handler */
scanner.msg_handler = null;
/* load symbols into the self using GLib Quarks */
load_symbols (links);
/* generate tokens table (tree) */
build_tree (ref tokens, links, false);
/* generate stop_tokens table (tree) */
build_tree (ref stop_tokens, links, true);
/* give the error handler an idea on how the input is named */
scanner.input_name = "TeX text";
}
public abstract IDoc parse (string contents, size_t line, long position) throws ParseError;
void vprefix_error (SymbPos symb_pos, string format, va_list args) {
err_str = "\n" + err_str;
var line = symb_pos.line;
long position = symb_pos.pos;
if (line == 0)
position += this.position;
size_t nlines; long i;
for (i = 0, nlines = 0; contents[i] != '\0' && nlines < line; ++i)
if ('\n' == contents[i] || '\r' == contents[i])
++nlines;
var unparsed_str = contents[i:contents.length].split ("\n"); // FIXME: MacOS newline '\r' characters...
var str = unparsed_str[0][0:position];
var compressed = str.compress ();
position = compressed.length + 1;
var arrow_str = string.nfill (position - 1, ' ') + "^";
compressed = unparsed_str[0].compress ();
str = format.vprintf (args);
err_str = "%s:%lu:%lu: %s\n%s\n%s\n%s".printf (get_type().name(),
this.line + line + 1,
position,
str,
compressed,
arrow_str,
err_str);
}
protected void prefix_error (SymbPos symb_pos, string format, ...) {
var list = va_list ();
vprefix_error (symb_pos, format, list);
}
protected void load_symbols (Array<Link> links) {
for (var i = 1; i < links.length; ++i) {
for (var j = 0; j < links.index (i).begin.length; ++j)
if (links.index (i).begin[j].length > 1)
scanner.scope_add_symbol (0, links.index (i).begin[j], (void*)(Quark.from_string (links.index (i).begin[j]) + TokenType.LAST));
for (var j = 0; j < links.index (i).end.length; ++j)
if (links.index (i).end[j].length > 1)
scanner.scope_add_symbol (0, links.index (i).end[j], (void*)(Quark.from_string (links.index (i).end[j]) + TokenType.LAST));
}
}
protected void build_tree (ref Node<uint> tokens, Array<Link> links, bool stop_tree) {
/* generate tokens table (tree) */
tokens = new Node<uint> ();
for (var i = 1; i < links.length; ++i) {
/* if current class has no begin tags */
if (!stop_tree && links.index (i).begin.length == 0
|| stop_tree && links.index (i).end.length == 0)
continue;
unowned Node<uint> parent_node = tokens;
unowned string[] symb_seq = stop_tree ? links.index (i).end: links.index (i).begin;
Quark symb_quark;
unowned Node child_node;
/* insert begin tags of all links into tree */
for (var j = 0; j < symb_seq.length; ++j) {
assert (symb_seq[j] != null && symb_seq.length != 0);
if (symb_seq[j].length > 1)
symb_quark = Quark.from_string(symb_seq[j]) + TokenType.LAST;
else
symb_quark = symb_seq[j][0];
child_node = parent_node.find_child (TraverseFlags.NON_LEAVES, symb_quark);
/* append node with symb_quark token */
if (child_node == null)
child_node = parent_node.append_data (symb_quark);
parent_node = child_node;
}
/* check for identical tokens lists and be shure that we create leaf for class id */
assert (parent_node.first_child () == null);
/* append leaf with class id */
parent_node.append_data (i);
}
}
protected void count_branches () {
if (in_child_params) {
switch (fifo_peek_head ().token) {
case TokenType.LEFT_CURLY:
case TokenType.LEFT_BRACE:
++child_param_branch_level;
break;
case TokenType.RIGHT_CURLY:
case TokenType.RIGHT_BRACE:
--child_param_branch_level;
break;
default:
break;
}
if (child_param_branch_level == 0
&& TokenType.LEFT_CURLY != fifo_peek_nth(1).token
&& TokenType.LEFT_BRACE != fifo_peek_nth(1).token)
in_child_params = false;
}
}
protected uint fifo_is_tag (Node<uint> tokens, out uint tag) {
uint match_length;
tag = 0;
/* search for tokens subsequence in tokens tree */
for (match_length = 0; ; ++match_length) {
if (tokens == null
|| TokenType.ERROR == fifo_peek_nth (match_length).token
|| TokenType.EOF == fifo_peek_nth (match_length).token) {
match_length = 0;
break;
}
tokens = tokens.find_child (TraverseFlags.NON_LEAVES,
fifo_peek_nth (match_length).token);
if (tokens != null && tokens.first_child().is_leaf()) {
tag = tokens.first_child().data;
++match_length;
break;
}
}
return match_length;
}
protected void fifo_pop () {
var ret = fifo_peek_head ();
if (ret.token != TokenType.ERROR && ret.token != TokenType.EOF)
symb_fifo.pop_head ();
}
protected SymbPos fifo_peek_head () {
if (symb_fifo.length == 0)
fifo_push ();
return symb_fifo.peek_head();
}
protected SymbPos fifo_peek_nth (uint n) {
unowned SymbPos ret;
while (n >= symb_fifo.length && fifo_push ());
if (n < symb_fifo.length)
ret = symb_fifo.peek_nth (n);
else
ret = symb_fifo.peek_tail ();
return ret;
}
bool fifo_push () {
var p = contents.offset (last_symb_pos.abspos);
scanner.get_next_token ();
if ('\\' == scanner.token) {
++back_slash_counter;
if (back_slash_counter % 4 == 0)
scanner.config.cpair_comment_single = "%\n";
else if (back_slash_counter % 2 == 0)
scanner.config.cpair_comment_single = null;
} else {
back_slash_counter = 0;
}
scanner.peek_next_token ();
if (scanner.token == TokenType.ERROR
|| scanner.token == TokenType.EOF) {
if (symb_fifo.length == 0) {
var sp = SymbPos ();
sp.token = scanner.token;
symb_fifo.push_tail (sp);
}
return false;
}
var sp = SymbPos ();
sp.token = scanner.token;
last_symb_pos.token = scanner.token;
sp.line = scanner.cur_line () - 1;
sp.pos = scanner.cur_position ();
sp.length = 1;
if (scanner.token > 255 && ((Quark)(scanner.token - TokenType.LAST)).to_string() != null) {
sp.length = ((Quark)(scanner.token - TokenType.LAST)).to_string().length;
sp.pos -= sp.length;
} else if (sp.pos != 0) {
--sp.pos;
}
last_symb_pos.length = sp.length;
/* current scanner's abspos evaluation */
while (last_symb_pos.line < sp.line
|| last_symb_pos.line == sp.line && last_symb_pos.pos < sp.pos) {
if ('\n' == p[0] || '\r' == p[0]) {
++last_symb_pos.line;
last_symb_pos.pos = 0;
} else {
++last_symb_pos.pos;
}
++last_symb_pos.abspos;
p = p.offset (1);
}
sp.abspos = last_symb_pos.abspos;
symb_fifo.push_tail (sp);
return true;
}
}
}
}