cppcms_tmpl_cc

C++ web POSIX framewark

	def on_end(self):
		output( "} // end of empty")
		global tmpl_seq
		del tmpl_seq[self.ident]


class else_block:
	pattern=r'^<%\s*else\s*%>$'
	type='else'
	def on_end(self):
		output("}")
	def use(self,m):
		prev=stack.pop()
		if prev.type!='if' and prev.type!='elif':
			error_exit("elif without if");
		output( "}else{")
		stack.append(self)

class if_block:
	pattern=r'^<%\s*(if|elif)\s+((not\s+|not\s+empty\s+|empty\s+)?('+variable_match+')|\((.+)\)|)\s*%>$'
	type='if'
	def prepare(self):
		output( "if(%s) {" % self.ident)

	def on_end(self):
		output( "} // endif")

	def use(self,m):
		global stack
		self.type=m.group(1)
		if m.group(4):
			if m.group(4)=='rtl':
				self.ident='(std::strcmp(tr->gettext("LTR"),"RTL")==0)'
			else:
				self.ident=make_ident(m.group(4))
			if m.group(3):
				if re.match('.*empty',m.group(3)):
					self.ident=self.ident + '.empty()'
				if re.match('not.*',m.group(3)):
					self.ident="!("+self.ident+")"
		else:
			self.ident=m.group(10)
		if self.type == 'if' :
			self.prepare()
			stack.append(self)
		else: # type == elif
			if stack :
				prev=stack.pop()
				if prev.type!='if' and prev.type!='elif':
					error_exit("elif without if");
				output( "}")
				output( "else")
				self.prepare()
				stack.append(self)
			else:
				error_exit("Unexpeced elif");
# END ifop				
			

class end_block:
	pattern=r'^<%\s*end(\s+(\w+))?\s*%>';
	def use(self,m):
		global stack
		if not stack:
			error_exit("Unexpeced 'end'");
		else:
			obj=stack.pop();
			if m.group(1):
				if obj.type!=m.group(2):
					error_exit("End of %s does not match block %s" % (m.group(2) , obj.type));
			obj.on_end()

class error_com:
	pattern=r'^<%(.*)%>$'
	def use(self,m):
		error_exit("unknown command `%s'" % m.group(1))


class cpp_include_block:
	pattern=r'^<%\s*c\+\+\s+(.*)%>$'
	def use(self,m):
		output( m.group(1));


class base_show:
	mark='('+variable_match+r')\s*(\|(.*))?'
	base_pattern='^\s*'+mark + '$'
	def get_params(self,s):
		pattern='^\s*(('+variable_match+')|('+str_match+')|(\-?\d+(\.\d*)?))\s*(,(.*))?$'
		res=[]
		m=re.match(pattern,s)
		while m:
			if m.group(2):
				res.append(make_ident(m.group(2)))
			elif m.group(8):
				res.append(m.group(8))
			elif m.group(10):
				res.append(m.group(10))
			if m.group(13):
				s=m.group(13)
				m=re.match(pattern,s)
			else:
				return res
		error_exit("Invalid parameters: `%s'" % s )
		return []
	def prepare(self,s):
		m=re.match(self.base_pattern,s)
		if not m:
			error_exit("No variable")
			return [];
		var=make_ident(m.group(1))
		if not m.group(8):
			return "escape(%s)" % var
		filters=m.group(8)
		expr='^\s*(ext\s+)?(\w+)\s*(\((([^"\)]|'+str_match + ')*)\))?\s*(\|(.*))?$'
		m=re.match(expr,filters)
		while m:
			if m.group(1):
				func="content."+m.group(2)
			else:
				func=m.group(2)
			if m.group(3):
				params=','.join([var]+self.get_params(m.group(4)))
			else:
				params=var
			var=func+"("+params+")"
			if m.group(8):
				filters=m.group(8)
				m=re.match(expr,filters)
			else:
				return var
		error_exit("Seems to be a problem in expression %s" % filters)
		return "";

class form_block:
	pattern=r'^<%\s*form\s+(((as_p|as_table|as_ul|as_dl|as_space)(\s+no\s+error)?)|error|input)\s+('\
		 + variable_match +')\s*%>'
	def use(self,m):
		ident=make_ident(m.group(5))
		global html_type_code
		if m.group(1)=='error':
			output('cout<<%s.render_error();' % ident)
		elif m.group(1)=='input':
			output('cout<<%s.render_input(%s);' % ( ident , html_type_code ));
		else:
			html_code='cppcms::base_form::' + m.group(3)
			if m.group(4):
				html_code=html_code + '|cppcms::base_form::error_no';
			output('cout<<%s.render(%s);' % (ident , html_code + '|' + html_type_code))



class filters_show_block(base_show):
	pattern=r'^<%\s*('+ variable_match + r'\s*(\|.*)?)%>$'
	def use(self,m):
		expr=self.prepare(m.group(1));
		if expr!="":
			output('cout<<%s;' % expr)

def make_format_params(s):
	pattern=r'^(([^,\("]|'+str_match+'|\(([^"\)]|'+str_match+')*\))+)(,(.*))?$'
	params=[]
	m=re.match(pattern,s)
	s_orig=s
	while m.group(1):
		res=base_show().prepare(m.group(1))
		if res:
			params.append(res)
		if not m.group(6):
			return params
		s=m.group(7)
		m=re.match(pattern,s)
	error_exit("Seems to be wrong parameters list [%s]" % s_orig)
	return []

class ngettext_block:
	pattern=r'^<%\s*ngt\s*('+str_match+')\s*,\s*('+str_match+')\s*,\s*('+variable_match+')\s*(using(.*))?\s*%>$'
	def use(self,m):
		s1=m.group(1)
		s2=m.group(3)
		idt=make_ident(m.group(5))
		params=[]
		if m.group(11):
			params=make_format_params(m.group(12))
		if not params:
			output( "cout<<tr->ngettext(%s,%s,%s);" % (s1,s2,idt))
		else:
			output( "cout<<(format(tr->ngettext(%s,%s,%s)) %% %s );" % (s1,s2,idt, ' % '.join(params)))
			

class gettext_block:
	pattern=r'^<%\s*gt\s*('+str_match+')\s*(using(.*))?\s*%>$'
	def use(self,m):
		s=m.group(1)
		params=[]
		if m.group(3):
			params=make_format_params(m.group(4))
		if not params:
			output( "cout<<tr->gettext(%s);" % s)
		else:
			output( "cout<<(format(tr->gettext(%s)) %% %s );" % (s , ' % '.join(params)))


class include_block:
	pattern=r'^<%\s*include\s+([a-zA_Z]\w*(::\w+)?)\s*\(\s*(.*)\)\s*%>$';
	def use(self,m):
		if m.group(3):
			params=base_show().get_params(m.group(3))
		else:
			params=[]
		output( "%s(%s);" % (m.group(1) , ','.join(params)))

def fetch_content(content):
	tmp=''
	for row in re.split('\n',content):
		global line_number
		global file_name
		line_number+=1
		l1=re.split(r'<%([^"%]|"([^"\\]|\\[^"]|\\")*"|%[^>])*%>',row)
		n=0
		for l2 in re.finditer(r'<%([^"%]|"([^"\\]|\\[^"]|\\")*"|%[^>])*%>',row):
			yield tmp+l1[n]
			tmp=''
			yield l2.group(0)
			n+=3
		tmp+=l1[n]+'\n'
	yield tmp

def help():
	print	"Usage cppcms_tmpl_cc [-o filename.cpp] [-n namespace] [-d domain] file1.tmpl ... \n" \
		"      -o filename.cpp     file name that implements this template\n" \
		"      -n namespace        setup namespace for template\n" \
		"      -d domain           setup gettext domain for this template\n" \
		"      -h/--help           show this help message\n"


	

def main():
	global stack
	all=[]
	indx=1
	global namespace_name
	global output_file
	global exit_flag
	while indx < len(os.sys.argv):
		if os.sys.argv[indx]=='-n':
			if indx+1>=len(os.sys.argv):
				sys.stderr.write("-n should be followed by namespace name\n")
				help()
				exit_flag=1
				return
			else:
				namespace_name=os.sys.argv[indx+1];
				indx+=1
		elif os.sys.argv[indx]=='-o':
			if indx+1>=len(os.sys.argv):
				sys.stderr.write("-o should be followed by output file name\n")
				help()
				exit_flag=1
				return
			else:
				output_file=os.sys.argv[indx+1]
				indx+=1
		elif os.sys.argv[indx]=='-d':
			if indx+1>=len(os.sys.argv):
				sys.stderr.write("-d should followed by gettext domain name\n")
				help()
				exit_flag=1
				return
			else:
				global spec_gettext
				spec_gettext=os.sys.argv[indx+1]
				indx+=1

		elif os.sys.argv[indx]=='--help' or os.sys.argv[indx]=='-h':
			help()
			exit_flag=1
			return
		else:
			all.append(os.sys.argv[indx])
		indx+=1
	if not all:
		sys.stderr.write("No input file names given\n")
		help()
		exit_flag=1
		return
	global output_fd
	if output_file!='':
		output_fd=open(output_file,"w")
	for file in all:
		global file_name
		global line_number
		line_number=0
		file_name=file
		f=open(file,'r')
		content=f.read()
		f.close()
		for x in fetch_content(content):
			if x=='' : continue
			if len(stack)==0:
				if re.match(r"^\s*$",x):
					continue
				elif not re.match(r"<\%.*\%>",x):
					error_exit("Content is not allowed outside template blocks")
					continue
			matched=0
			for c in [	namespace_block(), class_block(), if_block(), template_block(), end_block(), else_block(), \
					cpp_include_block(),\
					gettext_block(),ngettext_block(),\
					foreach_block(), item_block(), empty_block(),separator_block(),\
					include_block(),\
					html_type(), form_block(), \
					filters_show_block(), error_com()]:
				m = re.match(c.pattern,x)
				if m :
					c.use(m)
					matched=1
					break
			if not matched:
				inline_content(x)


		if stack:
			error_exit("Unexpected end of file %s" % file)
	global class_list
	if class_list and exit_flag==0:
		write_class_loader()

#######################
# MAIN
#######################


html_type_code='cppcms::base_form::as_html'
output_file=''
output_fd=sys.stdout
namespace_name=''
file_name=''
labels_counter=0
tmpl_seq={}
template_parameters={}
templates_map={}
parameters_counter=2
stack=[]
class_list=[]
exit_flag=0
current_template=''
spec_gettext=''
ignore_inline=1

################
main()
################

if output_fd!=sys.stderr:
	output_fd.close()

if exit_flag!=0 and output_file!='':
	try:
		os.unlink(output_file)
	except:
		pass

sys.exit(exit_flag)