cfmt/parens.awk at master · megacoder/cfmt · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
#!/CYGNUS/B19/H-I386~1/BIN/awk -f
function trimLeft( s,		v )	{
	v = s
	sub( /^[ \t]*/, "", v )
	return( v )
}
function trimRight( s, 		v )	{
	v = s
	sub( /[ \t]*$/, "", v )
	return( v )
}
function trim( s )	{
	return( trimLeft( trimRight( s ) ) )
}
function before( name, l, m, r )	{
	printf "%s[before] --> [%s|%s|%s]\n", name, l, m, r
}
function after( name, l, m, r )	{
	printf "%s[after] --> [%s|%s|%s]\n", name, l, m, r
}
{	sub( /[\r]/, "" )	}	# Drop \r DOS crap
{
	# Force HEX constants into uppercase, even in preprocessor
	while( match( $0, /0[Xx][0-9A-F]*[a-f][0-9a-fA-F]*/ ) > 0 )	{
		left  = substr( $0, 1, RSTART - 1 )
		mid   = substr( $0, RSTART, RLENGTH )
		right = substr( $0, RSTART + RLENGTH )
		# before( "hex constant", left, mid, right )
		mid = "0x" toupper( substr( mid, 3 ) )
		# after( "hex constant", left, mid, right )
		$0 = left mid right
	}
}
/^[ \t]*[#]/	{ print; next }		# Ignore preprocessor lines
/^[ 	]*[)]/	{ print; next }		# Ignore line w/only right paren
{
	# Separate code and comment
	if( match( $0, /[ \t]*[\/][*].*[*][\/][ \t]*$/ ) > 0 )	{
		code = trimRight( substr( $0, 1, RSTART - 1 ) )
		comment = substr( $0, RSTART )
	} else	{
		code = trimRight( $0 )
		comment = ""
	}
	# Template: [ :] --> [:]
	# Remove spaces before colons
	while( match( code, /[ \t]:/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "colon spaces", left, mid, right )
		mid = trim( mid )
		# after( "colon spaces", left, mid, right )
		code = left mid right
	}
	# Template: [token=token] --> [token = token]
	# Insert spaces around single-character operators
	while( match( code, /[a-zA-Z0-9\)][=<>\/*][a-zA-Z0-9\)]/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "operator spaces", left, mid, right )
		lop= substr( mid, 1, 1 )
		mop= substr( mid, 2, 1 )
		rop= substr( mid, 3, 1 )
		mid = lop " " mop " " rop
		# after( "operator spaces", left, mid, right )
		code = left mid right
	}
	# Template: [token==token] --> [token == token]
	# Insert spaces around double-character operators
	while(match( code, /[\]a-zA-Z0-9)][!=<>+*%-][=<>][a-zA-Z0-9)\]]/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "double-operator spaces", left, mid, right )
		lop= substr( mid, 1, 1 )
		mop= substr( mid, 2, 2 )
		rop= substr( mid, 4, 1 )
		mid = lop " " mop " " rop
		# after( "double-operator spaces", left, mid, right )
		code = left mid right
	}
	# Template: [token<<=token] --> [token <<= token]
	# Insert spaces around triple-character operators
	while( match( code, /[a-zA-Z0-9)\]][<>][<>]=[a-zA-Z0-9)\]]/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "triple-operator spaces", left, mid, right )
		lop= substr( mid, 1, 1 )
		mop= substr( mid, 2, 3 )
		rop= substr( mid, 5, 1 )
		mid = lop " " mop " " rop
		# after( "triple-operator spaces", left, mid, right )
		code = left mid right
	}
	# Template: [ptr -> field] --> [ptr->field]
	# Remove spaces round pointers
	while( match( code, /[ \t][ \t]*->[ \t][ \t]*/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "pointer spaces", left, mid, right )
		mid = trim( mid )
		# after( "pointer spaces", left, mid, right )
		code = left mid right
	}
	# Template: [word (] --> [word( ]
	# Collapse spaces bewteen words and left parens
	while( match( code, /[a-zA-Z_][a-zA-Z0-9_]*[ \t][ \t]*[(][ \t]*/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = trim( substr( code, RSTART, RLENGTH ) )
		right = trimLeft( substr( code, RSTART + RLENGTH ) )
		# before( "lparen spaces", left, mid, right )
		sub( /[ \t(].*$/, "( ", mid )
		# after( "lparen spaces", left, mid, right )
		code = left mid right
	}
	# Template: [  )] --> [ )]
	# Collapse multiple spaces before right parens
	while( match( code, /[ \t][ \t][ \t]*[)]/ ) > 0 )	{
		left  = trimRight( substr( code, 1, RSTART - 1 ) )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "rparen spaces", left, mid, right )
		code = left " )" right
		# after( "rparen spaces", left, mid, right )
	}
	# Template: [;foo] --> [; foo]
	# Enforce a space after every semicolon
	while( match( code, /;[^ \t]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "semi space", left, mid, right )
		mid = "; " substr( mid, 2 )
		# after( "semi space", left, mid, right )
		code = left mid right
	}
	# Template: [(foo] --> [( foo]
	# Enforce a space after every left paren not before another left paren
	while( match( code, /[(][^ \t(]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "space after lparen", left, mid, right )
		mid = "( " trim( substr( mid, 2 ) )
		# after( "space after lparen", left, mid, right )
		code = left mid right
	}
	# Template: [foo)] --> [foo )]
	# Enfore a space before ever right paren not after another rparen
	while( match( code, /[^ \t)*][)]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "space before rparen", left, mid, right )
		mid = substr( mid, 1, RLENGTH-1 ) " )"
		# after( "space before rparen", left, mid, right )
		code = left mid right
	}
	# Template: [( token )] --> [(token)]
	# Remove spaces around token used as a cast
	# while( match( code, /[ \t][(][ \t]*[a-zA-Z0-9_][a-zA-Z0-9_]*[ \t][)]/ ) > 0 ) {
	while( match( code, /[ \t]*[(][ \t][^-+=\/%]*[)][ \t]*/ ) > 0 ) {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "token cast spaces", left, mid, right )
		sub( /[(][ \t]*/, "(", mid )
		sub( /[ \t]*[)]/, ")", mid )
		# after( "token cast spaces", left, mid, right )
		code = left mid right
	}
	# Template: [( foo * )] --> [(foo *)]
	# Drop space after pointer before right paren of a cast
	while( match( code, /[(][^*]*[*][ \t][ \t]*[)]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "pointer cast space", left, mid, right )
		sub( /^[(][ \t]*/, "(", mid )
		sub( /[*][ \t]*[)]/, "*)", mid )
		# after( "pointer cast space", left, mid, right )
		code = left mid right
	}
	# Template: [( foo *)] --> [(foo *)]
	# Drop space after left paren of a cast
	while( match( code, /[(][ \t][^*]*[*][ \t]*[)]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "lparen cast space", left, mid, right )
		sub( /^[(][ \t]*/, "(", mid )
		sub( /[*][ \t]*[)]/, "*)", mid )
		# after( "lparen cast space", left, mid, right )
		code = left mid right
	}
	# Template: [)(] --> [) (]
	# Enfore a space between rparen--lparen
	while( match( code, /[)][(]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "rparen/lparen", left, mid, right )
		mid = ") ("
		# after( "rparen/lparen", left, mid, right )
		code = left mid right
	}
	# Template: [,foo] --> [, foo]
	# Enforce blank after comma
	while( match( code, /,[^ \t]/ ) > 0 )	{
		left  = substr( code, 1, RSTART-1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART+RLENGTH )
		# before( "blank after comma", left, mid, right )
		mid = ", " substr( mid, 2 )
		# after( "blank after comma", left, mid, right )
		code = left mid right
	}
	# Template: [return abc;] --> [return( abc );]
	# Enforce parens around return statements
	while( match( code, /return[ \t][^(][^;]*;/ ) > 0 )	{
		left  = substr( code, 1, RSTART-1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART+RLENGTH )
		# before( "return parens", left, mid, right )
		# mid == "return[ \t]*tokens...;"
		mid = "return( " trim( substr( mid, 8, RLENGTH-8 ) ) " );"
		# after( "return parens", left, mid, right )
		code = left mid right
	}
	# Template: [*( foo )] --> [*(foo)]
	# Remove layer of blanks around simple expression used a pointer
	while( match( code, /[*&][(][ \t][^()]*[)]/ ) > 0 )	{
		left  = substr( code, 1, RSTART-1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART+RLENGTH )
		# before( "pointer expr", left, mid, right )
		mid = substr( mid, 1, 1 ) "(" trim( substr( mid, 3, RLENGTH-4 ) ) ")"
		# after( "pointer expr", left, mid, right )
		code = left mid right
	}
	# Template: [ {] --> [\t{]
	# Force TAB before LBRACE not at left margin
	if( match( code, /[ \t]*[{][ \t]*$/ ) > 0 )	{
		if( RSTART > 1 )	{
			left  = substr( code, 1, RSTART - 1 )
			mid   = substr( code, RSTART, RLENGTH )
			right = substr( code, RSTART + RLENGTH )
			# before( "lbrace-bol", left, mid, right )
			mid     = "\t{"
			# after( "lbrace-bol", left, mid, right )
			code = left mid right
		}
	}
	# Template: [{foo] --> [{ foo]
	# Force space after LBRACE not at EOL
	if( match( code, /[{][^ \t]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "lbrace-leadin", left, mid, right )
		mid     = sprintf( "{ %s", substr( mid, 2 ) )
		# after( "lbrace-leadin", left, mid, right )
		code = left mid right
	}
	# Template: [}[,]$] --> [\t}[,]]
	# Force TAB before RBRACE at end of line, unless at left margin
	if( match( code, /[ \t]*[}][,]?[ \t]*$/ ) > 0 )	{
		if( RSTART > 1 )	{
			left  = substr( code, 1, RSTART - 1 )
			mid   = substr( code, RSTART, RLENGTH )
			right = substr( code, RSTART + RLENGTH )
			# before( "rbrace-eol", left, mid, right )
			mid     = sprintf( "\t%s", trim( mid ) )
			# after( "rbrace-eol", left, mid, right )
			code = left mid right
		}
	}
	# Template: [func(args)] --> [func( args )]
	# Force spaces around outermost (I hope) parens of function call
	if( match( code, /[a-zA-Z0-9_][ \t]*[(][^)(]*[)]/) > 0 ) {
		# Do not include last char of func with RE
		left  = substr( code, 1, RSTART )
		mid   = substr( code, RSTART+1, RLENGTH-1 )
		right = substr( code, RSTART + RLENGTH )
		# before( "arg-parens", left, mid, right )
		mid   = trimLeft( mid )		# Drop leading whitespace
		if( match( mid, /[(][ \t][ \t]*/ ) > 0 )	{
			# Drop any spaces after first lparen
			mid = "(" substr( mid, RSTART + RLENGTH )
		}
		if( match( mid, /[ \t][ \t]*[)]/ ) > 0 )	{
			# Drop any spaces before last rparen
			mid = substr( mid, 1, RSTART - 1 ) ")"
		}
		Lmid = length( mid )
		mid = sprintf( "( %s )", substr( mid, 2, Lmid - 2 ) )
		# after( "arg-parens", left, mid, right )
		code = left mid right
	}
	# Template: [while(args)] --> [while( args )]
	# Force spaces around outermost (I hope) parens of function call
	if( match( code, /[a-zA-Z0-9_][ \t]*[(][^)(]*[)]/) > 0 ) {
		# Do not include last char of func with RE
		left  = substr( code, 1, RSTART )
		mid   = substr( code, RSTART+1, RLENGTH-1 )
		right = substr( code, RSTART + RLENGTH )
		# before( "arg-parens", left, mid, right )
		mid   = trimLeft( mid )		# Drop leading whitespace
		if( match( mid, /[(][ \t][ \t]*/ ) > 0 )	{
			# Drop any spaces after first lparen
			mid = "(" substr( mid, RSTART + RLENGTH )
		}
		if( match( mid, /[ \t][ \t]*[)]/ ) > 0 )	{
			# Drop any spaces before last rparen
			mid = substr( mid, 1, RSTART - 1 ) ")"
		}
		Lmid = length( mid )
		mid = sprintf( "( %s )", substr( mid, 2, Lmid - 2 ) )
		# after( "arg-parens", left, mid, right )
		code = left mid right
	}
	# Template: [( )] --> [()]
	# Remove any intervening whitespace between matching parens
	while( match( code, /[(][ \t][ \t]*[)]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "rparen/lparen", left, mid, right )
		mid = "()"
		# after( "rparen/lparen", left, mid, right )
		code = left mid right
	}
	# Template: [)foo] --> [) foo]
	# Enfore a space after rparens followed by non-punctuation
	while( match( code, /[)][a-zA-Z0-9_]/ ) > 0 )	{
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "space after rparen", left, mid, right )
		mid = ") " substr( mid, 2 )
		# after( "space after rparen", left, mid, right )
		code = left mid right
	}
        # Remove bogus spaces from single quotes
        while( match( code, /['][ ][^'][']/ ) > 0 )     {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "space after rparen", left, mid, right )
                mid = "'" substr( mid, 3, 1 ) "'"
		code = left mid right
	}
        while( match( code, /['][^'][ ][']/ ) > 0 )     {
		left  = substr( code, 1, RSTART - 1 )
		mid   = substr( code, RSTART, RLENGTH )
		right = substr( code, RSTART + RLENGTH )
		# before( "space after rparen", left, mid, right )
                mid = "'" substr( mid, 2, 1 ) "'"
		code = left mid right
	}
	# Finished
	print trimRight( code comment )
}