5.16.7.10. Macro Definition

Start data section to src/flx_parse.mly[17 /35 ] Next Prev First Last
  1202: mac_arg:
  1203:   | NAME COLON FUNCTION    { snd $1, Expr }
  1204:   | NAME COLON PROCEDURE   { snd $1, Stmt }
  1205:   | NAME COLON NAME
  1206:     {
  1207:       let sr = rstoken (fst $1) (fst $3) in
  1208:       snd $1,
  1209:       match $3 with
  1210:       | (_,"ident") -> Ident
  1211:       | _ -> clierr sr "Unknown macro type"
  1212:     }
  1213:   | NAME                   { snd $1, Expr }
  1214: 
  1215: mac_args:
  1216:   | mac_arg COMMA mac_args { $1 :: $3 }
  1217:   | mac_arg                { [$1] }
  1218: 
  1219: mac_arg_list:
  1220:   | LPAR mac_args RPAR     { $2 }
  1221:   | LPAR RPAR              { [] }
  1222: 
  1223: eqop:
  1224:   | EQUAL {}
  1225:   | EQRIGHTARROW {}
  1226: 
  1227: macro_definition:
  1228:   | MACRO NAME IS expr SEMI
  1229:     {
  1230:       let
  1231:         sr = rstoken $1 $5 and
  1232:         lname = snd $2 and
  1233:         rname = $4
  1234:       in
  1235:         match rname with
  1236:         | `AST_tuple (_,ls) ->
  1237:           let ls =
  1238:             map
  1239:             (fun x -> match x with
  1240:               | `AST_name (_,x,[]) -> x
  1241:               | _ -> clierr sr "RHS must be name or name list"
  1242:             )
  1243:             ls
  1244:           in
  1245:           `AST_macro_names (sr,lname,ls)
  1246: 
  1247:         | `AST_name (_,x,[]) -> `AST_macro_name (sr,lname,x)
  1248: 
  1249:         | _ -> clierr sr "RHS must be name or name list"
  1250:     }
  1251: 
  1252:   | MACRO FOR NAME IN expr DO statement_aster DONE SEMI
  1253:     {
  1254:       let
  1255:         sr = rstoken $1 $9 and
  1256:         lname = snd $3 and
  1257:         rname = $5 and
  1258:         sts = $7
  1259:       in
  1260:         let ls = match rname with
  1261:         | `AST_name (_,rname,[]) -> [rname]
  1262:         | `AST_tuple (_,ls) ->
  1263:           map
  1264:           (fun x -> match x with
  1265:           | `AST_name (_,x,[]) -> x
  1266:           | _ -> clierr sr "RHS must be name or name list"
  1267:           )
  1268:           ls
  1269:         | _ -> clierr sr "RHS must be name list"
  1270:         in
  1271:          `AST_macro_ifor (sr, lname,ls,sts)
  1272:   }
  1273: 
  1274: 
  1275:   /*
  1276:   | MACRO NAME COLON LIST IDENT EQUAL rev_name_list SEMI
  1277:     {
  1278:       let
  1279:         sr = rstoken $1 $8 and
  1280:         lname = snd $2 and
  1281:         rnames = rev $7
  1282:       in
  1283:         `AST_macro_names (sr,lname,rnames)
  1284:     }
  1285:   */
  1286:   | MACRO NAME IS NEW SEMI
  1287:     {
  1288:       let
  1289:         sr = rstoken $1 $5 and
  1290:         lname = snd $2
  1291:       in
  1292:         `AST_macro_name (sr,lname,"")
  1293:     }
  1294: 
  1295:   | MACRO VAR macro_names EQUAL expr SEMI
  1296:     {
  1297:       let
  1298:         sr = rstoken $1 $6 and
  1299:         names = $3 and
  1300:         e = $5
  1301:       in
  1302:         `AST_macro_var (sr,names,e)
  1303:     }
  1304: 
  1305: 
  1306:   | MACRO macro_names EQUAL expr SEMI
  1307:     {
  1308:       let
  1309:         sr = rstoken $1 $5 and
  1310:         names = $2 and
  1311:         e = $4
  1312:       in
  1313:         `AST_macro_assign (sr,names,e)
  1314:     }
  1315: 
  1316: 
  1317:   | MACRO VAL macro_names EQUAL expr SEMI
  1318:     {
  1319:       let
  1320:         sr = rstoken $1 $6 and
  1321:         names = $3 and
  1322:         e = $5
  1323:       in
  1324:         `AST_macro_val (sr,names,e)
  1325:     }
  1326: 
  1327:   | MACRO VAL NAME IS tuple SEMI
  1328:     {
  1329:       let
  1330:         sr = rstoken $1 $6 and
  1331:         name = snd $3 and
  1332:         es =
  1333:           (* hacky .. (x,y) and x,y both tuples, no way
  1334:             to get a real tuple value ..
  1335:           *)
  1336:           match $5 with
  1337:           | `AST_tuple (_,es) -> es
  1338:           | x -> [x]
  1339:       in
  1340:         `AST_macro_vals (sr,name,es)
  1341:     }
  1342: 
  1343: 
  1344:   | MACRO FUNCTION NAME mac_arg_list eqop expr SEMI
  1345:     {
  1346:       let
  1347:         sr = rstoken $1 $7 and
  1348:         name = snd $3 and
  1349:         args = $4 and
  1350:         e = $6
  1351:       in
  1352:       `AST_expr_macro (sr,name,args,e)
  1353:     }
  1354: 
  1355:   | MACRO PROCEDURE NAME mac_arg_list compound
  1356:     {
  1357:       let
  1358:         sr = rsrange (slift $1) (fst $5) and
  1359:         name = snd $3 and
  1360:         args = $4 and
  1361:         sts = snd $5
  1362:       in
  1363:       `AST_stmt_macro (sr,name,args,sts)
  1364:     }
  1365: 
  1366:   | MACRO compound SEMI
  1367:     {
  1368:       let sr = rstoken $1 $3 in
  1369:       let sts = snd $2 in
  1370:       `AST_macro_block (sr,sts)
  1371:     }
  1372: 
  1373:   | MACRO FORGET macro_names SEMI
  1374:     {
  1375:       let sr = rstoken $1 $4 in
  1376:       `AST_macro_forget (sr,$3)
  1377:     }
  1378: 
  1379:   | MACRO GOTO NAME SEMI
  1380:     {
  1381:       `AST_macro_goto (rstoken $1 $4, snd $3)
  1382:     }
  1383: 
  1384:   | MACRO NAME COLONGREATER
  1385:     {
  1386:       `AST_macro_label (rstoken $1 $3, snd $2)
  1387:     }
  1388: 
  1389:   | MACRO IF expr GOTO NAME SEMI
  1390:     { `AST_macro_ifgoto (rstoken $1 $6,$3,snd $5) }
  1391: 
  1392:   | MACRO FOR VAL macro_names IN expr DO statement_aster DONE SEMI
  1393:   {
  1394:     `AST_macro_vfor (rstoken $1 $10, $4,$6,$8)
  1395:   }
  1396: 
  1397: 
  1398: macro_name_list:
  1399:   | macro_name_list COMMA NAME { snd $3 :: $1 }
  1400:   | NAME { [snd $1] }
  1401: macro_names:
  1402:   | macro_name_list { List.rev $1 }
  1403:   | { [] }
  1404: 
  1405: /*
  1406: rev_name_list:
  1407:   | NAME COMMA rev_name_list { snd $1 :: $3 }
  1408:   | NAME { [snd $1] }
  1409: */
  1410: 
End data section to src/flx_parse.mly[17]