Context Navigation

lex.l @ 5c7fb6c

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newstringwith_gc

Last change on this file since 5c7fb6c was 2c2242c, checked in by Peter A. Buhr <pabuhr@…>, 10 years ago
deal with newer built
Property mode set to `100644`
File size: 14.6 KB

Rev	Line
[51b7345]	1	/* -- Mode: C --
	2	*
	3	* CForall Lexer Version 1.0, Copyright (C) Peter A. Buhr 2001 -- Permission is granted to copy this
	4	* grammar and to use it within software systems. THIS GRAMMAR IS PROVIDED "AS IS" AND WITHOUT
	5	* ANY EXPRESS OR IMPLIED WARRANTIES.
	6	*
	7	* lex.l --
	8	*
	9	* Author : Peter A. Buhr
	10	* Created On : Sat Sep 22 08:58:10 2001
	11	* Last Modified By : Peter A. Buhr
[2c2242c]	12	* Last Modified On : Wed Jan 21 08:43:59 2015
	13	* Update Count : 320
[51b7345]	14	*/
	15
	16	%option yylineno
	17
	18	%{
[8c17ab0]	19	// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor
	20	// directive have been performed and removed from the source. The only exceptions are preprocessor
	21	// directives passed to the compiler (e.g., line-number directives) and C/C++ style comments, which
	22	// are ignored.
[51b7345]	23
[8c17ab0]	24	//************************** Includes and Defines **************************
[51b7345]	25
	26	#include <string>
	27
	28	#include "lex.h"
	29	#include "ParseNode.h"
[8c17ab0]	30	#include "cfa.tab.h" // YACC generated definitions based on C++ grammar
[51b7345]	31
	32	char *yyfilename;
[3848e0e]	33	std::string *strtext; // accumulate parts of character and string constant value
[51b7345]	34
[8c17ab0]	35	#define WHITE_RETURN(x) // do nothing
[51b7345]	36	#define NEWLINE_RETURN() WHITE_RETURN('\n')
	37	#define RETURN_VAL(x) yylval.tok.str = new std::string(yytext); \
	38	yylval.tok.loc.file = yyfilename; \
	39	yylval.tok.loc.line = yylineno; \
	40	return(x)
[3848e0e]	41	#define RETURN_STR(x) yylval.tok.str = strtext; \
	42	yylval.tok.loc.file = yyfilename; \
	43	yylval.tok.loc.line = yylineno; \
	44	return(x)
[51b7345]	45
[8c17ab0]	46	#define KEYWORD_RETURN(x) RETURN_VAL(x) // keyword
[51b7345]	47	#define IDENTIFIER_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
[8c17ab0]	48	//#define ATTRIBUTE_RETURN() RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
	49	#define ATTRIBUTE_RETURN() RETURN_VAL(ATTR_IDENTIFIER)
[51b7345]	50
[8c17ab0]	51	#define ASCIIOP_RETURN() RETURN_VAL((int)yytext[0]) // single character operator
	52	#define NAMEDOP_RETURN(x) RETURN_VAL(x) // multichar operator, with a name
[51b7345]	53
[8c17ab0]	54	#define NUMERIC_RETURN(x) rm_underscore(); RETURN_VAL(x) // numeric constant
[51b7345]	55
[3848e0e]	56	void rm_underscore() {
	57	// remove underscores in numeric constant
[51b7345]	58	int j = 0;
[3848e0e]	59	for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
[51b7345]	60	if ( yytext[i] != '_' ) {
	61	yytext[j] = yytext[i];
	62	j += 1;
	63	} // if
	64	} // for
	65	yyleng = j;
	66	yytext[yyleng] = '\0';
	67	}
	68
	69	%}
	70
	71	octal [0-7]
	72	nonzero [1-9]
	73	decimal [0-9]
	74	hex [0-9a-fA-F]
[3848e0e]	75	universal_char "\\"((u"_"?{hex_quad})\|(U"_"?{hex_quad}{2}))
[51b7345]	76
[8c17ab0]	77	// identifier, GCC: $ in identifier
[51b7345]	78	identifier ([a-zA-Z_$]\|{universal_char})([0-9a-zA-Z_$]\|{universal_char})*
	79
[8c17ab0]	80	// quoted identifier
	81	quoted_identifier "`"{identifier}"`"
	82
	83	// attribute identifier, GCC: $ in identifier
[51b7345]	84	attr_identifier "@"{identifier}
	85
[8c17ab0]	86	// numeric constants, CFA: '_' in constant
[3848e0e]	87	hex_quad {hex}("_"?{hex}){3}
[51b7345]	88	integer_suffix "_"?(([uU][lL]?)\|([uU]("ll"\|"LL")?)\|([lL][uU]?)\|("ll"\|"LL")[uU]?)
	89
	90	octal_digits ({octal})\|({octal}({octal}\|"_")*{octal})
	91	octal_prefix "0""_"?
	92	octal_constant (("0")\|({octal_prefix}{octal_digits})){integer_suffix}?
	93
	94	nonzero_digits ({nonzero})\|({nonzero}({decimal}\|"_")*{decimal})
	95	decimal_constant {nonzero_digits}{integer_suffix}?
	96
	97	hex_digits ({hex})\|({hex}({hex}\|"_")*{hex})
	98	hex_prefix "0"[xX]"_"?
	99	hex_constant {hex_prefix}{hex_digits}{integer_suffix}?
	100
	101	decimal_digits ({decimal})\|({decimal}({decimal}\|"_")*{decimal})
	102	fractional_constant ({decimal_digits}?"."{decimal_digits})\|({decimal_digits}".")
	103	exponent "_"?[eE]"_"?[+-]?{decimal_digits}
	104	floating_suffix "_"?[flFL]
	105	floating_constant (({fractional_constant}{exponent}?)\|({decimal_digits}{exponent})){floating_suffix}?
	106
	107	binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
	108	hex_fractional_constant ({hex_digits}?"."{hex_digits})\|({hex_digits}".")
	109	hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})\|({hex_digits}{binary_exponent})){floating_suffix}?
	110
[8c17ab0]	111	// character escape sequence, GCC: \e => esc character
[51b7345]	112	simple_escape "\\"[abefnrtv'"?\\]
[8c17ab0]	113	// ' stop highlighting
[3848e0e]	114	octal_escape "\\"{octal}("_"?{octal}){0,2}
	115	hex_escape "\\""x""_"?{hex_digits}
[51b7345]	116	escape_seq {simple_escape}\|{octal_escape}\|{hex_escape}\|{universal_char}
	117
[8c17ab0]	118	// display/white-space characters
[51b7345]	119	h_tab [\011]
	120	form_feed [\014]
	121	v_tab [\013]
	122	c_return [\015]
	123	h_white [ ]\|{h_tab}
	124
[8c17ab0]	125	// operators
[51b7345]	126	op_unary_only "~"\|"!"
	127	op_unary_binary "+"\|"-"\|"*"
	128	op_unary_pre_post "++"\|"--"
	129	op_unary {op_unary_only}\|{op_unary_binary}\|{op_unary_pre_post}
	130
	131	op_binary_only "/"\|"%"\|"^"\|"&"\|"\|"\|"<"\|">"\|"="\|"=="\|"!="\|"<<"\|">>"\|"<="\|">="\|"+="\|"-="\|"*="\|"/="\|"%="\|"&="\|"\|="\|"^="\|"<<="\|">>="
	132	op_binary_over {op_unary_binary}\|{op_binary_only}
	133	op_binary_not_over "?"\|"->"\|"&&"\|"\|\|"
	134	operator {op_unary_pre_post}\|{op_binary_over}\|{op_binary_not_over}
	135
	136	%x COMMENT
[3848e0e]	137	%x BKQUOTE
	138	%x QUOTE
	139	%x STRING
[51b7345]	140
	141	%%
	142	/* line directives */
	143	^{h_white}"#"{h_white}[0-9]+{h_white}["][^"\n]+["][^\n]"\n" {
[8c17ab0]	144	/* " stop highlighting */
[51b7345]	145	char *end_num;
	146	char begin_string, end_string;
	147	char *filename;
	148	long lineno, length;
	149	lineno = strtol( yytext + 1, &end_num, 0 );
	150	begin_string = strchr( end_num, '"' );
[3848e0e]	151	if ( begin_string ) {
	152	end_string = strchr( begin_string + 1, '"' );
	153	if ( end_string ) {
	154	length = end_string - begin_string - 1;
	155	filename = new char[ length + 1 ];
	156	memcpy( filename, begin_string + 1, length );
	157	filename[ length ] = '\0';
	158	//std::cout << "file " << filename << " line " << lineno << std::endl;
	159	yylineno = lineno;
	160	yyfilename = filename;
	161	}
[51b7345]	162	}
	163	}
	164
	165	/* ignore preprocessor directives (for now) */
	166	^{h_white}"#"[^\n]"\n" ;
	167
	168	/* ignore C style comments */
[3848e0e]	169	"/*" { BEGIN COMMENT; }
[51b7345]	170	<COMMENT>.\|\n ;
[3848e0e]	171	<COMMENT>"*/" { BEGIN 0; }
[51b7345]	172
	173	/* ignore C++ style comments */
	174	"//"[^\n]*"\n" ;
	175
	176	/* ignore whitespace */
[3848e0e]	177	{h_white}+ { WHITE_RETURN(' '); }
	178	({v_tab}\|{c_return}\|{form_feed})+ { WHITE_RETURN(' '); }
	179	({h_white}\|{v_tab}\|{c_return}\|{form_feed})*"\n" { NEWLINE_RETURN(); }
[51b7345]	180
	181	/* keywords */
[6c3744e]	182	_Alignas { KEYWORD_RETURN(ALIGNAS); } // C11
	183	_Alignof { KEYWORD_RETURN(ALIGNOF); } // C11
[3848e0e]	184	__alignof { KEYWORD_RETURN(ALIGNOF); } // GCC
	185	__alignof__ { KEYWORD_RETURN(ALIGNOF); } // GCC
	186	asm { KEYWORD_RETURN(ASM); }
	187	__asm { KEYWORD_RETURN(ASM); } // GCC
	188	__asm__ { KEYWORD_RETURN(ASM); } // GCC
[6c3744e]	189	_Atomic { KEYWORD_RETURN(ATOMIC); } // C11
[3848e0e]	190	__attribute { KEYWORD_RETURN(ATTRIBUTE); } // GCC
	191	__attribute__ { KEYWORD_RETURN(ATTRIBUTE); } // GCC
	192	auto { KEYWORD_RETURN(AUTO); }
	193	_Bool { KEYWORD_RETURN(BOOL); } // C99
	194	break { KEYWORD_RETURN(BREAK); }
	195	case { KEYWORD_RETURN(CASE); }
	196	catch { KEYWORD_RETURN(CATCH); } // CFA
	197	char { KEYWORD_RETURN(CHAR); }
	198	choose { KEYWORD_RETURN(CHOOSE); } // CFA
	199	_Complex { KEYWORD_RETURN(COMPLEX); } // C99
	200	__complex { KEYWORD_RETURN(COMPLEX); } // GCC
	201	__complex__ { KEYWORD_RETURN(COMPLEX); } // GCC
	202	const { KEYWORD_RETURN(CONST); }
	203	__const { KEYWORD_RETURN(CONST); } // GCC
	204	__const__ { KEYWORD_RETURN(CONST); } // GCC
	205	context { KEYWORD_RETURN(CONTEXT); } // CFA
	206	continue { KEYWORD_RETURN(CONTINUE); }
	207	default { KEYWORD_RETURN(DEFAULT); }
	208	do { KEYWORD_RETURN(DO); }
	209	double { KEYWORD_RETURN(DOUBLE); }
	210	dtype { KEYWORD_RETURN(DTYPE); } // CFA
	211	else { KEYWORD_RETURN(ELSE); }
	212	enum { KEYWORD_RETURN(ENUM); }
	213	__extension__ { KEYWORD_RETURN(EXTENSION); } // GCC
	214	extern { KEYWORD_RETURN(EXTERN); }
	215	fallthru { KEYWORD_RETURN(FALLTHRU); } // CFA
	216	finally { KEYWORD_RETURN(FINALLY); } // CFA
	217	float { KEYWORD_RETURN(FLOAT); }
[2c2242c]	218	__float128 { KEYWORD_RETURN(FLOAT); } // GCC
[3848e0e]	219	for { KEYWORD_RETURN(FOR); }
	220	forall { KEYWORD_RETURN(FORALL); } // CFA
	221	fortran { KEYWORD_RETURN(FORTRAN); }
	222	ftype { KEYWORD_RETURN(FTYPE); } // CFA
[6c3744e]	223	_Generic { KEYWORD_RETURN(GENERIC); } // C11
[3848e0e]	224	goto { KEYWORD_RETURN(GOTO); }
	225	if { KEYWORD_RETURN(IF); }
	226	_Imaginary { KEYWORD_RETURN(IMAGINARY); } // C99
	227	__imag { KEYWORD_RETURN(IMAGINARY); } // GCC
	228	__imag__ { KEYWORD_RETURN(IMAGINARY); } // GCC
	229	inline { KEYWORD_RETURN(INLINE); } // C99
	230	__inline { KEYWORD_RETURN(INLINE); } // GCC
	231	__inline__ { KEYWORD_RETURN(INLINE); } // GCC
	232	int { KEYWORD_RETURN(INT); }
[2c2242c]	233	__int128 { KEYWORD_RETURN(INT); } // GCC
[3848e0e]	234	__label__ { KEYWORD_RETURN(LABEL); } // GCC
	235	long { KEYWORD_RETURN(LONG); }
	236	lvalue { KEYWORD_RETURN(LVALUE); } // CFA
[6c3744e]	237	_Noreturn { KEYWORD_RETURN(NORETURN); } // C11
[3848e0e]	238	register { KEYWORD_RETURN(REGISTER); }
	239	restrict { KEYWORD_RETURN(RESTRICT); } // C99
	240	__restrict { KEYWORD_RETURN(RESTRICT); } // GCC
	241	__restrict__ { KEYWORD_RETURN(RESTRICT); } // GCC
	242	return { KEYWORD_RETURN(RETURN); }
	243	short { KEYWORD_RETURN(SHORT); }
	244	signed { KEYWORD_RETURN(SIGNED); }
	245	__signed { KEYWORD_RETURN(SIGNED); } // GCC
	246	__signed__ { KEYWORD_RETURN(SIGNED); } // GCC
	247	sizeof { KEYWORD_RETURN(SIZEOF); }
	248	static { KEYWORD_RETURN(STATIC); }
[6c3744e]	249	_Static_assert { KEYWORD_RETURN(STATICASSERT); } // C11
[3848e0e]	250	struct { KEYWORD_RETURN(STRUCT); }
	251	switch { KEYWORD_RETURN(SWITCH); }
[6c3744e]	252	_Thread_local { KEYWORD_RETURN(THREADLOCAL); } // C11
[3848e0e]	253	throw { KEYWORD_RETURN(THROW); } // CFA
	254	try { KEYWORD_RETURN(TRY); } // CFA
	255	type { KEYWORD_RETURN(TYPE); } // CFA
	256	typedef { KEYWORD_RETURN(TYPEDEF); }
	257	typeof { KEYWORD_RETURN(TYPEOF); } // GCC
	258	__typeof { KEYWORD_RETURN(TYPEOF); } // GCC
	259	__typeof__ { KEYWORD_RETURN(TYPEOF); } // GCC
	260	union { KEYWORD_RETURN(UNION); }
	261	unsigned { KEYWORD_RETURN(UNSIGNED); }
	262	void { KEYWORD_RETURN(VOID); }
	263	volatile { KEYWORD_RETURN(VOLATILE); }
	264	__volatile { KEYWORD_RETURN(VOLATILE); } // GCC
	265	__volatile__ { KEYWORD_RETURN(VOLATILE); } // GCC
	266	while { KEYWORD_RETURN(WHILE); }
[51b7345]	267
	268	/* identifier */
[3848e0e]	269	{identifier} { IDENTIFIER_RETURN(); }
	270	{attr_identifier} { ATTRIBUTE_RETURN(); }
	271	"`" { BEGIN BKQUOTE; }
	272	<BKQUOTE>{identifier} { IDENTIFIER_RETURN(); }
	273	<BKQUOTE>"`" { BEGIN 0; }
[51b7345]	274
	275	/* numeric constants */
[3848e0e]	276	"0" { NUMERIC_RETURN(ZERO); } // CFA
	277	"1" { NUMERIC_RETURN(ONE); } // CFA
	278	{decimal_constant} { NUMERIC_RETURN(INTEGERconstant); }
	279	{octal_constant} { NUMERIC_RETURN(INTEGERconstant); }
	280	{hex_constant} { NUMERIC_RETURN(INTEGERconstant); }
	281	{floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
	282	{hex_floating_constant} { NUMERIC_RETURN(FLOATINGconstant); }
[51b7345]	283
	284	/* character constant, allows empty value */
[3848e0e]	285	"L"?"_"?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
	286	<QUOTE>[^'\\\n]* { *strtext += std::string( yytext ); }
	287	<QUOTE>['\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
[8c17ab0]	288	/* ' stop highlighting */
[51b7345]	289
	290	/* string constant */
[3848e0e]	291	"L"?"_"?["] { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
	292	<STRING>[^"\\\n]* { *strtext += std::string( yytext ); }
	293	<STRING>["\n] { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
[8c17ab0]	294	/* " stop highlighting */
[51b7345]	295
[3848e0e]	296	<QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
	297	<QUOTE,STRING>[\\] { *strtext += std::string( yytext ); } // unknown escape character
	298
[51b7345]	299	/* punctuation */
[3848e0e]	300	"[" { ASCIIOP_RETURN(); }
	301	"]" { ASCIIOP_RETURN(); }
	302	"(" { ASCIIOP_RETURN(); }
	303	")" { ASCIIOP_RETURN(); }
	304	"{" { ASCIIOP_RETURN(); }
	305	"}" { ASCIIOP_RETURN(); }
	306	"," { ASCIIOP_RETURN(); } // also operator
	307	":" { ASCIIOP_RETURN(); }
	308	";" { ASCIIOP_RETURN(); }
	309	"." { ASCIIOP_RETURN(); } // also operator
	310	"..." { NAMEDOP_RETURN(ELLIPSIS); }
	311
	312	/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
	313	"<:" { RETURN_VAL('['); }
	314	":>" { RETURN_VAL(']'); }
	315	"<%" { RETURN_VAL('{'); }
	316	"%>" { RETURN_VAL('}'); }
[51b7345]	317
	318	/* operators */
[3848e0e]	319	"!" { ASCIIOP_RETURN(); }
	320	"+" { ASCIIOP_RETURN(); }
	321	"-" { ASCIIOP_RETURN(); }
	322	"*" { ASCIIOP_RETURN(); }
	323	"/" { ASCIIOP_RETURN(); }
	324	"%" { ASCIIOP_RETURN(); }
	325	"^" { ASCIIOP_RETURN(); }
	326	"~" { ASCIIOP_RETURN(); }
	327	"&" { ASCIIOP_RETURN(); }
	328	"\|" { ASCIIOP_RETURN(); }
	329	"<" { ASCIIOP_RETURN(); }
	330	">" { ASCIIOP_RETURN(); }
	331	"=" { ASCIIOP_RETURN(); }
	332	"?" { ASCIIOP_RETURN(); }
	333
	334	"++" { NAMEDOP_RETURN(ICR); }
	335	"--" { NAMEDOP_RETURN(DECR); }
	336	"==" { NAMEDOP_RETURN(EQ); }
	337	"!=" { NAMEDOP_RETURN(NE); }
	338	"<<" { NAMEDOP_RETURN(LS); }
	339	">>" { NAMEDOP_RETURN(RS); }
	340	"<=" { NAMEDOP_RETURN(LE); }
	341	">=" { NAMEDOP_RETURN(GE); }
	342	"&&" { NAMEDOP_RETURN(ANDAND); }
	343	"\|\|" { NAMEDOP_RETURN(OROR); }
	344	"->" { NAMEDOP_RETURN(ARROW); }
	345	"+=" { NAMEDOP_RETURN(PLUSassign); }
	346	"-=" { NAMEDOP_RETURN(MINUSassign); }
	347	"*=" { NAMEDOP_RETURN(MULTassign); }
	348	"/=" { NAMEDOP_RETURN(DIVassign); }
	349	"%=" { NAMEDOP_RETURN(MODassign); }
	350	"&=" { NAMEDOP_RETURN(ANDassign); }
	351	"\|=" { NAMEDOP_RETURN(ORassign); }
	352	"^=" { NAMEDOP_RETURN(ERassign); }
	353	"<<=" { NAMEDOP_RETURN(LSassign); }
	354	">>=" { NAMEDOP_RETURN(RSassign); }
[51b7345]	355
	356	/* CFA, operator identifier */
[3848e0e]	357	{op_unary}"?" { IDENTIFIER_RETURN(); } // unary
	358	"?"({op_unary_pre_post}\|"()"\|"[?]") { IDENTIFIER_RETURN(); }
	359	"?"{op_binary_over}"?" { IDENTIFIER_RETURN(); } // binary
[51b7345]	360	/*
	361	This rule handles ambiguous cases with operator identifiers, e.g., "int ??()", where the
	362	string "??" can be lexed as ""/"??" or "?"/"?". Since it is common practise to put
	363	a unary operator juxtaposed to an identifier, e.g., "*i", users will be annoyed if they
	364	cannot do this with respect to operator identifiers. Even with this special hack, there
	365	are 5 general cases that cannot be handled. The first case is for the function-call
	366	identifier "?()":
	367
	368	int * ?()(); // declaration: space required after '*'
	369	* ?()(); // expression: space required after '*'
	370
	371	Without the space, the string "*?()" is ambiguous without N character look ahead; it
	372	requires scanning ahead to determine if there is a '(', which is the start of an
	373	argument/parameter list.
	374
	375	The 4 remaining cases occur in expressions:
	376
	377	i++?i:0; // space required before '?'
	378	i--?i:0; // space required before '?'
	379	i?++i:0; // space required after '?'
	380	i?--i:0; // space required after '?'
	381
	382	In the first two cases, the string "i++?" is ambiguous, where this string can be lexed as
	383	"i"/"++?" or "i++"/"?"; it requires scanning ahead to determine if there is a '(', which
	384	is the start of an argument list. In the second two cases, the string "?++x" is
	385	ambiguous, where this string can be lexed as "?++"/"x" or "?"/"++x"; it requires scanning
	386	ahead to determine if there is a '(', which is the start of an argument list.
	387	*/
	388	{op_unary}"?"(({op_unary_pre_post}\|"[?]")\|({op_binary_over}"?")) {
	389	// 1 or 2 character unary operator ?
	390	int i = yytext[1] == '?' ? 1 : 2;
[3848e0e]	391	yyless( i ); // put back characters up to first '?'
[51b7345]	392	if ( i > 1 ) {
	393	NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
	394	} else {
	395	ASCIIOP_RETURN();
	396	} // if
	397	}
	398
	399	/* unknown characters */
[3848e0e]	400	. { printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
[51b7345]	401
	402	%%
	403
	404
[8c17ab0]	405	// Local Variables:
	406	// fill-column: 100
	407	// compile-command: "make"
	408	// End:

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format