@@ -13,11 +13,8 @@ use parse::parser;
13
13
use diagnostic:: span_handler;
14
14
use codemap:: { CodeMap , span, ExpnInfo , ExpandedFrom } ;
15
15
use ast_util:: dummy_sp;
16
+ use parse:: token;
16
17
17
- // obsolete old-style #macro code:
18
- //
19
- // syntax_expander, normal, builtin
20
- //
21
18
// new-style macro! tt code:
22
19
//
23
20
// syntax_expander_tt, syntax_expander_tt_item, mac_result,
@@ -27,12 +24,6 @@ use ast_util::dummy_sp;
27
24
// is now probably a redundant AST node, can be merged with
28
25
// ast::mac_invoc_tt.
29
26
30
- // second argument is the span to blame for general argument problems
31
- type syntax_expander_ =
32
- fn @( ext_ctxt , span , ast:: mac_arg , ast:: mac_body ) -> @ast:: expr ;
33
- // second argument is the origin of the macro, if user-defined
34
- type syntax_expander = { expander : syntax_expander_ , span : Option < span > } ;
35
-
36
27
type macro_def = { name : ~str , ext : syntax_extension } ;
37
28
38
29
type item_decorator =
@@ -56,10 +47,7 @@ enum mac_result {
56
47
57
48
enum syntax_extension {
58
49
59
- // normal() is obsolete, remove when #old_macros go away.
60
- normal( syntax_expander ) ,
61
-
62
- // #[auto_serialize] and such. will probably survive death of #old_macros
50
+ // #[auto_serialize] and such
63
51
item_decorator( item_decorator ) ,
64
52
65
53
// Token-tree expanders
@@ -73,8 +61,6 @@ enum syntax_extension {
73
61
// A temporary hard-coded map of methods for expanding syntax extension
74
62
// AST nodes into full ASTs
75
63
fn syntax_expander_table ( ) -> HashMap < ~str , syntax_extension > {
76
- fn builtin ( f : syntax_expander_ ) -> syntax_extension
77
- { normal ( { expander: f, span: None } ) }
78
64
fn builtin_normal_tt ( f : syntax_expander_tt_ ) -> syntax_extension {
79
65
normal_tt ( { expander: f, span: None } )
80
66
}
@@ -85,18 +71,19 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
85
71
syntax_expanders. insert ( ~"macro_rules",
86
72
builtin_item_tt (
87
73
ext:: tt:: macro_rules:: add_new_extension) ) ;
88
- syntax_expanders. insert ( ~"fmt", builtin ( ext:: fmt:: expand_syntax_ext) ) ;
74
+ syntax_expanders. insert ( ~"fmt",
75
+ builtin_normal_tt ( ext:: fmt:: expand_syntax_ext) ) ;
89
76
syntax_expanders. insert (
90
77
~"auto_serialize",
91
78
item_decorator ( ext:: auto_serialize:: expand_auto_serialize) ) ;
92
79
syntax_expanders. insert (
93
80
~"auto_deserialize",
94
81
item_decorator ( ext:: auto_serialize:: expand_auto_deserialize) ) ;
95
- syntax_expanders. insert ( ~"env", builtin ( ext:: env:: expand_syntax_ext) ) ;
82
+ syntax_expanders. insert ( ~"env",
83
+ builtin_normal_tt ( ext:: env:: expand_syntax_ext) ) ;
96
84
syntax_expanders. insert ( ~"concat_idents",
97
- builtin ( ext:: concat_idents:: expand_syntax_ext) ) ;
98
- syntax_expanders. insert ( ~"ident_to_str",
99
- builtin ( ext:: ident_to_str:: expand_syntax_ext) ) ;
85
+ builtin_normal_tt (
86
+ ext:: concat_idents:: expand_syntax_ext) ) ;
100
87
syntax_expanders. insert ( ~"log_syntax",
101
88
builtin_normal_tt (
102
89
ext:: log_syntax:: expand_syntax_ext) ) ;
@@ -122,21 +109,29 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
122
109
builtin_normal_tt ( ext:: quote:: expand_quote_stmt) ) ;
123
110
124
111
syntax_expanders. insert ( ~"line",
125
- builtin ( ext:: source_util:: expand_line) ) ;
112
+ builtin_normal_tt (
113
+ ext:: source_util:: expand_line) ) ;
126
114
syntax_expanders. insert ( ~"col",
127
- builtin ( ext:: source_util:: expand_col) ) ;
115
+ builtin_normal_tt (
116
+ ext:: source_util:: expand_col) ) ;
128
117
syntax_expanders. insert ( ~"file",
129
- builtin ( ext:: source_util:: expand_file) ) ;
118
+ builtin_normal_tt (
119
+ ext:: source_util:: expand_file) ) ;
130
120
syntax_expanders. insert ( ~"stringify",
131
- builtin ( ext:: source_util:: expand_stringify) ) ;
121
+ builtin_normal_tt (
122
+ ext:: source_util:: expand_stringify) ) ;
132
123
syntax_expanders. insert ( ~"include",
133
- builtin ( ext:: source_util:: expand_include) ) ;
124
+ builtin_normal_tt (
125
+ ext:: source_util:: expand_include) ) ;
134
126
syntax_expanders. insert ( ~"include_str",
135
- builtin ( ext:: source_util:: expand_include_str) ) ;
127
+ builtin_normal_tt (
128
+ ext:: source_util:: expand_include_str) ) ;
136
129
syntax_expanders. insert ( ~"include_bin",
137
- builtin ( ext:: source_util:: expand_include_bin) ) ;
130
+ builtin_normal_tt (
131
+ ext:: source_util:: expand_include_bin) ) ;
138
132
syntax_expanders. insert ( ~"module_path",
139
- builtin ( ext:: source_util:: expand_mod) ) ;
133
+ builtin_normal_tt (
134
+ ext:: source_util:: expand_mod) ) ;
140
135
syntax_expanders. insert ( ~"proto",
141
136
builtin_item_tt ( ext:: pipes:: expand_proto) ) ;
142
137
syntax_expanders. insert (
@@ -292,87 +287,39 @@ fn expr_to_ident(cx: ext_ctxt,
292
287
}
293
288
}
294
289
295
- fn get_mac_args_no_max ( cx : ext_ctxt , sp : span , arg : ast:: mac_arg ,
296
- min : uint , name : ~str ) -> ~[ @ast:: expr ] {
297
- return get_mac_args ( cx, sp, arg, min, None , name) ;
290
+ fn check_zero_tts ( cx : ext_ctxt , sp : span , tts : & [ ast:: token_tree ] ,
291
+ name : & str ) {
292
+ if tts. len ( ) != 0 {
293
+ cx. span_fatal ( sp, fmt ! ( "%s takes no arguments" , name) ) ;
294
+ }
298
295
}
299
296
300
- fn get_mac_args ( cx : ext_ctxt , sp : span , arg : ast:: mac_arg ,
301
- min : uint , max : Option < uint > , name : ~str ) -> ~[ @ast:: expr ] {
302
- match arg {
303
- Some ( expr) => match expr. node {
304
- ast:: expr_vec( elts, _) => {
305
- let elts_len = vec:: len ( elts) ;
306
- match max {
307
- Some ( max) if ! ( min <= elts_len && elts_len <= max) => {
308
- cx. span_fatal ( sp,
309
- fmt ! ( "%s! takes between %u and %u arguments." ,
310
- name, min, max) ) ;
311
- }
312
- None if ! ( min <= elts_len) => {
313
- cx. span_fatal ( sp, fmt ! ( "%s! needs at least %u arguments." ,
314
- name, min) ) ;
315
- }
316
- _ => return elts /* we are good */
317
- }
318
- }
319
- _ => {
320
- cx. span_fatal ( sp, fmt ! ( "%s!: malformed invocation" , name) )
321
- }
322
- } ,
323
- None => cx. span_fatal ( sp, fmt ! ( "%s!: missing arguments" , name) )
297
+ fn get_single_str_from_tts ( cx : ext_ctxt , sp : span , tts : & [ ast:: token_tree ] ,
298
+ name : & str ) -> ~str {
299
+ if tts. len ( ) != 1 {
300
+ cx. span_fatal ( sp, fmt ! ( "%s takes 1 argument." , name) ) ;
324
301
}
325
- }
326
302
327
- fn get_mac_body ( cx : ext_ctxt , sp : span , args : ast:: mac_body )
328
- -> ast:: mac_body_
329
- {
330
- match ( args) {
331
- Some ( body) => body,
332
- None => cx. span_fatal ( sp, ~"missing macro body")
303
+ match tts[ 0 ] {
304
+ ast:: tt_tok( _, token:: LIT_STR ( ident) ) => cx. str_of ( ident) ,
305
+ _ =>
306
+ cx. span_fatal ( sp, fmt ! ( "%s requires a string." , name) )
333
307
}
334
308
}
335
309
336
- // Massage syntactic form of new-style arguments to internal representation
337
- // of old-style macro args, such that old-style macro can be run and invoked
338
- // using new syntax. This will be obsolete when #old_macros go away.
339
- fn tt_args_to_original_flavor ( cx : ext_ctxt , sp : span , arg : ~[ ast:: token_tree ] )
340
- -> ast:: mac_arg {
341
- use ast:: { matcher, matcher_, match_tok, match_seq, match_nonterminal} ;
342
- use parse:: lexer:: { new_tt_reader, reader} ;
343
- use tt:: macro_parser:: { parse_or_else, matched_seq,
344
- matched_nonterminal} ;
345
-
346
- // these spans won't matter, anyways
347
- fn ms ( m : matcher_ ) -> matcher {
348
- { node: m, span: dummy_sp ( ) }
310
+ fn get_exprs_from_tts ( cx : ext_ctxt , tts : ~[ ast:: token_tree ] )
311
+ -> ~[ @ast:: expr ] {
312
+ let p = parse:: new_parser_from_tts ( cx. parse_sess ( ) ,
313
+ cx. cfg ( ) ,
314
+ tts) ;
315
+ let mut es = ~[ ] ;
316
+ while p. token != token:: EOF {
317
+ if es. len ( ) != 0 {
318
+ p. eat ( token:: COMMA ) ;
319
+ }
320
+ es. push ( p. parse_expr ( ) ) ;
349
321
}
350
- let arg_nm = cx. parse_sess ( ) . interner . gensym ( @~"arg") ;
351
-
352
- let argument_gram = ~[ ms ( match_seq ( ~[
353
- ms ( match_nonterminal ( arg_nm, parse:: token:: special_idents:: expr, 0 u) )
354
- ] , Some ( parse:: token:: COMMA ) , true , 0 u, 1 u) ) ] ;
355
-
356
- let arg_reader = new_tt_reader ( cx. parse_sess ( ) . span_diagnostic ,
357
- cx. parse_sess ( ) . interner , None , arg) ;
358
- let args =
359
- match parse_or_else ( cx. parse_sess ( ) , cx. cfg ( ) , arg_reader as reader ,
360
- argument_gram) . get ( arg_nm) {
361
- @matched_seq( s, _) => {
362
- do s. map ( ) |lf| {
363
- match * lf {
364
- @matched_nonterminal( parse:: token:: nt_expr( arg) ) =>
365
- arg, /* whew! list of exprs, here we come! */
366
- _ => fail ~"badly-structured parse result"
367
- }
368
- }
369
- } ,
370
- _ => fail ~"badly-structured parse result"
371
- } ;
372
-
373
- return Some ( @{ id: parse:: next_node_id ( cx. parse_sess ( ) ) ,
374
- callee_id: parse:: next_node_id ( cx. parse_sess ( ) ) ,
375
- node: ast:: expr_vec ( args, ast:: m_imm) , span: sp} ) ;
322
+ es
376
323
}
377
324
378
325
//
0 commit comments