5.16.5.10. Macro Definition

Start data section to src/flx_parse.mly[15 /33 ] Next Prev First Last
  1009: mac_arg:
  1010:   | NAME COLON FUNCTION    { snd $1, Expr }
  1011:   | NAME COLON PROCEDURE   { snd $1, Stmt }
  1012:   | NAME COLON NAME
  1013:     {
  1014:       let sr = rstoken (fst $1) (fst $3) in
  1015:       snd $1,
  1016:       match $3 with
  1017:       | (_,"ident") -> Ident
  1018:       | _ -> clierr sr "Unknown macro type"
  1019:     }
  1020:   | NAME                   { snd $1, Expr }
  1021: 
  1022: mac_args:
  1023:   | mac_arg COMMA mac_args { $1 :: $3 }
  1024:   | mac_arg                { [$1] }
  1025: 
  1026: mac_arg_list:
  1027:   | LPAR mac_args RPAR     { $2 }
  1028:   | LPAR RPAR              { [] }
  1029: 
  1030: macro_definition:
  1031:   | MACRO NAME IS expr SEMI
  1032:     {
  1033:       let
  1034:         sr = rstoken $1 $5 and
  1035:         lname = snd $2 and
  1036:         rname = $4
  1037:       in
  1038:         match rname with
  1039:         | `AST_tuple (_,ls) ->
  1040:           let ls =
  1041:             map
  1042:             (fun x -> match x with
  1043:               | `AST_name (_,x,[]) -> x
  1044:               | _ -> clierr sr "RHS must be name or name list"
  1045:             )
  1046:             ls
  1047:           in
  1048:           `AST_macro_names (sr,lname,ls)
  1049: 
  1050:         | `AST_name (_,x,[]) -> `AST_macro_name (sr,lname,x)
  1051: 
  1052:         | _ -> clierr sr "RHS must be name or name list"
  1053:     }
  1054: 
  1055:   | MACRO FOR NAME IN expr DO statement_aster DONE SEMI
  1056:     {
  1057:       let
  1058:         sr = rstoken $1 $9 and
  1059:         lname = snd $3 and
  1060:         rname = $5 and
  1061:         sts = $7
  1062:       in
  1063:         let ls = match rname with
  1064:         | `AST_name (_,rname,[]) -> [rname]
  1065:         | `AST_tuple (_,ls) ->
  1066:           map
  1067:           (fun x -> match x with
  1068:           | `AST_name (_,x,[]) -> x
  1069:           | _ -> clierr sr "RHS must be name or name list"
  1070:           )
  1071:           ls
  1072:         | _ -> clierr sr "RHS must be name list"
  1073:         in
  1074:          `AST_macro_ifor (sr, lname,ls,sts)
  1075:   }
  1076: 
  1077: 
  1078:   /*
  1079:   | MACRO NAME COLON LIST IDENT EQUAL rev_name_list SEMI
  1080:     {
  1081:       let
  1082:         sr = rstoken $1 $8 and
  1083:         lname = snd $2 and
  1084:         rnames = rev $7
  1085:       in
  1086:         `AST_macro_names (sr,lname,rnames)
  1087:     }
  1088:   */
  1089:   | MACRO NAME IS NEW SEMI
  1090:     {
  1091:       let
  1092:         sr = rstoken $1 $5 and
  1093:         lname = snd $2
  1094:       in
  1095:         `AST_macro_name (sr,lname,"")
  1096:     }
  1097: 
  1098:   | MACRO VAR macro_names EQUAL expr SEMI
  1099:     {
  1100:       let
  1101:         sr = rstoken $1 $6 and
  1102:         names = $3 and
  1103:         e = $5
  1104:       in
  1105:         `AST_macro_var (sr,names,e)
  1106:     }
  1107: 
  1108: 
  1109:   | MACRO macro_names EQUAL expr SEMI
  1110:     {
  1111:       let
  1112:         sr = rstoken $1 $5 and
  1113:         names = $2 and
  1114:         e = $4
  1115:       in
  1116:         `AST_macro_assign (sr,names,e)
  1117:     }
  1118: 
  1119: 
  1120:   | MACRO VAL macro_names EQUAL expr SEMI
  1121:     {
  1122:       let
  1123:         sr = rstoken $1 $6 and
  1124:         names = $3 and
  1125:         e = $5
  1126:       in
  1127:         `AST_macro_val (sr,names,e)
  1128:     }
  1129: 
  1130:   | MACRO VAL NAME IS tuple SEMI
  1131:     {
  1132:       let
  1133:         sr = rstoken $1 $6 and
  1134:         name = snd $3 and
  1135:         es =
  1136:           (* hacky .. (x,y) and x,y both tuples, no way
  1137:             to get a real tuple value ..
  1138:           *)
  1139:           match $5 with
  1140:           | `AST_tuple (_,es) -> es
  1141:           | x -> [x]
  1142:       in
  1143:         `AST_macro_vals (sr,name,es)
  1144:     }
  1145: 
  1146: 
  1147:   | MACRO FUNCTION NAME mac_arg_list EQUAL expr SEMI
  1148:     {
  1149:       let
  1150:         sr = rstoken $1 $7 and
  1151:         name = snd $3 and
  1152:         args = $4 and
  1153:         e = $6
  1154:       in
  1155:       `AST_expr_macro (sr,name,args,e)
  1156:     }
  1157: 
  1158:   | MACRO PROCEDURE NAME mac_arg_list compound
  1159:     {
  1160:       let
  1161:         sr = rsrange (slift $1) (fst $5) and
  1162:         name = snd $3 and
  1163:         args = $4 and
  1164:         sts = snd $5
  1165:       in
  1166:       `AST_stmt_macro (sr,name,args,sts)
  1167:     }
  1168: 
  1169:   | MACRO compound SEMI
  1170:     {
  1171:       let sr = rstoken $1 $3 in
  1172:       let sts = snd $2 in
  1173:       `AST_macro_block (sr,sts)
  1174:     }
  1175: 
  1176:   | MACRO FORGET macro_names SEMI
  1177:     {
  1178:       let sr = rstoken $1 $4 in
  1179:       `AST_macro_forget (sr,$3)
  1180:     }
  1181: 
  1182:   | MACRO GOTO NAME SEMI
  1183:     {
  1184:       `AST_macro_goto (rstoken $1 $4, snd $3)
  1185:     }
  1186: 
  1187:   | MACRO NAME COLONGREATER
  1188:     {
  1189:       `AST_macro_label (rstoken $1 $3, snd $2)
  1190:     }
  1191: 
  1192:   | MACRO IF expr GOTO NAME SEMI
  1193:     { `AST_macro_ifgoto (rstoken $1 $6,$3,snd $5) }
  1194: 
  1195:   | MACRO FOR VAL macro_names IN expr DO statement_aster DONE SEMI
  1196:   {
  1197:     `AST_macro_vfor (rstoken $1 $10, $4,$6,$8)
  1198:   }
  1199: 
  1200: 
  1201: macro_name_list:
  1202:   | macro_name_list COMMA NAME { snd $3 :: $1 }
  1203:   | NAME { [snd $1] }
  1204: macro_names:
  1205:   | macro_name_list { List.rev $1 }
  1206:   | { [] }
  1207: 
  1208: /*
  1209: rev_name_list:
  1210:   | NAME COMMA rev_name_list { snd $1 :: $3 }
  1211:   | NAME { [snd $1] }
  1212: */
  1213: 
End data section to src/flx_parse.mly[15]