songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cgal/Packages/Manual_tools/src/cpp_formatting.C

1750 lines
52 KiB
C
Raw Blame History

/**************************************************************************
cpp_formatting.C
=============================================================
Project : Tools for the CC manual writing task around cc_manual.sty.
Function : C++ Formatting functions.
System : bison, flex, C++ (g++)
Author : (c) 1998 Lutz Kettner
Revision : $Revision$
Date : $Date$
**************************************************************************/
#include <cpp_formatting.h>
#include <string_conversion.h>
#include <macro_dictionary.h>
#include <internal_macros.h>
#include <html_config.h>
#include <html_error.h>
#include <stdlib.h>
#include <ctype.h>
#include <output.h>
// New style conversion routines
// =======================================
string class_name;
string template_class_name;
// Old style conversion routines
// =======================================
/* table size and font size constants */
/* ================================== */
const int table_width = 650; // absolute
const int table_long_param_indent = 50; // absolute
const int table_first_col = 25; // in percent
const int table_second_col = 25; // in percent
const int table_third_col = 50; // in percent
const int table_2c_first_col = 30; // in percent
const int table_2c_second_col = 70; // in percent
const double width_per_character = 5.5;
// This factor is multiplied to the actual width of an C++ declaration
// right before the test for multiple lines formatting occurs.
// A greater value forces declarations to be printed in multiple lines.
double stretch_factor = 1.6;
/* HTML generating functions */
/* ========================= */
double estimate_html_size( const char* s) {
if ( s == 0)
return 0;
int n = 0;
while ( *s) {
if ( *s == '|' && isupper(s[1]) && s[2] == '|') {
s += 2;
} else if ( *s > ' ' || (*s > '\0' && s[1] > ' '))
n++;
++s;
}
return width_per_character * n;
}
inline double estimate_html_size( const string& s) {
return estimate_html_size( s.c_str());
}
void three_cols_html_begin( ostream& out, bool big_col1) {
current_font = it_font;
out << indent << indent << ind_newline
<< "<!3><TABLE BORDER=0 CELLSPACING=2 CELLPADDING=0 WIDTH="
<< table_width << ">" << ind_newline
<< "<TR><TD ALIGN=LEFT VALIGN=TOP WIDTH="
<< table_first_col + (big_col1 ? (table_second_col+table_third_col) :0)
<< "%" << ( big_col1 ? " COLSPAN=3>" : " NOWRAP>")
<< ind_newline << "<I><NOBR>" << outdent << ind_newline;
}
void three_cols_html_premature_end( ostream& out) {
out << indent << ind_newline << store_remember_font() << "</I></NOBR>"
<< ind_newline << "</TD></TR>" << ind_newline
<< "</TABLE><!3>" << outdent << outdent << ind_newline;
}
void three_cols_html_second( ostream& out, bool big_col1, bool big_col2) {
out << indent << ind_newline << store_remember_font() << "</I></NOBR>"
<< ind_newline << "</TD>";
if ( big_col1)
out << "</TR><TR><TD WIDTH=" << table_first_col << "% NOWRAP></TD>";
out << "<TD ALIGN=LEFT VALIGN=TOP WIDTH="
<< table_second_col + ( big_col2 ? table_third_col : 0)
<< "% NOWRAP" << ( big_col2 ? " COLSPAN=2>" : ">")
<< ind_newline << "<I><NOBR>" << get_remember_font() << outdent
<< ind_newline;
}
void three_cols_html_third( ostream& out, bool big_col2, bool empty_col3) {
out << indent << ind_newline << store_remember_font() << "</I></NOBR>"
<< ind_newline;
if ( ! big_col2)
out << "</TD>";
if ( ! empty_col3) {
if ( big_col2)
out << "</TR><TR><TD WIDTH=" << table_first_col
<< "% NOWRAP></TD><TD WIDTH=" << table_second_col
<< "% NOWRAP></TD>";
out << "<TD ALIGN=LEFT VALIGN=TOP WIDTH=" << table_third_col << "%>";
}
out << outdent << ind_newline;
}
void three_cols_html_end( ostream& out, bool empty_col3) {
out << indent << ind_newline;
if ( ! empty_col3)
out << "</TD>";
out << "</TR>" << ind_newline
<< "</TABLE><!3>" << outdent << outdent << ind_newline;
}
void three_cols_html_new_closing( ostream& out) {
out << outdent;
}
void two_cols_html_begin( ostream& out) {
current_font = it_font;
out << indent << indent << ind_newline
<< "<!2><TABLE BORDER=0 CELLSPACING=2 CELLPADDING=0 WIDTH="
<< table_width << ">" << ind_newline
<< "<TR><TD ALIGN=LEFT VALIGN=TOP WIDTH="
<< table_2c_first_col + table_2c_second_col << "% NOWRAP COLSPAN=2>"
<< ind_newline << "<I><NOBR>" << outdent << ind_newline;
}
void two_cols_html_premature_end( ostream& out) {
out << indent << ind_newline << store_remember_font() <<"</I></NOBR>"
<< ind_newline << "</TD></TR>" << ind_newline
<< "</TABLE><!2>" << outdent << outdent << ind_newline;
}
void two_cols_html_second( ostream& out, bool empty_col2) {
out << indent << ind_newline << store_remember_font() << "</I></NOBR>"
<< ind_newline << "</TD></TR>";
if ( ! empty_col2)
out << "<TR><TD WIDTH=" << table_2c_first_col
<< "% NOWRAP></TD><TD ALIGN=LEFT VALIGN=TOP WIDTH="
<< table_2c_second_col << "%>";
out << outdent << ind_newline;
}
void two_cols_html_new_closing( ostream& out) {
out << indent << ind_newline << store_remember_font() << "</I></NOBR>"
<< ind_newline << "</TD></TR>" << outdent << outdent;
}
void two_cols_html_end( ostream& out, bool empty_col2) {
out << indent << ind_newline;
if ( ! empty_col2)
out << "</TD></TR>" << ind_newline;
out << "</TABLE><!2>" << outdent << outdent << ind_newline;
}
/* template declarations for functions and others */
/* ============================================== */
/* It depends on the layout (2 or 3 columns) */
const char* handle_template_layout( ostream& out,
const char* decl,
bool three_col) {
const char* new_pos = decl;
const char* p = decl;
while ( *p && isspace( *p))
p++;
if ( strncmp( "template", p, 8) == 0) {
p += 8;
while ( *p && isspace( *p))
p++;
if ( *p == '<') {
p++;
// Here we know that it is a template declaration. Now we
// look for the end of the template params using a nesting counter.
int nesting = 1;
while ( *p && nesting > 0) {
if ( *p == '<')
nesting++;
else if ( *p == '>')
nesting --;
p++;
}
new_pos = p;
if ( ! macroIsTrue( "\\ccTagRmTemplate")) {
// Print the template declaration.
if ( three_col)
three_cols_html_begin( out, true);
else
two_cols_html_begin( out);
print_ascii_len_to_html( out, decl, p - decl);
if ( three_col)
three_cols_html_premature_end( out);
else
two_cols_html_premature_end( out);
// Make the postprocessing glue the template keyword and list
// together with the declaration.
out << "<!GLUE>";
}
}
}
return new_pos;
}
/* Formatting functions that work like the cc_manual.sty */
/* ===================================================== */
// This function separates the return value from the scope, the function name,
// the parameter list (without paranthesis) and the rest of the signature.
// Therefore, the string in signature will be parsed from the end
// looking for the first ')' and then for the matching '(', using
// a nesting count for '(', ')', '{', '}', '<', '>'. Then, the next token is
// assumed to be the function name. After that, a scope can be a list of
// '::' and identifiers. The rest is assumed to be the return value. All parts
// might be empty. The parantheses for the parameters are not allowed to be
// omitted. The function name token might be an operator !!
// For the special case of enumerators the last parameter enum_decl
// changes the parsing to look for braces `{}' instead of parantheses `()'.
void split_function_declaration( const char* signature,
char*& return_value,
char*& scope,
char*& function_name,
char*& parameter_list,
const char*& rest,
bool enum_decl = false) {
char opening = '(';
char closing = ')';
if ( enum_decl) {
opening = '{';
closing = '}';
}
const char* s = signature + strlen( signature) - 1;
// Note that the string processing pointer s can point one character
// in front of signature (where it should never be dereferenced).
// This is checked using the s_end pointer.
const char* s_end = signature - 1;
// skip the rest
while ( s != s_end && *s != closing)
--s;
rest = s + 1;
while ( *rest > 0 && *rest <= ' ')
++rest;
if ( s != s_end)
--s;
while ( s != s_end && *s <= ' ')
--s;
// scan the parameter list
const char* q = s;
int nesting = 0;
while ( s != s_end && ( nesting || *s != opening)) {
switch ( *s) {
case ')':
case '}':
case '>':
++nesting;
break;
case '(':
case '{':
case '<':
--nesting;
break;
}
--s;
}
const char* p = s + 1;
while ( *p > 0 && *p <= ' ')
++p;
if ( q - p >= 0) {
parameter_list = new char[ q - p + 2];
strncpy( parameter_list, p, q - p + 1);
parameter_list[ q - p + 1] = '\0';
} else
parameter_list = 0;
if ( s != s_end) // read over the '('
--s;
while ( s != s_end && *s <= ' ')
--s;
if ( s == s_end || nesting) {
printErrorMessage( MalformedFunctionDeclaration);
exit( 1);
}
q = s;
// scan function name
// skip possible operator symbols and white spaces
while ( s != s_end && ( ! isalnum( *s)) && ( *s != '_') && ( *s != '|'))
--s;
// parse first identifier for the function_name
while ( s != s_end && ( isalnum( *s) || *s == '_' || *s == '|'))
--s;
// check the possibilty that the function is a cast operator
// like `operator int', or an idfier as operator like `operator new'
// so check whether the next identifier is equal to `operator'
p = s;
while ( s != s_end && *s <= ' ')
--s;
while ( s != s_end && ( isalnum( *s) || *s == '_' || *s == '|'))
--s;
// check for conversion operators with template classes like
// operator A<int>(...)
const char* pp = signature;
while ( isspace( *pp))
pp++;
if ( strncmp( pp, "operator", 8) == 0)
s = pp - 1;
else {
if ( strncmp( s + 1, "operator", 8) != 0)
// it's not the cast operator, restore old position
s = p;
}
if ( q - s) {
function_name = new char[ q - s + 1];
strncpy( function_name, s + 1, q - s);
function_name[ q - s] = '\0';
} else
function_name = 0;
// check for a scope operator
while ( s != s_end && *s <= ' ')
--s;
q = s;
while ( (s - s_end) > 0 && *s == ':' && *(s-1) == ':') {
s -= 2;
while ( s != s_end && *s <= ' ')
--s;
while ( s != s_end && ( isalnum( *s) || *s == '_' || *s == '|'))
--s;
}
if ( q - s > 0) {
scope = new char[ q - s + 1];
strncpy( scope, s + 1, q - s);
scope[ q - s] = '\0';
} else
scope = 0;
// The rest is the return type
while ( s != s_end && *s <= ' ')
--s;
q = signature;
while ( *q && *q <= ' ')
++q;
if ( s - q >= 0) {
return_value = new char[ s - q + 2];
strncpy( return_value, q, s - q + 1);
return_value[ s - q + 1] = '\0';
} else
return_value = 0;
}
// This function separates a variable declaration around the variable name.
// The rest might contain `)', array subscripts or an assignment.
// The scope might be empty, the return_value should not be empty.
// No fancy tricks like operators.
void split_variable_declaration( const char* signature,
char*& return_value,
char*& scope,
char*& variable_name,
char*& rest) {
const char* s = signature + strlen( signature) - 1;
// Note that the string processing pointer s can point one character
// in front of signature (where it should never be dereferenced).
// This is checked using the s_end pointer.
const char* s_end = signature - 1;
// skip the `;'
while ( s != s_end && *s != ';')
--s;
if ( s != s_end)
--s;
// skip the rest
const char* q = s;
// look out for an assignment (including nesting)
int nesting = 0;
while ( s != s_end && ( nesting || *s != '=')) {
if ( *s == '}' || *s == ')' || *s == ']' || *s == '>')
++nesting;
if ( *s == '{' || *s == '(' || *s == '[' || *s == '<')
--nesting;
--s;
}
if ( s != s_end) {
// assignment found
--s;
} else {
// not found, restore old position
s = q;
}
// skip possible operator symbols and white spaces
while ( s != s_end && ( ! isalnum( *s)) && ( *s != '_') && ( *s != '|'))
--s;
const char* p = s + 1;
while ( *p > 0 && *p <= ' ')
++p;
if ( q - p >= 0) {
rest = new char[ q - p + 2];
strncpy( rest, p, q - p + 1);
rest[ q - p + 1] = '\0';
} else
rest = 0;
if ( s == s_end) {
printErrorMessage( MalformedFunctionDeclaration);
exit( 1);
}
q = s;
// scan function name
// parse first identifier for the function_name
while ( s != s_end && ( isalnum( *s) || *s == '_' || *s == '|'))
--s;
if ( q - s) {
variable_name = new char[ q - s + 1];
strncpy( variable_name, s + 1, q - s);
variable_name[ q - s] = '\0';
} else
variable_name = 0;
// check for a scope operator
while ( s != s_end && *s <= ' ')
--s;
q = s;
while ( (s - s_end) > 0 && *s == ':' && *(s-1) == ':') {
s -= 2;
while ( s != s_end && *s <= ' ')
--s;
while ( s != s_end && ( isalnum( *s) || *s == '_' || *s == '|'))
--s;
}
if ( q - s > 0) {
scope = new char[ q - s + 1];
strncpy( scope, s + 1, q - s);
scope[ q - s] = '\0';
} else
scope = 0;
// The rest is the return type
while ( s != s_end && *s <= ' ')
--s;
q = signature;
while ( *q && *q <= ' ')
++q;
if ( s - q >= 0) {
return_value = new char[ s - q + 2];
strncpy( return_value, q, s - q + 1);
return_value[ s - q + 1] = '\0';
} else
return_value = 0;
}
void remove_const_ref_pair( char* s) {
if ( ! macroIsTrue( "\\ccTagRmConstRefPair"))
return;
int state = 0; // 0 = no const, 1 = c, 2 = co, 3 = con, 4 = cons, 5 = const
int nesting = 0;
char* q; // position of recently found const
int nest; // nesting level of recently found const
while( *s) {
switch( state) {
case 0:
if ( *s == '(' || *s == '<' || *s == '[' || *s == '{')
++nesting;
if ( *s == ')' || *s == '>' || *s == ']' || *s == '}')
--nesting;
if ( *s == 'c') {
state = 1;
nest = nesting;
q = s;
}
++s;
break;
case 1:
if ( *s == 'o') {
++s;
state = 2;
} else
state = 0;
break;
case 2:
if ( *s == 'n') {
++s;
state = 3;
} else
state = 0;
break;
case 3:
if ( *s == 's') {
++s;
state = 4;
} else
state = 0;
break;
case 4:
if ( *s == 't') {
++s;
state = 5;
} else
state = 0;
break;
case 5:
if ( *s == '(' || *s == '<' || *s == '[' || *s == '{')
++nesting;
if ( *s == ')' || *s == '>' || *s == ']' || *s == '}')
--nesting;
if ( *s == '&' && nest == nesting) {
q[0] = ' ';
q[1] = ' ';
q[2] = ' ';
q[3] = ' ';
q[4] = ' ';
s[0] = ' ';
return;
}
++s;
break;
}
}
return;
}
void remove_own_classname( char* s, const string& classname) {
if ( ! macroIsTrue( "\\ccTagRmEigenClassName"))
return;
if ( classname.empty())
return;
// An easy algorithm (quadratic runtime worst case).
// The classname has to match exactly (and is removed at most once).
// If the result is an empty string, the classname is not removed.
int l = strlen( s) - classname.size();
int l2 = classname.size();
int i;
bool is_empty = true;
for ( i = 0; i <= l; i++) {
if ( strncmp( s, classname.c_str(), l2) == 0)
break;
if ( ! isspace( *s))
is_empty = false;
s++;
}
if ( i <= l) {
// Classname found. Test if it is not part of a larger idfier.
if ( i < l && ( isalnum( s[l2]) || s[l2] == '_'))
return;
if ( i > 0 && ( isalnum( s[-1]) || s[-1] == '_'))
return;
// Classname found. Test non-empty result.
char* p = s + l2;
while ( *p) {
if ( ! isspace( *p))
is_empty = false;
p++;
}
if ( ! is_empty) {
// Remove it.
for( ; l2 > 0; l2--)
*s++ = ' ';
}
}
}
// This function separates each parameter in a parameter list.
// It replaces therefore the separating commatas by `\0'.
// The returnvalue states the number of parameters found.
// The parsing process takes nesting in account.
int separate_parameter_list( char* s) {
if ( ! s)
return 0;
char* s_start = s - 1;
int n = 1;
int nesting = 0;
while( *s) {
if ( *s == '(' || *s == '<' || *s == '[' || *s == '{')
++nesting;
if ( *s == ')' || *s == '>' || *s == ']' || *s == '}')
--nesting;
if ( *s == ',' && nesting == 0) {
++n;
// remove trailing spaces
*s = ' ';
char* q = s - 1;
while ( q != s_start && *q && *q <= ' ')
--q;
++q;
*q = '\0';
}
++s;
}
if ( nesting ) {
printErrorMessage( MalformedFunctionDeclaration);
exit( 1);
}
return n;
}
// Compute the operator layout. Assume reasonable values in all parameters.
// Actually, exp_size just counts all parameters and operator characters.
// Only exceptional cases has to recompute exp_size. The boolean
// ignore_params can be set true in which case the parameters will not
// be printed, even not the creationvariable for methods. (Used
// for the new and the delete operators.)
// The parantheses operator has to format its own parantheses and
// the first commata between the first and second parameter (if
// more than one parameter exists).
// As an exceptional case for ++ and -- the number of parameters
// is reduced from two to one to hide the second int parameter
// neccessary to indicate that the postincrement is meant. (Hack!! ;--> )
// Returns: false if failed, true for success.
bool format_operators( int n, int& modifiable_n,
char* op,
const char*& praefix,
const char*& infix,
const char*& postfix,
double& exp_size,
bool& ignore_params) {
current_font = it_font;
// Assume that the syntax is not malformed (error messages are
// provided elsewhere, namely compiler or cc_manual.sty).
// Non matching operators are printed in functional notation.
if ( ! macroIsTrue( "\\ccTagOperatorLayout"))
return false;
if ( *op <= ' ')
return false;
if ( op[1] <= ' ') { // one character operators
if ( n == 1) { // with one parameter
switch ( *op) {
case '~':
case '!':
case '-':
case '+':
case '&':
case '*':
praefix = op;
break;
default:
return false;
}
} else if ( n == 2) { // with two parameters
switch ( *op) {
case '*':
case '/':
case '%':
case '+':
case '-':
case '<':
case '>':
case '&':
case '^':
case '|':
case '=':
case ',':
infix = op;
break;
default:
return false;
}
} else
return false;
} else if ( op[2] <= ' ') { // two character operators
if ( n == 1) { // with one parameter
switch ( *op) {
case '-':
if ( op[1] == '>')
postfix = op;
else if ( op[1] == '-')
praefix = op;
else
return false;
break;
case '(':
if ( op[1] == ')') {
infix = op;
} else
return false;
break;
case '+':
if ( op[1] == *op)
praefix = op;
else
return false;
break;
default:
return false;
}
} else if ( n == 2) { // with two parameters
switch ( *op) {
case '[':
if ( op[1] == ']') {
infix = "[";
postfix = "]";
}
else
return false;
break;
case '(':
if ( op[1] == ')') {
infix = "(";
postfix = ")";
}
else
return false;
break;
case '+':
case '-':
if ( op[1] == *op) {
postfix = op;
modifiable_n--;
exp_size -= estimate_html_size( " int");
}
else if ( op[1] == '=')
infix = op;
else
return false;
break;
case '>':
case '<':
case '&':
case '|':
if ( op[1] == *op || op[1] == '=')
infix = op;
else
return false;
break;
case '=':
case '!':
case '*':
case '/':
case '%':
case '^':
if ( op[1] == '=')
infix = op;
else
return false;
break;
default:
return false;
}
} else if (op[0] == '(' && op[1] == ')') {
infix = "(";
postfix = ")";
} else
return false;
} else { // three or more character operators
if ( strcmp( op, "->*") == 0)
postfix = op;
else if ( strcmp( op, "<<=") == 0)
infix = op;
else if ( strcmp( op, ">>=") == 0)
infix = op;
else if ( strcmp( op, "new") == 0) {
ignore_params = true;
exp_size = estimate_html_size( " new ");
exp_size += estimate_html_size( template_class_name);
praefix = "new";
infix = template_class_name.c_str();
} else if ( strcmp( op, "delete") == 0) {
ignore_params = true;
exp_size = estimate_html_size( " delete void*");
praefix = "delete void*";
} else if ( strcmp( op, "delete[]") == 0) {
ignore_params = true;
exp_size = estimate_html_size( " delete[] void*");
praefix = "delete[] void*";
} else
return false;
}
return true;
}
void print_rest( ostream& out, const char* txt){
out << ' ';
while( *txt && *txt != ';') {
if ( *txt == '|' && isupper(txt[1]) && txt[2] == '|') {
out << new_remember_font( txt[1]);
txt += 2;
} else if ( is_html_multi_character( *txt))
out << html_multi_character( *txt);
else
if ( *txt > ' ' || (*txt > '\0' && txt[1] > ' '))
out << *txt;
++txt;
}
}
// Three column layout functions
// =====================================================
void format_function( bool method, const char* signature,
bool is_empty_comment) {
current_font = it_font;
char* return_value;
char* scope;
char* function_name;
char* parameter_list;
const char* rest;
bool normal_operator = false; // either operator ...
bool conversion_operator = false; // ... or conversion operator
// or (normal) function
char* op_symbols;
while( *signature && *signature == ' ')
signature++;
split_function_declaration( signature,
return_value,
scope,
function_name,
parameter_list,
rest);
// check function_name for operator
if ( strncmp( function_name, "operator", 8) == 0
&& ! isalnum(function_name[8])
&& function_name[8] != '_') {
op_symbols = function_name + 8;
while ( *op_symbols && *op_symbols <= ' ')
++op_symbols;
normal_operator = (return_value != 0);
conversion_operator = (return_value == 0);
}
double exp_size_ret = 0.0;
double exp_size = 0.0;
if ( return_value) {
remove_const_ref_pair( return_value);
exp_size_ret += estimate_html_size( return_value);
}
if ( conversion_operator)
exp_size_ret += estimate_html_size( op_symbols);
three_cols_html_begin( *current_ostream,
exp_size_ret * stretch_factor >
table_width*table_first_col/100.0);
// ---------
// index
if ( !method && macroIsTrue( "\\lciIfHtmlIndex")
&& macroIsTrue( "\\lciIfHtmlRefIndex")) {
char* formatted_return = convert_fontified_ascii_to_html(
return_value);
char* formatted_scope = convert_fontified_ascii_to_html( scope);
char* formatted_function = convert_fontified_ascii_to_html(
function_name);
char* formatted_params = convert_fontified_ascii_to_html(
parameter_list);
char* formatted_rest = convert_fontified_ascii_to_html( rest);
// Make only the function name a hyperlink. Types could be substituted
// according the rules.
*index_stream << sort_key_function << '1';
filter_for_index_comment( *index_stream, function_name);
*index_stream << ' ';
filter_for_index_comment( *index_stream, signature);
*index_stream << "!><UL><LI><I>"
<< formatted_return << ' ' << formatted_scope
<< "<A HREF=\"" << current_filename << "#Function_";
filter_for_index_anchor( *index_stream, signature);
*index_stream << "\">" << formatted_function << "</A>"
<< "( " << formatted_params << ")" << formatted_rest
<< "</I></UL>" << endl;
*current_ostream << "<A NAME=\"Function_";
filter_for_index_anchor( *current_ostream, signature);
*current_ostream << "\"></A>" << endl;
delete[] formatted_return;
delete[] formatted_scope;
delete[] formatted_function;
delete[] formatted_params;
delete[] formatted_rest;
}
// end index
// ----------
if ( return_value)
print_ascii_to_html_spc( *current_ostream, return_value);
if ( conversion_operator)
print_ascii_to_html_spc( *current_ostream, op_symbols);
// handle function body or operation signature
// first, estimate size
if ( method)
exp_size = estimate_html_size( macroX( "\\ccPureVar")) +
width_per_character;
int n = 0;
if ( conversion_operator) {
exp_size += estimate_html_size( op_symbols);
} else if ( parameter_list) {
n = separate_parameter_list( parameter_list);
char* p = parameter_list;
int m = n;
while ( m--) {
remove_const_ref_pair( p);
remove_own_classname( p, template_class_name);
exp_size += estimate_html_size( p) + width_per_character;
p += strlen( p) + 1; // skip to next parameter
}
}
if (! macroIsTrue( "\\ccTagRmTrailingConst"))
exp_size += estimate_html_size( rest);
bool failed = false;
if ( normal_operator) {
exp_size += estimate_html_size( op_symbols);
bool ignore_params = false; // exception for new and delete operators
const char* praefix = "";
const char* infix = "";
const char* postfix = "";
failed = ! format_operators( ( method ? n + 1 : n), n,
op_symbols,
praefix, infix, postfix,
exp_size, ignore_params);
if ( ! failed) {
// print the operator
three_cols_html_second(
*current_ostream,
exp_size_ret * stretch_factor >
table_width * table_first_col / 100.0,
is_empty_comment || (exp_size * stretch_factor >
table_width * table_second_col / 100.0)
);
print_ascii_to_html_spc( *current_ostream, praefix);
*current_ostream << " ";
char* p = parameter_list;
if ( ! ignore_params) {
if ( method)
print_ascii_to_html_spc(*current_ostream,
macroX( "\\ccPureVar"));
else if (n) {
--n;
print_ascii_to_html_spc(*current_ostream, p);
p += strlen( p) + 1; // skip to next parameter
}
}
*current_ostream << " ";
print_ascii_to_html_spc( *current_ostream, infix);
*current_ostream << " ";
if ( ! ignore_params && n) {
while ( n--) {
print_ascii_to_html_spc(*current_ostream, p);
p += strlen( p) + 1; // skip to next parameter
if ( n)
*current_ostream << ", ";
}
}
print_ascii_to_html_spc( *current_ostream, postfix);
}
}
if ( ! normal_operator || failed) {
if ( scope)
exp_size += estimate_html_size( scope);
exp_size += estimate_html_size( function_name);
exp_size += 3 * width_per_character; // for parameter list parantheses
// then, do the printing
three_cols_html_second(
*current_ostream,
exp_size_ret * stretch_factor >
table_width * table_first_col / 100.0,
is_empty_comment || (exp_size * stretch_factor >
table_width * table_second_col / 100.0)
);
if ( conversion_operator) {
print_ascii_to_html_spc( *current_ostream, op_symbols);
*current_ostream << " ( ";
if ( ! definedMacro( "\\ccPureVar")) {
printErrorMessage( VariableUsedError);
*current_ostream << "*this";
} else
print_ascii_to_html_spc( *current_ostream,
macroX( "\\ccPureVar"));
*current_ostream << ")";
} else {
double dd_width = table_width * ( 1.0 - table_first_col / 100.0);
dd_width /= stretch_factor;
if ( exp_size > dd_width && parameter_list) {
*current_ostream << store_remember_font();
*current_ostream << "<TABLE BORDER=0 CELLSPACING=0 "
"CELLPADDING=0><TR><TD ALIGN=LEFT VALIGN=TOP NOWRAP";
if ( macroIsTrue( "\\ccLongParamLayout") ||
! macroIsTrue( "\\ccAlternateThreeColumn"))
*current_ostream << " COLSPAN=2";
*current_ostream << "><I>" << get_remember_font()
<< ind_newline;
}
if ( method) {
if ( ! definedMacro( "\\ccPureVar")) {
printErrorMessage( VariableUsedError);
*current_ostream << "*this";
} else
print_ascii_to_html_spc(*current_ostream,
macroX( "\\ccPureVar"));
*current_ostream << '.';
}
if ( scope)
print_ascii_to_html_spc( *current_ostream, scope);
print_ascii_to_html_spc( *current_ostream, function_name);
if ( parameter_list) {
*current_ostream << " ( ";
if ( exp_size > dd_width) {
*current_ostream << store_remember_font();
*current_ostream << "</I></TD>";
if ( macroIsTrue( "\\ccLongParamLayout") ||
! macroIsTrue( "\\ccAlternateThreeColumn"))
*current_ostream << "</TR><TR><TD WIDTH="
<< table_long_param_indent
<< " NOWRAP></TD>";
*current_ostream << "<TD ALIGN=LEFT VALIGN=TOP "
"NOWRAP><I>";
*current_ostream << get_remember_font() << ind_newline;
}
char* p = parameter_list;
while ( n--) {
print_ascii_to_html_spc( *current_ostream, p);
p += strlen( p) + 1; // skip to next parameter
if ( n) {
*current_ostream << ", ";
if ( exp_size > dd_width)
*current_ostream << "<BR>" << ind_newline;
}
}
*current_ostream << ")";
if ( exp_size > dd_width) {
*current_ostream << store_remember_font();
*current_ostream << "</I></TD></TR></TABLE>" <<ind_newline;
}
} else
*current_ostream << " ()";
}
}
if (! macroIsTrue( "\\ccTagRmTrailingConst"))
print_rest( *current_ostream, rest);
three_cols_html_third( *current_ostream,
exp_size * stretch_factor>
table_width * table_second_col / 100.0,
is_empty_comment);
delete[] return_value;
delete[] scope;
delete[] function_name;
delete[] parameter_list;
three_cols_html_new_closing( *current_ostream);
}
void format_variable( const char* signature,
bool is_empty_comment,
bool is_typedef = false) {
current_font = it_font;
char* return_value;
char* scope;
char* variable_name;
char* rest; // possibly including assignment
split_variable_declaration( signature,
return_value,
scope,
variable_name,
rest);
char* formatted_var = convert_fontified_ascii_to_html( variable_name);
double exp_size_ret = 0.0;
double exp_size = 0.0;
if ( return_value) {
remove_const_ref_pair( return_value);
exp_size_ret += estimate_html_size( return_value);
}
three_cols_html_begin( *current_ostream,
exp_size_ret * stretch_factor >
table_width*table_first_col/100.0);
if ( class_name.empty()) {
if ( macroIsTrue( "\\lciIfHtmlLinks") &&
macroIsTrue( "\\lciIfHtmlRefLinks") &&
strlen(variable_name) > 1) {
// generate a substitution rule for hyperlinking
*anchor_stream << "[a-zA-Z0-9_]\"" << formatted_var
<< "\" { ECHO; }" << endl;
*anchor_stream << '"' << formatted_var
<< "\"/{noCCchar} { wrap_anchor( \""
<< current_filename
<< (is_typedef ? "#Typedef_" : "#Var_" );
filter_for_index_anchor( *anchor_stream, variable_name);
*anchor_stream << "\", yytext); }" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlIndex") &&
macroIsTrue( "\\lciIfHtmlRefIndex")) {
// index
*index_stream << (is_typedef ? sort_key_typedef :
sort_key_variable) << '1';
filter_for_index_comment( *index_stream, variable_name);
*index_stream << "!><UL><LI><I>" << formatted_var
<< "</I></UL>" << endl;
}
} else if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << (is_typedef ? sort_key_typedef :
sort_key_variable) << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, variable_name);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename
<< (is_typedef ? "#Typedef_" : "#Var_" );
filter_for_index_anchor( *index_stream, variable_name);
*index_stream << "\"><I>" << template_class_name << "::"
<< variable_name << "</I></A></UL>" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlLinks") ||
macroIsTrue( "\\lciIfHtmlIndex")) {
*current_ostream << "<A NAME=\""
<< (is_typedef ? "Typedef_" : "Var_" );
filter_for_index_anchor( *current_ostream, variable_name);
*current_ostream << "\"></A>" << endl;
}
// end index
if ( return_value)
print_ascii_to_html_spc( *current_ostream, return_value);
// handle function body or operation signature
// first, estimate size
if ( scope)
exp_size += estimate_html_size( scope);
exp_size += estimate_html_size( variable_name);
if ( rest)
exp_size += estimate_html_size( rest);
// then, do the printing
three_cols_html_second(
*current_ostream,
exp_size_ret * stretch_factor> table_width * table_first_col/100.0,
is_empty_comment || (exp_size * stretch_factor>
table_width * table_second_col / 100.0)
);
if ( scope)
print_ascii_to_html_spc( *current_ostream, scope);
print_ascii_to_html_spc( *current_ostream, variable_name);
// *current_ostream << formatted_var;
if ( rest) {
*current_ostream << ' ';
print_ascii_to_html_spc( *current_ostream, rest);
}
*current_ostream << ';';
three_cols_html_third( *current_ostream,
exp_size * stretch_factor >
table_width * table_second_col / 100.0,
is_empty_comment);
delete[] return_value;
delete[] scope;
delete[] formatted_var;
delete[] variable_name;
delete[] rest;
three_cols_html_new_closing( *current_ostream);
}
// Two column layout functions
// =====================================================
void format_class_declaration( const char* signature) {
current_font = it_font;
char* return_value;
char* scope;
char* struct_name;
char* rest;
split_variable_declaration( signature,
return_value,
scope,
struct_name,
rest);
char* formatted_struct = convert_fontified_ascii_to_html( struct_name);
two_cols_html_begin( *current_ostream);
if ( class_name.empty()) {
if ( macroIsTrue( "\\lciIfHtmlLinks") && strlen(struct_name) > 1) {
// generate a substitution rule for hyperlinking
*anchor_stream << "[a-zA-Z0-9_]\"" << formatted_struct
<< "\" { ECHO; }" << endl;
*anchor_stream << '"' << formatted_struct
<< "\"/{noCCchar} { wrap_anchor( \""
<< current_filename << "#Struct_";
filter_for_index_anchor( *anchor_stream, struct_name);
*anchor_stream << "\", yytext); }" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_struct << '1';
filter_for_index_comment( *index_stream, struct_name);
*index_stream << "!><UL><LI><I>" << formatted_struct
<< "</I></UL>" << endl;
}
} else if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_struct << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, struct_name);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename << "#Struct_";
filter_for_index_anchor( *index_stream, struct_name);
*index_stream << "\"><I>" << template_class_name << "::"
<< struct_name << "</I></A></UL>" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlLinks") ||
macroIsTrue( "\\lciIfHtmlIndex")) {
*current_ostream << "<A NAME=\"Struct_";
filter_for_index_anchor( *current_ostream, struct_name);
*current_ostream << "\"></A>" << endl;
}
// end index
print_ascii_to_html_spc( *current_ostream, signature);
// *current_ostream << ';';
delete[] return_value;
delete[] scope;
delete[] formatted_struct;
delete[] struct_name;
delete[] rest;
two_cols_html_new_closing( *current_ostream);
}
void format_struct( const char* signature) {
current_font = it_font;
char* return_value;
char* scope;
char* struct_name;
char* parameter_list;
const char* rest;
split_function_declaration( signature,
return_value,
scope,
struct_name,
parameter_list,
rest,
true);
char* formatted_struct = convert_fontified_ascii_to_html( struct_name);
two_cols_html_begin( *current_ostream);
if ( class_name.empty()) {
if ( macroIsTrue( "\\lciIfHtmlLinks") && strlen(struct_name) > 1) {
// generate a substitution rule for hyperlinking
*anchor_stream << "[a-zA-Z0-9_]\"" << formatted_struct
<< "\" { ECHO; }" << endl;
*anchor_stream << '"' << formatted_struct
<< "\"/{noCCchar} { wrap_anchor( \""
<< current_filename << "#Struct_";
filter_for_index_anchor( *anchor_stream, struct_name);
*anchor_stream << "\", yytext); }" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_struct << '1';
filter_for_index_comment( *index_stream, struct_name);
*index_stream << "!><UL><LI><I>" << formatted_struct
<< "</I></UL>" << endl;
}
} else if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_struct << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, struct_name);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename << "#Struct_";
filter_for_index_anchor( *index_stream, struct_name);
*index_stream << "\"><I>" << template_class_name << "::"
<< struct_name << "</I></A></UL>" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlLinks") ||
macroIsTrue( "\\lciIfHtmlIndex")) {
*current_ostream << "<A NAME=\"Struct_";
filter_for_index_anchor( *current_ostream, struct_name);
*current_ostream << "\"></A>" << endl;
}
// end index
// first, estimate size
double exp_size = 0.0;
if ( scope)
exp_size += estimate_html_size( scope);
if ( return_value)
exp_size += estimate_html_size( return_value);
exp_size += estimate_html_size( formatted_struct)
+ 3.0 * width_per_character;
int n = 0;
if ( parameter_list) {
exp_size += 2 * width_per_character;
n = separate_parameter_list( parameter_list);
char* p = parameter_list;
int m = n;
while ( m--) {
exp_size += estimate_html_size( p) + width_per_character;
p += strlen( p) + 1; // skip to next parameter
}
}
exp_size *= stretch_factor;
if ( exp_size > table_width && parameter_list) {
*current_ostream << store_remember_font();
*current_ostream << "<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>"
"<TR><TD ALIGN=LEFT VALIGN=TOP NOWRAP";
//if ( tag_long_param_layout)
//*current_ostream << " COLSPAN=2";
*current_ostream << "><I>" << get_remember_font() << ind_newline;
}
if ( return_value) {
print_ascii_to_html_spc( *current_ostream, return_value);
*current_ostream << ' ';
}
if ( scope)
print_ascii_to_html_spc( *current_ostream, scope);
*current_ostream << formatted_struct;
if ( parameter_list) {
*current_ostream << " { ";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</TD><TD ALIGN=LEFT VALIGN=TOP NOWRAP>";
*current_ostream << get_remember_font() << ind_newline;
}
char* p = parameter_list;
while ( n--) {
while ( *p && *p <= ' ')
++p;
print_ascii_to_html_spc( *current_ostream, p);
p += strlen( p) + 1; // skip to next parameter
if ( n) {
*current_ostream << ", ";
if ( exp_size > table_width)
*current_ostream << "<BR>" << ind_newline;
}
}
*current_ostream << "};";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</TD></TR></TABLE>" << ind_newline;
}
} else
*current_ostream << ';';
delete[] return_value;
delete[] scope;
delete[] formatted_struct;
delete[] struct_name;
delete[] parameter_list;
two_cols_html_new_closing( *current_ostream);
}
void format_nested_type( const char* nested_type_name) {
current_font = it_font;
char* formatted_type = convert_fontified_ascii_to_html( nested_type_name);
two_cols_html_begin( *current_ostream);
if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_nested_type << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, nested_type_name);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename << "#Nested_type_"
<< nested_type_name
<< "\"><I>";
if ( ! template_class_name.empty())
*index_stream << template_class_name << "::";
*index_stream << nested_type_name << "</I></A></UL>" << endl;
*current_ostream << "<A NAME=\"Nested_type_" << nested_type_name
<< "\"></A>" << endl;
// end index
}
// first, estimate size
double exp_size = estimate_html_size( template_class_name)
+ estimate_html_size( nested_type_name)
+ 2 * width_per_character;
exp_size *= stretch_factor;
print_ascii_to_html_spc( *current_ostream, template_class_name);
*current_ostream << "::";
print_ascii_to_html_spc( *current_ostream, nested_type_name);
delete[] formatted_type;
two_cols_html_new_closing( *current_ostream);
}
void format_enum( const char* signature) {
current_font = it_font;
char* return_value;
char* scope;
char* enum_name;
char* parameter_list;
const char* rest;
split_function_declaration( signature,
return_value,
scope,
enum_name,
parameter_list,
rest,
true);
char* formatted_enum = convert_fontified_ascii_to_html( enum_name);
two_cols_html_begin( *current_ostream);
if ( class_name.empty()) {
if ( macroIsTrue( "\\lciIfHtmlLinks") && strlen( enum_name) > 1) {
// generate a substitution rule for hyperlinking
*anchor_stream << "[a-zA-Z0-9_]\"" << formatted_enum
<< "\" { ECHO; }" << endl;
*anchor_stream << '"' << formatted_enum
<< "\"/{noCCchar} { wrap_anchor( \""
<< current_filename << "#Enum_";
filter_for_index_anchor( *anchor_stream, enum_name);
*anchor_stream << "\", yytext); }" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_enum << '1';
filter_for_index_comment( *index_stream, enum_name);
*index_stream << "!><UL><LI><I>" << formatted_enum
<< "</I></UL>" << endl;
}
} else if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index
*index_stream << sort_key_enum << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, enum_name);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename << "#Enum_";
filter_for_index_anchor( *index_stream, enum_name);
*index_stream << "\"><I>" << template_class_name << "::"
<< enum_name << "</I></A></UL>" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlLinks") ||
macroIsTrue( "\\lciIfHtmlIndex")) {
*current_ostream << "<A NAME=\"Enum_";
filter_for_index_anchor( *current_ostream, enum_name);
*current_ostream << "\"></A>" << endl;
}
// end index
// first, estimate size
double exp_size = 0.0;
if ( scope)
exp_size += estimate_html_size( scope);
if ( return_value)
exp_size += estimate_html_size( return_value);
exp_size += estimate_html_size( formatted_enum)
+ 3.0 * width_per_character;
int n = 0;
if ( parameter_list) {
exp_size += 2 * width_per_character;
n = separate_parameter_list( parameter_list);
char* p = parameter_list;
int m = n;
while ( m--) {
exp_size += estimate_html_size( p) + width_per_character;
p += strlen( p) + 1; // skip to next parameter
}
}
exp_size *= stretch_factor;
if ( exp_size > table_width && parameter_list) {
*current_ostream << store_remember_font();
*current_ostream << "<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>"
"<TR><TD ALIGN=LEFT VALIGN=TOP NOWRAP";
//if ( tag_long_param_layout)
//*current_ostream << " COLSPAN=2";
*current_ostream << "><I>" << get_remember_font() << ind_newline;
}
if ( return_value) {
print_ascii_to_html_spc( *current_ostream, return_value);
*current_ostream << ' ';
}
if ( scope)
print_ascii_to_html_spc( *current_ostream, scope);
*current_ostream << formatted_enum;
if ( parameter_list) {
*current_ostream << " { ";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</TD><TD ALIGN=LEFT VALIGN=TOP NOWRAP>";
*current_ostream << get_remember_font() << ind_newline;
}
char* p = parameter_list;
while ( n--) {
while ( *p && *p <= ' ')
++p;
print_ascii_to_html_spc( *current_ostream, p);
if ( class_name.empty()) {
if ( macroIsTrue( "\\lciIfHtmlIndex")) {
// index: print enum tags with (possible) initializers
*index_stream << sort_key_enum_tags << '1' << p
<< "!><UL><LI><I>";
print_ascii_to_html_spc( *index_stream, p);
*index_stream << "</I></UL>" << endl;
}
if ( macroIsTrue( "\\lciIfHtmlLinks")) {
// generate a substitution rule for hyperlinking
// Here, the initializer has to be suppressed
char* q = p;
while( *q && *q != '=')
++q;
while ( q>p && q[-1] <= ' ')
--q;
char c_tmp = *q;
*q = '\0';
if ( strlen( p) > 1) {
char *tmp_param = convert_fontified_ascii_to_html( p);
*anchor_stream << "[a-zA-Z0-9_]\"" << tmp_param
<< "\" { ECHO; }" << endl;
*anchor_stream << '"' << tmp_param
<< "\"/{noCCchar} { wrap_anchor( \""
<< current_filename << "#Enum_";
filter_for_index_anchor( *anchor_stream, enum_name);
*anchor_stream << "\", yytext); }" << endl;
delete[] tmp_param;
}
*q = c_tmp; // restore initializer
}
} else if ( macroIsTrue( "\\lciIfHtmlClassIndex") &&
macroIsTrue( "\\lciIfHtmlIndex")) {
// index: print enum tags with their (possible) initializers
*index_stream << sort_key_enum_tags << '1' << p
<< "!><UL><LI><I>";
print_ascii_to_html_spc( *index_stream, p);
*index_stream << "</I></UL>" << endl;
*index_stream << sort_key_enum_tags << '1';
filter_for_index_comment( *index_stream, template_class_name);
*index_stream << "::";
filter_for_index_comment( *index_stream, p);
*index_stream << "!><UL><LI><A HREF=\""
<< current_filename << "#Enum_";
filter_for_index_anchor( *index_stream, enum_name);
*index_stream << "\"><I>" << template_class_name << "::"
<< p << "</I></A></UL>" << endl;
}
p += strlen( p) + 1; // skip to next parameter
if ( n) {
*current_ostream << ", ";
if ( exp_size > table_width)
*current_ostream << "<BR>" << ind_newline;
}
}
*current_ostream << "};";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</TD></TR></TABLE>" << ind_newline;
}
} else
*current_ostream << ';';
delete[] return_value;
delete[] scope;
delete[] formatted_enum;
delete[] enum_name;
delete[] parameter_list;
two_cols_html_new_closing( *current_ostream);
}
void format_constructor( const char* signature) {
current_font = it_font;
char* return_value;
char* scope;
char* function_name;
char* parameter_list;
const char* rest;
split_function_declaration( signature,
return_value,
scope,
function_name,
parameter_list,
rest);
two_cols_html_begin( *current_ostream);
// first, estimate size
double exp_size = 1.0;
// Of no use here!
// if ( scope)
// exp_size += estimate_html_size( scope);
exp_size += estimate_html_size( macroX( "\\ccPureVar"))
+ estimate_html_size( template_class_name)
+ width_per_character;
int n = 0;
if ( parameter_list) {
exp_size += 2 * width_per_character;
n = separate_parameter_list( parameter_list);
char* p = parameter_list;
int m = n;
while ( m--) {
remove_const_ref_pair( p);
remove_own_classname( p, template_class_name);
exp_size += estimate_html_size( p) + width_per_character;
p += strlen( p) + 1; // skip to next parameter
}
}
exp_size *= stretch_factor;
if ( exp_size > table_width && parameter_list) {
*current_ostream << store_remember_font();
*current_ostream << "<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>"
"<TR><TD ALIGN=LEFT VALIGN=TOP NOWRAP";
if ( macroIsTrue( "\\ccLongParamLayout") ||
! macroIsTrue( "\\ccAlternateThreeColumn"))
*current_ostream << " COLSPAN=2";
*current_ostream << "><I>" << get_remember_font() << ind_newline;
}
// Of no use here!
// if ( scope)
// print_ascii_to_html_spc( *current_ostream, scope);
print_ascii_to_html_spc( *current_ostream, template_class_name);
*current_ostream << ' '; // More space would be a good idea here.
print_ascii_to_html_spc( *current_ostream, macroX( "\\ccPureVar"));
if ( parameter_list) {
*current_ostream << " ( ";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</I></TD>";
if ( macroIsTrue( "\\ccLongParamLayout") ||
! macroIsTrue( "\\ccAlternateThreeColumn"))
*current_ostream << "</TR><TR><TD WIDTH="
<< table_long_param_indent
<< " NOWRAP></TD>";
*current_ostream << "<TD ALIGN=LEFT VALIGN=TOP "
"NOWRAP><I>";
*current_ostream << get_remember_font() << ind_newline;
}
char* p = parameter_list;
while ( n--) {
print_ascii_to_html_spc( *current_ostream, p);
p += strlen( p) + 1; // skip to next parameter
if ( n) {
*current_ostream << ", ";
if ( exp_size > table_width)
*current_ostream << "<BR>" << ind_newline;
}
}
*current_ostream << ");";
if ( exp_size > table_width) {
*current_ostream << store_remember_font();
*current_ostream << "</I></TD></TR></TABLE>" << ind_newline;
}
} else
*current_ostream << ';';
delete[] return_value;
delete[] scope;
delete[] function_name;
delete[] parameter_list;
two_cols_html_new_closing( *current_ostream);
}
// Toplevel handleFunctions
// =====================================================
void handle_two_column_layout( char key, const char* decl) {
if ( current_ostream) {
decl = handle_template_layout( *current_ostream, decl, false);
switch ( key) {
case 'A':
format_class_declaration( decl);
break;
case 'B':
format_struct( decl);
break;
case 'C':
format_nested_type( decl);
break;
case 'D':
format_enum( decl);
break;
case 'E':
format_constructor( decl);
break;
default:
printErrorMessage( UnknownKeyError);
}
}
}
void handle_three_column_layout( char key, const char* decl, bool empty) {
if ( current_ostream) {
decl = handle_template_layout( *current_ostream, decl, true);
switch ( key) {
case 'L': // member function
format_function( true, decl, empty);
break;
case 'M': // function
format_function( false, decl, empty);
break;
case 'N':
format_variable( decl, empty);
break;
case 'O': // typedef
format_variable( decl, empty, true);
break;
default:
printErrorMessage( UnknownKeyError);
}
}
}
// EOF //
Reference in New Issue View Git Blame Copy Permalink