adobe-source-commits

[Foster B. <fos...@us...>]

Update of /cvsroot/adobe-source/sandbox/visual_refactor/adobe/source
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27679/adobe/source

Added Files:
	adam.cpp adam_evaluate.cpp adam_parser.cpp array.cpp 
	dictionary.cpp eve.cpp eve_engine.cpp eve_evaluate.cpp 
	eve_parser.cpp expression_parser.cpp expression_parser.hpp 
	istream.cpp lex_stream.cpp lex_stream.hpp lex_stream_fwd.hpp 
	metrowerks_mach_o.hpp name.cpp parse.cpp parse_pdf.cpp 
	parser_shared.cpp parser_shared.hpp rectangle.cpp 
	string_pool.cpp string_pool.hpp test_configuration.cpp 
	token.cpp token.hpp typeinfo.cpp value.cpp virtual_machine.cpp 
	xstr.cpp 
Log Message:
SO SORRY for the large qty of emails -- creating a branch for Adobe Begin refactoring.

--- NEW FILE: xstr.cpp ---
/*
	Copyright 2005 Adobe Systems Incorporated
	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
	or a copy at http://opensource.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#include <adobe/xstr.hpp>

#include <adobe/config.hpp>
#include <adobe/name.hpp>
#include <adobe/dictionary.hpp>
#include <adobe/once.hpp>
#include <adobe/algorithm.hpp>
#include <adobe/functional.hpp>

#include <vector>
#include <map>
[...1015 lines suppressed...]

	node_t::attribute_set_t::const_iterator	first(default_context_g->begin());
	node_t::attribute_set_t::const_iterator	last(default_context_g->end());

	for (; first != last; ++first)
		dict[first->first] = adobe::value_t(first->second);
	}

	return result;
}

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

ADOBE_ONCE_DEFINITION(xstr_once, init_xstr_once)

/*************************************************************************************************/

--- NEW FILE: adam_parser.cpp ---
/*
	Copyright 2005 Adobe Systems Incorporated
	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
	or a copy at http://opensource.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#include <utility>
#include <istream>
#include <sstream>
#include <iomanip>
#include <cassert>

#include <boost/bind.hpp>
#include <boost/array.hpp>

#include <adobe/once.hpp>
#include <adobe/array.hpp>
#include <adobe/name.hpp>
#include <adobe/value.hpp>
#include <adobe/dictionary.hpp>

#include <adobe/algorithm.hpp>
#include <adobe/source/token.hpp>

#include <adobe/adam_parser.hpp>
#include <adobe/source/expression_parser.hpp>
#include <adobe/adam.hpp>

/*************************************************************************************************/

/*
	TODO (sparent) : Changes to grammar -
*		1. input/output qualifiers go away - auto-detect qualification.
*		2. State cells go away.
*		3. non_reversible goes away (need to add some kind of idempotent check).
		4. Add relate clause
*		5. Question: Does "relation_set" go away? What are they for?
		6. The current relation sets should be renamed if they stay - what is in relate is a
			relation set.
		7. Need to add some way to declare validity predicate.
*		8. Question: Do "when" and "after" conditionals only apply to relate clauses?


For optional items ensure that if present - the following items are required.
after is currently not connected.

*/

/*************************************************************************************************/

namespace { void init_keyword_table(); }

ADOBE_ONCE_DECLARATION(adobe_adam_parser)
ADOBE_ONCE_DEFINITION(adobe_adam_parser, init_keyword_table)

/*************************************************************************************************/

namespace {

/*************************************************************************************************/

typedef boost::array<adobe::name_t, 10> keyword_table_t;

/*************************************************************************************************/

/*
	WARNING (sparent) : Initialization of these once_name_t items is defered until
	adam_parser::adam_parser().
*/

keyword_table_t*			keyword_table_g;
const adobe::once_name_t	input_k;
const adobe::once_name_t	output_k;
const adobe::once_name_t	interface_k;
const adobe::once_name_t	logic_k;
const adobe::once_name_t	constant_k;
const adobe::once_name_t	invariant_k;
const adobe::once_name_t	sheet_k;
const adobe::once_name_t	unlink_k;
const adobe::once_name_t	when_k;
const adobe::once_name_t	relate_k;

/*************************************************************************************************/

void init_keyword_table()
{
	adobe::remove_const(input_k)		= adobe::static_name_t("input");
	adobe::remove_const(output_k)		= adobe::static_name_t("output");
	adobe::remove_const(interface_k)	= adobe::static_name_t("interface");
	adobe::remove_const(logic_k)		= adobe::static_name_t("logic");
	adobe::remove_const(constant_k)		= adobe::static_name_t("constant");
	adobe::remove_const(invariant_k)	= adobe::static_name_t("invariant");
	adobe::remove_const(sheet_k)		= adobe::static_name_t("sheet");
	adobe::remove_const(unlink_k)		= adobe::static_name_t("unlink");
	adobe::remove_const(when_k)			= adobe::static_name_t("when");
	adobe::remove_const(relate_k)		= adobe::static_name_t("relate");

	static keyword_table_t keyword_table_s =
	{{
		input_k,
		output_k,
		interface_k,
		logic_k,
		constant_k,
		invariant_k,
		sheet_k,
		unlink_k,
		when_k,
		relate_k
	}};

	adobe::sort(keyword_table_s);

	keyword_table_g = &keyword_table_s;
}

/*************************************************************************************************/

bool keyword_lookup(const adobe::name_t& name)
{
	keyword_table_t::const_iterator	iter(adobe::lower_bound(*keyword_table_g, name));

	return (iter != keyword_table_g->end() && *iter == name);	
}

void once_instance()
{
	ADOBE_ONCE_INSTANCE(adobe_adam_parser);
}

/*************************************************************************************************/

} // namespace

/*************************************************************************************************/

/*************************************************************************************************/

namespace adobe {

/*************************************************************************************************/

/*! \page adam_grammar Adam Grammar

\code

translation_unit		= { sheet_specifier }.
sheet_specifier			= [lead_comment] "sheet" identifier "{" { qualified_cell_decl } "}" [trail_comment].

qualified_cell_decl		= interface_set_decl | input_set_decl | output_set_decl
							| constant_set_decl | logic_set_decl | invariant_set_decl.

interface_set_decl		= "interface"	":" { [lead_comment] interface_cell_decl }.
input_set_decl			= "input"		":" { [lead_comment] input_cell_decl }.
output_set_decl			= "output"		":" { [lead_comment] output_cell_decl }.
constant_set_decl		= "constant"	":" { [lead_comment] constant_cell_decl }.
logic_set_decl			= "logic"		":" { [lead_comment] logic_cell_decl }.
invariant_set_decl		= "invariant"	":" { [lead_comment] invariant_cell_decl }.

interface_cell_decl		= ["unlink"] identifier [initializer] [define_expression] end_statement.
input_cell_decl			= identifier [initializer] end_statement.

output_cell_decl		= named_decl.
constant_cell_decl		= identifier initializer end_statement.
logic_cell_decl			= named_decl | relate_decl.
invariant_cell_decl		= named_decl.

relate_decl				= [conditional] "relate" "{" relate_expression relate_expression { relate_expression } "}" [trail_comment].
relate_expression		= [lead_comment] named_decl.
named_decl				= identifier define_expression end_statement.

initializer				= ":" expression.
conditional				= "when" "(" expression ")".

define_expression		= "<==" expression.

end_statement			= ";" [trail_comment].

\endcode
*/

/*************************************************************************************************/

class adam_parser : private expression_parser
{
 public:
	adam_parser(std::istream& in, const line_position_t& position, const adam_callback_suite_t& callbacks);

	using expression_parser::require_expression; // Export is_expression for client
	
//	translation_unit = { sheet_specifier }.
	void parse();

 private:
	typedef adam_callback_suite_t::relation_t	relation_t;
	typedef std::vector<relation_t>				relation_set_t;

	adam_callback_suite_t						adam_callback_suite_m;

//	sheet_specifier = [lead_comment] "sheet" identifier "{" { qualified_cell_decl } "}" [trail_comment].
	bool is_sheet_specifier();
	
//	qualified_cell_decl		= interface_set_decl | input_set_decl | output_set_decl
//								| constant_set_decl | logic_set_decl | invariant_set_decl.
	bool is_qualified_cell_decl();

//	interface_set_decl		= "interface"	":" { [lead_comment] interface_cell_decl }.
	bool is_interface_set_decl();
//	input_set_decl			= "input"		":" { [lead_comment] input_cell_decl }.
	bool is_input_set_decl();
//	output_set_decl			= "output"		":" { [lead_comment] output_cell_decl }.
	bool is_output_set_decl();
//	constant_set_decl		= "constant"	":" { [lead_comment] constant_cell_decl }.
	bool is_constant_set_decl();
//	logic_set_decl			= "logic"		":" { [lead_comment] logic_cell_decl }.
	bool is_logic_set_decl();
//	invariant_set_decl		= "invariant"	":" { [lead_comment] invariant_cell_decl }.
	bool is_invariant_set_decl();
	
//	interface_cell_decl		= ["unlink"] identifier [initializer] [define_expression] end_statement.
	bool is_interface_cell_decl(const std::string& detailed);
//	input_cell_decl			= identifier [initializer] end_statement.
	bool is_input_cell_decl(const std::string& detailed);
//	output_cell_decl		= named_decl.
	bool is_output_cell_decl(const std::string& detailed);
//	constant_cell_decl		= identifier initializer end_statement.
	bool is_constant_cell_decl(const std::string& detailed);
//	logic_cell_decl			= named_decl | relate_decl.
	bool is_logic_cell_decl(const std::string& detailed);
//	invariant_cell_decl		= named_decl.
	bool is_invariant_cell_decl(const std::string& detailed);

//	relate_decl				= [conditional] "relate" "{" relate_expression relate_expression { relate_expression } "}" [trail_comment].
	bool is_relate_decl(line_position_t& position, array_t& expression, relation_set_t&, std::string&);
//	relate_expression		= [lead_comment] named_decl.
	bool is_relate_expression_decl(relation_t&);
//	named_decl				= identifier define_expression end_statement.
	bool is_named_decl(name_t& cell_name, line_position_t& position, array_t& expression, std::string&);

//	initializer				= ":" expression.
	bool is_initializer(line_position_t&, array_t& initializer);
//	conditional				= "when" "(" expression ")".
	bool is_conditional(line_position_t& position, array_t& expression);
//	define_expression		= "<==" expression.
	bool is_define_expression(line_position_t&, array_t&);
 
//	end_statement			= ";" [trail_comment].
	void require_end_statement(std::string& brief);
	
	typedef void (sheet_t::*sheet_add_t)(name_t, const relation_t&);
	typedef bool (adam_parser::*set_decl_t)(const std::string& detailed);

	bool is_logic_or_invariant_cell_decl(sheet_add_t);
	bool is_set_decl(name_t, set_decl_t);
};

/*************************************************************************************************/

adam_parser::adam_parser(std::istream& in, const line_position_t& position, const adam_callback_suite_t& callbacks) :
	expression_parser(in, position), adam_callback_suite_m(callbacks)
{
	once_instance();
	
	set_keyword_extension_lookup(boost::bind(&keyword_lookup, _1));
	
	assert(adam_callback_suite_m.add_cell_proc_m); 		// all callbacks are required.
	assert(adam_callback_suite_m.add_relation_proc_m);
	assert(adam_callback_suite_m.add_interface_proc_m);
}

/*************************************************************************************************/

void parse(std::istream& stream, const line_position_t& position, const adam_callback_suite_t& callbacks)
{
	adam_parser(stream, position, callbacks).parse();
}

/*************************************************************************************************/

array_t parse_adam_expression(const std::string& str_expression)
{
	once_instance();
	
	std::stringstream	expression_stream(str_expression);
	
	adobe::expression_parser parser(expression_stream, line_position_t("expression"));
	parser.set_keyword_extension_lookup(boost::bind(&keyword_lookup, _1));

	adobe::array_t expression;
	parser.require_expression(expression);
	
	return expression;
}

/*************************************************************************************************/

/*
	REVISIT (sparent) : sheets need to become copy-on-write and then this should return a list of
	sheets.
*/

void adam_parser::parse()
{
	while (is_sheet_specifier()) ;
	require_token(eof_k);
}

/*************************************************************************************************/

//	sheet_specifier = [lead_comment] "sheet" identifier "{" { qualified_cell_decl } "}" [trail_comment].
bool adam_parser::is_sheet_specifier()
{
	is_token(lead_comment_k);
	if (!is_token(sheet_k)) return false;
	require_token(identifier_k);
	require_token(open_brace_k);
	while (is_qualified_cell_decl()) { }
	require_token(close_brace_k);
	is_token(trail_comment_k);
	return true;
}

/*************************************************************************************************/

//	qualified_cell_decl		= interface_set_decl | input_set_decl | output_set_decl
//								| constant_set_decl | logic_set_decl | invariant_set_decl.
bool adam_parser::is_qualified_cell_decl()
{
	if (	is_interface_set_decl()
			|| is_input_set_decl()
			|| is_output_set_decl()
			|| is_constant_set_decl()
			|| is_logic_set_decl()
			|| is_invariant_set_decl())
	{
		return true;
	}
	
	return false;
}
	
/*************************************************************************************************/

//	interface_set_decl		= "interface"	":" { [lead_comment] interface_cell_decl }.
bool adam_parser::is_interface_set_decl()
{
	return is_set_decl(interface_k, &adam_parser::is_interface_cell_decl);
}
	
/*************************************************************************************************/
	
//	input_set_decl			= "input"		":" { [lead_comment] input_cell_decl }.
bool adam_parser::is_input_set_decl()
{
	return is_set_decl(input_k, &adam_parser::is_input_cell_decl);
}

/*************************************************************************************************/
	
//	output_set_decl			= "output"		":" { [lead_comment] output_cell_decl }.
bool adam_parser::is_output_set_decl()
{
	return is_set_decl(output_k, &adam_parser::is_output_cell_decl);
}

/*************************************************************************************************/
		
//	constant_set_decl		= "constant"	":" { [lead_comment] constant_cell_decl }.
bool adam_parser::is_constant_set_decl()
{
	return is_set_decl(constant_k, &adam_parser::is_constant_cell_decl);
}

/*************************************************************************************************/
	
//	logic_set_decl			= "logic"		":" { [lead_comment] logic_cell_decl }.
bool adam_parser::is_logic_set_decl()
{
	return is_set_decl(logic_k, &adam_parser::is_logic_cell_decl);
}

/*************************************************************************************************/
	
//	invariant_set_decl		= "invariant"	":" { [lead_comment] invariant_cell_decl }.
bool adam_parser::is_invariant_set_decl()
{
	return is_set_decl(invariant_k, &adam_parser::is_invariant_cell_decl);
}
	
/*************************************************************************************************/

//	interface_cell_decl		= ["unlink"] identifier [initializer] [define_expression] end_statement.
bool adam_parser::is_interface_cell_decl(const std::string& detailed)
{
	name_t 			cell_name;
	array_t			initializer, expression;
	line_position_t	initializer_position, expression_position;
	std::string		brief;

	bool linked (!is_token(unlink_k));
	
	if (!is_identifier(cell_name)) return false;
	
	(void)is_initializer(initializer_position, initializer);

	(void)is_define_expression(expression_position, expression);
	
	require_end_statement(brief);
		
	adam_callback_suite_m.add_interface_proc_m (cell_name, linked, initializer_position,
			initializer, expression_position, expression, brief, detailed);

	return true;
}
	
/*************************************************************************************************/

//	input_cell_decl			= identifier [initializer] end_statement.
bool adam_parser::is_input_cell_decl(const std::string& detailed)
{
	name_t 			cell_name;
	array_t			initializer;
	line_position_t	position;
	std::string		brief;
	
	if (!is_identifier(cell_name)) return false;
	
	(void)is_initializer(position, initializer);
	
	require_end_statement(brief);
	
	adam_callback_suite_m.add_cell_proc_m(adam_callback_suite_t::input_k, cell_name,
			position, initializer, brief, detailed);

	return true;
}
	
/*************************************************************************************************/

//	output_cell_decl		= named_decl.
bool adam_parser::is_output_cell_decl(const std::string& detailed)
{
	name_t			cell_name;
	line_position_t	position;
	array_t			expression;
	std::string		brief; // REVISIT (fbreret) do something with me

	if (!is_named_decl(cell_name, position, expression, brief)) return false;

	adam_callback_suite_m.add_cell_proc_m(adam_callback_suite_t::output_k, cell_name,
			position, expression, brief, detailed);

	return true;
}

/*************************************************************************************************/

//	constant_cell_decl		= identifier initializer end_statement.
bool adam_parser::is_constant_cell_decl(const std::string& detailed)
{
	name_t 			cell_name;
	line_position_t	position;
	array_t			initializer;
	std::string		brief;

	if (!is_identifier(cell_name)) return false;
	if (!is_initializer(position, initializer)) throw_exception("initializer required");
	require_end_statement(brief);

	adam_callback_suite_m.add_cell_proc_m(adam_callback_suite_t::constant_k, cell_name,
			position, initializer, brief, detailed);

	return true;
}
		
/*************************************************************************************************/

//	logic_cell_decl			= named_decl | relate_decl.
bool adam_parser::is_logic_cell_decl(const std::string& detailed)
{
	name_t 			cell_name;
	line_position_t	position;
	array_t			expression;
	std::string		brief;

	relation_set_t	relations;
	
	if (is_named_decl(cell_name, position, expression, brief))
	{
		adam_callback_suite_m.add_cell_proc_m(adam_callback_suite_t::logic_k, cell_name,
				position, expression, brief, detailed);
		return true;
	}
	else if (is_relate_decl(position, expression, relations, brief))
	{
		adam_callback_suite_m.add_relation_proc_m(	position, expression, &relations.front(),
													&relations.front() + relations.size(),
													brief, detailed);
		return true;
	}
	return false;
}
	
/*************************************************************************************************/

//	invariant_cell_decl		= named_decl.
bool adam_parser::is_invariant_cell_decl(const std::string& detailed)
{
	name_t			cell_name;
	line_position_t	position;
	array_t			expression;
	std::string		brief;

	if (!is_named_decl(cell_name, position, expression, brief)) return false;

	adam_callback_suite_m.add_cell_proc_m(adam_callback_suite_t::invariant_k, cell_name,
		position, expression, brief, detailed);

	return true;
}
	
/*************************************************************************************************/

//	relate_decl				= [conditional] "relate" "{" relate_expression relate_expression { relate_expression } "}" [trail_comment]
bool adam_parser::is_relate_decl(line_position_t& position, array_t& expression, relation_set_t& relation_set, std::string& brief)
{
	if (is_conditional(position, expression)) require_token(relate_k);
	else if (!is_token(relate_k)) return false;

	require_token(open_brace_k);

	relation_t relation_1;
	relation_t relation_2;

	if (!is_relate_expression_decl(relation_1) ||
		!is_relate_expression_decl(relation_2))
	{
		throw_exception("minimum two relate_expression required");
	}

	relation_set.push_back(relation_1);
	relation_set.push_back(relation_2);

	relation_1.expression_m.clear();
	while (is_relate_expression_decl(relation_1))
	{
		relation_set.push_back(relation_1);
		relation_1.expression_m.clear();
	}

	require_token(close_brace_k);

	(void)is_trail_comment(brief);

	return true;
}
	
/*************************************************************************************************/

//	relate_expression		= [lead_comment] named_decl.
bool adam_parser::is_relate_expression_decl(relation_t& relation)
{
	(void)is_lead_comment(relation.detailed_m);
	return is_named_decl(relation.name_m, relation.position_m, relation.expression_m, relation.brief_m);
}

/*************************************************************************************************/

//	named_decl				= identifier define_expression end_statement.
bool adam_parser::is_named_decl(name_t& cell_name, line_position_t& position, array_t& expression, std::string& brief)
{
	if (!is_identifier(cell_name)) return false;
	if (!is_define_expression(position, expression)) throw_exception("define_expression required"); 
	require_end_statement(brief);
	return true;
}
	
/*************************************************************************************************/

//	initializer				= ":" expression.
bool adam_parser::is_initializer(line_position_t& position, array_t& expression)
{
	if (!is_token(colon_k)) return false;
	
	position = next_position();
	require_expression(expression);

	return true;
}

/*************************************************************************************************/

//	define_expression		= "<==" expression.
bool adam_parser::is_define_expression(line_position_t& position, array_t& expression)
{
	if (!is_token(is_k)) return false;
	
	position = next_position();
	require_expression(expression);
	return true;
}

/*************************************************************************************************/

//	conditional = "when" "(" expression ")".

bool adam_parser::is_conditional(line_position_t& position, array_t& expression)
{
	if (!is_token(when_k)) return false;

	require_token(open_parenthesis_k);
	
	position = next_position();
	
	require_expression(expression);
	require_token(close_parenthesis_k);

	return true;
}

/*************************************************************************************************/

//	end_statement			= ";" [trail_comment].
void adam_parser::require_end_statement(std::string& brief)
{
	require_token(semicolon_k);
	(void)is_trail_comment(brief);
}
	
/*************************************************************************************************/

bool adam_parser::is_set_decl(name_t token, set_decl_t set_decl)
{
	if (!is_token(token)) return false;
	
	require_token(colon_k);

	while (true)
	{
		std::string detailed;
		(void)is_lead_comment(detailed);
		if (!(this->*set_decl)(detailed)) break;
	}
	
	return true;
}

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

--- NEW FILE: name.cpp ---
/*
	Copyright 2005 Adobe Systems Incorporated
	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
	or a copy at http://opensource.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#include <adobe/name.hpp>

#include <set>

#include <adobe/once.hpp>
#include <adobe/source/string_pool.hpp>

#if defined(ADOBE_SERIALIZATION)
#include <ostream>
#endif

/*************************************************************************************************/

ADOBE_GLOBAL_MUTEX_DEFINITION(name_t)

/*************************************************************************************************/

namespace {

/*************************************************************************************************/

struct str_less
{
	bool operator () (const char* x, const char* y) const
		{ return std::strcmp(x, y) < 0; }
};

/*************************************************************************************************/

// Precondition: length only need be non-zero if not copying
// Precondition: if string_name is null - length must be zero
const char* unique_string(const char* string_name, std::size_t length, bool copy)
{
	typedef std::set<const char*, str_less> name_store_t;
	
	static const char* empty_string_s = "";

	if (length == 0) return empty_string_s;
	
	ADOBE_GLOBAL_MUTEX_INSTANCE(name_t);

	static name_store_t			name_store_s;
	static adobe::string_pool	string_pool_s;

	name_store_t::iterator iter = name_store_s.find(string_name);

	if (iter == name_store_s.end())
	{
		if (copy) string_name = string_pool_s.add(string_name, length);

		iter = name_store_s.insert(string_name).first;
	}

	return *iter;
}

/*************************************************************************************************/

} // namespace

/*************************************************************************************************/

namespace adobe {

/*************************************************************************************************/

name_t::name_t (const char* string_name)
{
	std::size_t length = (string_name && *string_name) ? std::strlen(string_name) : 0;

	name_m = unique_string(string_name, length, true);
}

/*************************************************************************************************/

name_t::name_t (const char* string_name, std::size_t length)
{
	name_m = unique_string(string_name, length, true);
}

/*************************************************************************************************/

name_t::name_t (const char* string_name, dont_copy_t)
{
	// length only needs to be non-zero since we aren't copying
	std::size_t length = (string_name && *string_name) ? std::size_t(1) : 0;
	name_m = unique_string(string_name, length, false);
}

/*************************************************************************************************/

#if defined(ADOBE_SERIALIZATION)

std::ostream& operator << (std::ostream& os, const adobe::name_t& t)
{
	os << t.get();
	return os;
}

#endif

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

--- NEW FILE: eve_engine.cpp ---

--- NEW FILE: parser_shared.hpp ---
/*
	Copyright 2005 Adobe Systems Incorporated
	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
	or a copy at http://opensource.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#ifndef ADOBE_PARSER_SHARED_HPP
#define ADOBE_PARSER_SHARED_HPP

/*************************************************************************************************/

#include <adobe/istream_fwd.hpp>
#include <adobe/name_fwd.hpp>

/*************************************************************************************************/

namespace adobe {

/*************************************************************************************************/

void throw_parser_exception(const char* errorString, const adobe::line_position_t& position);
void throw_parser_exception(adobe::name_t expected, adobe::name_t found,
		const adobe::line_position_t& position);

/*************************************************************************************************/

} // namespace adobe

/*************************************************************************************************/

#endif // ADOBE_PARSER_SHARED_HPP

/*************************************************************************************************/

--- NEW FILE: token.hpp ---
/*
	Copyright 2005 Adobe Systems Incorporated
	Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
	or a copy at http://opensource.adobe.com/licenses.html)
*/

/*************************************************************************************************/

#include <adobe/name_fwd.hpp>
#include <adobe/once.hpp>

/*************************************************************************************************/

ADOBE_ONCE_DECLARATION(adobe_token)
ADOBE_ONCE_STATIC_INSTANCE(adobe_token)

/*************************************************************************************************/

namespace adobe {

/*************************************************************************************************/

extern const once_name_t ifelse_k;

extern const once_name_t number_k;
extern const once_name_t identifier_k;
extern const once_name_t string_k;
extern const once_name_t lead_comment_k;
extern const once_name_t trail_comment_k;

extern const once_name_t semicolon_k;
extern const once_name_t comma_k;
extern const once_name_t assign_k;
extern const once_name_t question_k;
extern const once_name_t colon_k;
extern const once_name_t open_brace_k;
extern const once_name_t close_brace_k;
extern const once_name_t open_parenthesis_k;
extern const once_name_t close_parenthesis_k;
extern const once_name_t dot_k;
extern const once_name_t open_bracket_k;
extern const once_name_t close_bracket_k;
extern const once_name_t at_k;
extern const once_name_t is_k;

extern const once_name_t add_k;
extern const once_name_t subtract_k;
extern const once_name_t multiply_k;
extern const once_name_t divide_k;
extern const once_name_t modulus_k;

extern const once_name_t not_k;
extern const once_name_t unary_negate_k;

extern const once_name_t less_k;
extern const once_name_t greater_k;

extern const once_name_t and_k;
extern const once_name_t or_k;
extern const once_name_t less_equal_k;
extern const once_name_t greater_equal_k;
extern const once_name_t not_equal_k;
extern const once_name_t equal_k;

extern const once_name_t empty_k;
extern const once_name_t true_k;
extern const once_name_t false_k;

e...
 
[truncated message content]