bugfix: comments weren't discarded in "derive" line

1 files changed, 1 insertions, 1 deletions

diff --git a/lib/sitecing_parser.ll b/lib/sitecing_parser.ll
index 9514ce4..4fd6709 100644
--- a/lib/sitecing_parser.ll
+++ b/lib/sitecing_parser.ll
@@ -63,580 +63,580 @@ NOIDCHAR	[^A-Za-z0-9_]
 	anchor();
 	BEGIN(VARLINE);
     }
     ^\%\%import{WHITESPACE}+	{
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	BEGIN(IMPORTLINE);
     }
     ^\%\%import_type{WHITESPACE}+ {
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	BEGIN(IMPORTTYPELINE);
     }
     ^\%\%derive{WHITESPACE}+	{
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	BEGIN(DERIVELINE);
     }
     \<\%constructor\>	{
 	modi.push_front(modus_operandi());
 	anchor();
 	BEGIN(CONSTRUCTOR);
     }
     \<\%destructor\>	{
 	modi.push_front(modus_operandi());
 	anchor();
 	BEGIN(DESTRUCTOR);
     }
     \<\%codemethod{WHITESPACE}+	{
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	anchor();
 	BEGIN(CODEMETHODLINE);
     }
     \<\%method{WHITESPACE}+ {
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	anchor();
 	BEGIN(METHODLINE);
     }
     ^\%\%pragma{WHITESPACE}+	{
 	modi.push_front(modus_operandi(modus_operandi::flag_devour_comments));
 	BEGIN(PRAGMALINE);
     }
     <<EOF>>	{
 	assert(modi.size()==1);
 	M().modify(modus_operandi::modus_preop);
 	LexerOutput(";",1);
 	return 0;
     }
 }
 <<EOF>>	throw preprocessor_error(CODEPOINT,"unexpected end of file",lineno());
 
 <CODEBLOCK,CODEMETHODBLOCK>{
     "<%output>"	{
 	anchor();
 	yy_push_state(OUTPUTBLOCK);
     }
 }
 
 <PRAGMALINE>{
     {WHITESPACE}+	{
 	modus_operandi& m = M();
 	if(!m.output.empty()) {
 	    string::size_type eq = m.output.find('=');
 	    if(eq==string::npos) {
 		pragmas[m.output]=m.output;
 	    }else{
 		pragmas[m.output.substr(0,eq)] = m.output.substr(eq+1);
 	    }
 	    m.output.erase();
 	}
     }
     \n			{
 	modus_operandi& m = M();
 	if(!m.output.empty()) {
 	    string::size_type eq = m.output.find('=');
 	    if(eq==string::npos) {
 		pragmas[m.output]=m.output;
 	    }else{
 		pragmas[m.output.substr(0,eq)] = m.output.substr(eq+1);
 	    }
 	    m.output.erase();
 	}
 	modi.pop_front();
 	BEGIN(INITIAL);
 	anchor();
     }
 }
 
 <METHODLINE>{
     {WHITESPACE}+	{
 	modus_operandi& m = M();
 	if(!m.output.empty()) {
 	    if(!m._lastid.empty()) {
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._lastid = m.output;
 	    m.output.clear();
 	}
     }
     \*	{
 	modus_operandi& m = M();
 	ECHO;
 	if(!m._lastid.empty()) {
 	    if(!m._type.empty()) m._type += ' ';
 	    m._type += m._lastid;
 	}
 	m._lastid = m.output;
 	m.output.clear();
     }
     \(	{
 	modus_operandi& m = M();
 	if(m.output.empty()) {
 	    m._name=m._lastid;
 	}else{
 	    if(!m._lastid.empty()) { // XXX: lastid, I believe should never be emtpy...
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._name = m.output;
 	    m.output.clear();
 	}
 	ECHO;
 	BEGIN(METHODARGS);
     }
 }
 <METHODARGS>{
     \%\>	{
 	modus_operandi& m = M();
 	m._args = m.output;
 	m.output.clear();
 	anchor();
 	BEGIN(METHODBLOCK);
     }
 }
 
 <INITIAL,METHODBLOCK,OUTPUTBLOCK>{
     \<\%{WHITESPACE}+	{
 	M().modify(modus_operandi::modus_postop);
 	anchor();
 	LexerOutput("(",1);
 	yy_push_state(INLINE);
     }
     ^\%{WHITESPACE}	{
 	M().modify(modus_operandi::modus_code);
 	anchor();
 	yy_push_state(CODELINE);
     }
     \<\%code\>	{
 	M().modify(modus_operandi::modus_code);
 	anchor();
 	yy_push_state(CODEBLOCK);
     }
     "</%output>" {
 	if(YY_START!=OUTPUTBLOCK) throw preprocessor_error(CODEPOINT,"unexpected tag",lineno());
 	M().modify(modus_operandi::modus_code);
 	anchor();
 	yy_pop_state();
     }
 }
 
 <INLINE>\%\>	LexerOutput(")",1); M().modus=modus_operandi::modus_preop; yy_pop_state();
 <CODELINE>\n	yy_pop_state();
 
 <CODEMETHODLINE>{
     {WHITESPACE}+	{
 	modus_operandi& m = M();
 	if(!m.output.empty()) {
 	    if(!m._lastid.empty()) {
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._lastid = m.output;
 	    m.output.clear();
 	}
     }
     \*	{
 	modus_operandi& m = M();
 	ECHO;
 	if(!m._lastid.empty()) {
 	    if(!m._type.empty()) m._type += ' ';
 	    m._type += m._lastid;
 	}
 	m._lastid = m.output;
 	m.output.clear();
     }
     \(	{
 	modus_operandi& m = M();
 	if(m.output.empty()) {
 	    m._name=m._lastid;
 	}else{
 	    if(!m._lastid.empty()) { // XXX: lastid, I believe should never be emtpy...
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._name = m.output;
 	    m.output.clear();
 	}
 	ECHO;
 	BEGIN(CODEMETHODARGS);
     }
 }
 <CODEMETHODARGS>{
     \%\>	{
 	modus_operandi& m = M();
 	m._args = m.output;
 	m.output.clear();
 	m.flags=0;
 	anchor();
 	BEGIN(CODEMETHODBLOCK);
     }
 }
 
 <IMPORTLINE>{
     {WHITESPACE}+	{ }
     {ID}	{
 	modus_operandi& m = M();
 	if(!m._name.empty())
 	    throw preprocessor_error(CODEPOINT,"syntax error",lineno());
 	m._name = yytext;
     }
     \=		{
 	M().output.clear();
 	BEGIN(IMPORTCOMPONENT);
     }
 }
 <IMPORTCOMPONENT>{
     {WHITESPACE}+	{ }
     \n	{
 	modus_operandi& m = M();
 	string::size_type t = m.output.find_first_not_of(" \t");
 	if(t!=string::npos)
 	    m.output.erase(0,t);
 	t = m.output.find_last_not_of(" \t;");
 	if(t!=string::npos)
 	    m.output.erase(t+1);
 	if(m.output[0]=='"' && m.output[m.output.length()-1]=='"') {
 	    m.output.erase(0,1);
 	    m.output.erase(m.output.length()-1);
 	}
 	string c = combine_path(component_basename,m.output);
 	member_variables.push_back(member_variable(m._type,m._name,normalize_path(c,strip_leading_slash),true));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
 }
 
 <IMPORTTYPELINE>{
     {WHITESPACE}+	{ }
     {ID}	{
 	modus_operandi& m = M();
 	if(!m._name.empty())
 	    throw preprocessor_error(CODEPOINT,"syntax error",lineno());
 	m._name = yytext;
     }
     \=		{
 	M().output.clear();
 	BEGIN(IMPORTTYPECOMPONENT);
     }
 }
 <IMPORTTYPECOMPONENT>{
     {WHITESPACE}+	{ }
     \n	{
 	modus_operandi& m = M();
 	string::size_type t = m.output.find_first_not_of(" \t");
 	if(t!=string::npos)
 	    m.output.erase(0,t);
 	t = m.output.find_last_not_of(" \t;");
 	if(t!=string::npos)
 	    m.output.erase(t+1);
 	if(m.output[0]=='"' && m.output[m.output.length()-1]=='"') {
 	    m.output.erase(0,1);
 	    m.output.erase(m.output.length()-1);
 	}
 	string c = combine_path(component_basename,m.output);
 	member_variables.push_back(member_variable(m._type,m._name,normalize_path(c,strip_leading_slash),true,true));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
 }
 
 <DERIVELINE>{
     {WHITESPACE}+	{ }
     {ID}	{
 	modus_operandi& m = M();
 	if(!m._name.empty())
 	    throw preprocessor_error(CODEPOINT,"syntax_error",lineno());
 	m._name = yytext;
     }
     \=		{
 	M().output.clear();
 	BEGIN(DERIVECOMPONENT);
     }
 }
 <DERIVECOMPONENT>{
     {WHITESPACE}+	{ }
     \n {
 	modus_operandi& m = M();
 	string::size_type t = m.output.find_first_not_of(" \t");
 	if(t!=string::npos)
 	    m.output.erase(0,t);
 	t = m.output.find_last_not_of(" \t;");
 	if(t!=string::npos)
 	    m.output.erase(t+1);
 	if(m.output[0]=='"' && m.output[m.output.length()-1]=='"') {
 	    m.output.erase(0,1);
 	    m.output.erase(m.output.length()-1);
 	}
 	string c = combine_path(component_basename,m.output);
 	ancestor_classes.push_back(ancestor_class(m._name,normalize_path(c,strip_leading_slash)));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
 }
 
 <VARLINE>{
     {WHITESPACE}+	{
 	modus_operandi& m = M();
 	if(!m.output.empty()) {
 	    if(!m._lastid.empty()) {
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._lastid = m.output;
 	    m.output.clear();
 	}
     }
     \*	{
 	modus_operandi& m = M();
 	ECHO;
 	if(!m._lastid.empty()) {
 	    if(!m._type.empty()) m._type += ' ';
 	    m._type += m._lastid;
 	}
 	m._lastid = m.output;
 	m.output.clear();
     }
     \;|\n|\=	{
 	modus_operandi& m = M();
 	if(m.output.empty()) {
 	    m._name=m._lastid;
 	}else{
 	    if(!m._lastid.empty()) { // XXX: lastid should never be emtpy, I believe?
 		if(!m._type.empty()) m._type += ' ';
 		m._type += m._lastid;
 	    }
 	    m._name=m.output;
 	    m.output.clear();
 	}
 	BEGIN(VARINIT);
 	if(*yytext!='=')
 	    unput('\n');
     }
 }
 <VARINIT>{
     \n	{
 	modus_operandi& m = M();
 	string::size_type t = m.output.find_first_not_of(" \t");
 	if(t!=string::npos)
 	    m.output.erase(0,t);
 	t = m.output.find_last_not_of(" \t;");
 	if(t!=string::npos)
 	    m.output.erase(t+1);
 	member_variables.push_back(member_variable(m._type,m._name,m.output));
 	if(!m.output.empty())
 	    have_initializers=true;
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
 }
 <DECLLINE>\n	{
     ECHO;
     decl += M().output;
     modi.pop_front();
     BEGIN(INITIAL);
 }
 <IMPLLINE>\n	{
     ECHO;
     impl += M().output;
     modi.pop_front();
     BEGIN(INITIAL);
 }
 <CLASSLINE>\n	{
     class_name = M().output;
     modi.pop_front();
     BEGIN(INITIAL);
 }
-<CLASSLINE,DECLLINE,IMPLLINE,VARLINE,VARINIT,IMPORTLINE,IMPORTCOMPONENT,CODEMETHODLINE,CODEMETHODARGS,INLINE,METHODLINE,METHODARGS,DECLBLOCK,IMPLBLOCK,CONSTRUCTOR,DESTRUCTOR,CODEMETHODBLOCK,CODELINE,CODEBLOCK,PRAGMALINE>{
+<CLASSLINE,DECLLINE,IMPLLINE,VARLINE,VARINIT,IMPORTLINE,IMPORTCOMPONENT,CODEMETHODLINE,CODEMETHODARGS,INLINE,METHODLINE,METHODARGS,DECLBLOCK,IMPLBLOCK,CONSTRUCTOR,DESTRUCTOR,CODEMETHODBLOCK,CODELINE,CODEBLOCK,PRAGMALINE,DERIVELINE,DERIVECOMPONENT>{
     "/*"	{
 	yy_push_state(SLASHSTAR_COMMENT);
 	if(!M().devour_comments()) {
 	    ECHO;
 	}
     }
     "//"	{
 	yy_push_state(SLASHSLASH_COMMENT);
 	if(!M().devour_comments()) {
 	    ECHO;
 	}
     }
     \"		{
 	yy_push_state(STRING);
     	ECHO;
     }
     \'\\.\'	{
 	ECHO;
     }
 }
 
 <INITIAL,METHODBLOCK,OUTPUTBLOCK>{
     \"	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\\"",2);
     \n	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\n",2);
     \r	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\r",2);
     \t	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\t",2);
     \b	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\b",2);
     \a	soft_anchor(); M().modify(modus_operandi::modus_text); LexerOutput("\\a",2);
     .	soft_anchor(); M().modify(modus_operandi::modus_text); ECHO;
     {WHITESPACE}+	soft_anchor(); M().modify(modus_operandi::modus_text); ECHO;
 }
 
 <DECLBLOCK,IMPLBLOCK,CONSTRUCTOR,DESTRUCTOR,CODEMETHODBLOCK,METHODBLOCK,CODEBLOCK>{
     \<\/\%decl\>	{
 	if(YY_START!=DECLBLOCK) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	decl += M().output;
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/\%impl\>	{
 	if(YY_START!=IMPLBLOCK) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	impl += M().output;
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/\%constructor\>	{
 	if(YY_START!=CONSTRUCTOR) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	member_functions.push_back(member_function("","","",M().output));
 	have_constructor = true;
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/\%destructor\>	{
 	if(YY_START!=DESTRUCTOR) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	member_functions.push_back(member_function("","~","",M().output));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/\%codemethod\>	{
 	if(YY_START!=CODEMETHODBLOCK) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	modus_operandi& m = M();
 	member_functions.push_back(member_function(m._type,m._name,m._args,m.output));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/%method\> {
 	if(YY_START!=METHODBLOCK) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	modus_operandi& m = M();
 	m.modify(modus_operandi::modus_code);
 	member_functions.push_back(member_function(m._type,m._name,m._args,m.output));
 	modi.pop_front();
 	BEGIN(INITIAL);
     }
     \<\/%code\> {
 	if(YY_START!=CODEBLOCK) throw preprocessor_error(CODEPOINT,"tags mismatch",lineno());
 	yy_pop_state();
     }
     \n		ECHO;
 }
 
 <SLASHSTAR_COMMENT>{
     "*/"	{
 	if(!M().devour_comments()) {
 	    ECHO;
 	}
 	yy_pop_state();
 	unput(' ');
     }
     \n	{
 	if(!M().devour_comments()) {
 	    ECHO;
 	}
     }
 }
 <SLASHSLASH_COMMENT>{
     \n	{
 	if(!M().devour_comments()) {
 	    ECHO;
 	}
 	yy_pop_state();
 	if(YY_START!=CODEBLOCK && YY_START!=CODEMETHODBLOCK && YY_START!=IMPLBLOCK && YY_START!=DECLBLOCK)
 	    unput('\n');
     }
 }
 <SLASHSTAR_COMMENT,SLASHSLASH_COMMENT>.	{
     if(!M().devour_comments()) {
 	ECHO;
     }
 }
 <STRING>{
     \\.	ECHO;
     \"	ECHO; yy_pop_state();
     .	ECHO;
 }
 
 {WHITESPACE}+	{
     if(!(M().flags&modus_operandi::flag_devour_whitespace)) {
 	ECHO;
     }
 }
 
 %%
 
 sitecing_parser::sitecing_parser(component_factory& f)
     : factory(f), have_initializers(false), have_constructor(false),
     base_class("sitecing::cgi_component"),
     base_header("sitecing/cgi_component.h"),
     skeleton(__SC_DEFAULT_SKELETON) {
     }
 
 void sitecing_parser::preprocess(const string& in) {
     ifstream ifs(in.c_str(),ios::in);
     if(!ifs.good())
 	throw preprocessor_error(CODEPOINT,"failed to open input file");
     input_file = in;
     modi.push_front(modus_operandi(0));
     switch_streams(&ifs,NULL);
     if(yylex())
 	throw preprocessor_error(CODEPOINT,"unknown error");
     pragmas_t::const_iterator mp = pragmas.find("main");
     if(mp==pragmas.end()) {
 	member_functions.push_back(member_function("void","main","(int _magic,va_list _args)",M().output));
     }else{
 	member_functions.push_back(
 	    member_function(
 		"void","main","(int _magic,va_list _args)",
 		mp->second+"::main(_magic,_args);"
 	    )
 	);
     }
     if(have_initializers && !have_constructor)
 	member_functions.push_back(member_function("","","",""));
     sitecing_enflesher enflesher(*this);
     enflesher.enflesh();
 }
 
 void sitecing_parser::LexerOutput(const char* buf,int size) {
     assert(modi.size());
     M().output.append(buf,size);
 }
 
 static const char *modus_transitions
     [sitecing_parser::modus_operandi::modi]
     [sitecing_parser::modus_operandi::modi] = {
 // To:
 // code   preop               postop                text                         From:
  { "",    "(*(__SCIF->out))", "(*(__SCIF->out))<<", "(*(__SCIF->out))<<\"" }, // code
  { ";",   "",                 "<<",                 "<<\""                 }, // preop
  { NULL,  NULL,               "",                   "\""                   }, // postop
  { "\";", "\"",               "\"<<",               ""                     }  // text
 };
 
 void sitecing_parser::modus_operandi::modify(modus_t m) {
     const char * x = modus_transitions[modus][m];
     assert(x);
     output += x;
     modus = m;
 }
 
 void sitecing_parser::soft_anchor() {
     if(M().modus!=modus_operandi::modus_text)
 	anchor();
 }
 void sitecing_parser::anchor() {
     if(M().modus==modus_operandi::modus_text)
 	M().modify(modus_operandi::modus_preop);
     M().output += "\n#line ";
     char tmp[7];
     snprintf(tmp,sizeof(tmp),"%d",lineno());
     M().output += tmp;
     M().output += " \"";
     M().output += input_file;
     M().output += "\"\n";
 }
 /* vim:set ft=lex: */