| ... | ... | @@ -42,13 +42,22 @@ const Def = enum { |
| 42 | 42 | defAssignExpr, |
| 43 | 43 | defSingleAssignExpr, |
| 44 | 44 | defExpr, |
| 45 | | defBoolOrExpr, |
| 45 | defOrElseExpr, |
| 46 | defCatchExpr, |
| 47 | defRecoveryNonmixingOp, |
| 48 | defControlOp, |
| 49 | defBoolExpr, |
| 46 | 50 | defBoolAndExpr, |
| 51 | defBoolOrExpr, |
| 47 | 52 | defCompareExpr, |
| 48 | | defBitwiseExpr, |
| 49 | | defBitShiftExpr, |
| 53 | defCompareOperand, |
| 54 | defBitOp, |
| 55 | defBitwiseNonmixingOp, |
| 50 | 56 | defAdditionExpr, |
| 57 | defMulOrModExpr, |
| 58 | defModExpr, |
| 51 | 59 | defMultiplyExpr, |
| 60 | defMultiplyNonmixingOp, |
| 52 | 61 | defPrefixExpr, |
| 53 | 62 | defPrimaryExpr, |
| 54 | 63 | defIfExpr, |
| ... | ... | @@ -103,14 +112,21 @@ const Def = enum { |
| 103 | 112 | defAndOp, |
| 104 | 113 | defCompareOp, |
| 105 | 114 | defCompareOpTok, |
| 106 | | defBitwiseOp, |
| 107 | | defBitwiseOpTok, |
| 115 | defBitwiseAndOp, |
| 116 | defBitwiseAndOpTok, |
| 117 | defBitwiseOrOp, |
| 118 | defBitwiseOrOpTok, |
| 119 | defBitwiseXorOp, |
| 120 | defBitwiseXorOpTok, |
| 121 | defCatchOp, |
| 122 | defOrElseOp, |
| 108 | 123 | defBitShiftOp, |
| 109 | 124 | defBitShiftOpTok, |
| 110 | 125 | defAdditionOp, |
| 111 | 126 | defAdditionOpTok, |
| 112 | 127 | defMultiplyOp, |
| 113 | 128 | defMultiplyOpTok, |
| 129 | defModOp, |
| 114 | 130 | defPrefixOp, |
| 115 | 131 | defPrefixTypeOp, |
| 116 | 132 | defPtrMods, |
| ... | ... | @@ -290,7 +306,7 @@ const Def = enum { |
| 290 | 306 | const Parser = struct { |
| 291 | 307 | source: []const u8, |
| 292 | 308 | i: usize, |
| 293 | | depths: [272]u8, |
| 309 | depths: [288]u8, |
| 294 | 310 | pub fn parseRoot(p: *Parser) Error!bool { |
| 295 | 311 | const def_index = @backingInt(Def.defRoot); |
| 296 | 312 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| ... | ... | @@ -964,33 +980,44 @@ const Parser = struct { |
| 964 | 980 | defer p.depths[def_index] -= 1; |
| 965 | 981 | return blk_0: { |
| 966 | 982 | const pos_0 = p.i; |
| 967 | | if (try p.parseBoolOrExpr()) break :blk_0 true; |
| 983 | if (try p.parsePrefixExpr() and blk_2: { |
| 984 | const pos_2 = p.i; |
| 985 | if (try p.parseOrElseExpr()) break :blk_2 true; |
| 986 | p.i = pos_2; |
| 987 | if (try p.parseCatchExpr()) break :blk_2 true; |
| 988 | p.i = pos_2; |
| 989 | if (try p.parseBoolExpr()) break :blk_2 true; |
| 990 | p.i = pos_2; |
| 991 | break :blk_2 false; |
| 992 | }) break :blk_0 true; |
| 968 | 993 | p.i = pos_0; |
| 969 | 994 | break :blk_0 false; |
| 970 | 995 | }; |
| 971 | 996 | } |
| 972 | | pub fn parseBoolOrExpr(p: *Parser) Error!bool { |
| 973 | | const def_index = @backingInt(Def.defBoolOrExpr); |
| 997 | pub fn parseOrElseExpr(p: *Parser) Error!bool { |
| 998 | const def_index = @backingInt(Def.defOrElseExpr); |
| 974 | 999 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 975 | 1000 | p.depths[def_index] += 1; |
| 976 | 1001 | defer p.depths[def_index] -= 1; |
| 977 | 1002 | return blk_0: { |
| 978 | 1003 | const pos_0 = p.i; |
| 979 | | if (try p.parseBoolAndExpr() and blk_1: { |
| 1004 | if (blk_1: { |
| 1005 | var match_1 = false; |
| 980 | 1006 | var i_1: usize = 0; |
| 981 | 1007 | while (blk_3: { |
| 982 | 1008 | const pos_3 = p.i; |
| 983 | | if (try p.parseOrOp() and try p.parseBoolAndExpr()) break :blk_3 true; |
| 1009 | if (try p.parseOrElseOp() and try p.parsePrefixExpr()) break :blk_3 true; |
| 984 | 1010 | p.i = pos_3; |
| 985 | 1011 | break :blk_3 false; |
| 986 | 1012 | }) { |
| 1013 | match_1 = true; |
| 987 | 1014 | if (i_1 > max_depth) return error.MaxDepth; |
| 988 | 1015 | i_1 += 1; |
| 989 | 1016 | } |
| 990 | | break :blk_1 true; |
| 1017 | break :blk_1 match_1; |
| 991 | 1018 | } and blk_1: { |
| 992 | 1019 | const pos_1 = p.i; |
| 993 | | const match_1 = try p.parseOrOp(); |
| 1020 | const match_1 = try p.parseRecoveryNonmixingOp(); |
| 994 | 1021 | p.i = pos_1; |
| 995 | 1022 | break :blk_1 !match_1; |
| 996 | 1023 | }) break :blk_0 true; |
| ... | ... | @@ -998,28 +1025,30 @@ const Parser = struct { |
| 998 | 1025 | break :blk_0 false; |
| 999 | 1026 | }; |
| 1000 | 1027 | } |
| 1001 | | pub fn parseBoolAndExpr(p: *Parser) Error!bool { |
| 1002 | | const def_index = @backingInt(Def.defBoolAndExpr); |
| 1028 | pub fn parseCatchExpr(p: *Parser) Error!bool { |
| 1029 | const def_index = @backingInt(Def.defCatchExpr); |
| 1003 | 1030 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1004 | 1031 | p.depths[def_index] += 1; |
| 1005 | 1032 | defer p.depths[def_index] -= 1; |
| 1006 | 1033 | return blk_0: { |
| 1007 | 1034 | const pos_0 = p.i; |
| 1008 | | if (try p.parseCompareExpr() and blk_1: { |
| 1035 | if (blk_1: { |
| 1036 | var match_1 = false; |
| 1009 | 1037 | var i_1: usize = 0; |
| 1010 | 1038 | while (blk_3: { |
| 1011 | 1039 | const pos_3 = p.i; |
| 1012 | | if (try p.parseAndOp() and try p.parseCompareExpr()) break :blk_3 true; |
| 1040 | if (try p.parseCatchOp() and try p.parsePrefixExpr()) break :blk_3 true; |
| 1013 | 1041 | p.i = pos_3; |
| 1014 | 1042 | break :blk_3 false; |
| 1015 | 1043 | }) { |
| 1044 | match_1 = true; |
| 1016 | 1045 | if (i_1 > max_depth) return error.MaxDepth; |
| 1017 | 1046 | i_1 += 1; |
| 1018 | 1047 | } |
| 1019 | | break :blk_1 true; |
| 1048 | break :blk_1 match_1; |
| 1020 | 1049 | } and blk_1: { |
| 1021 | 1050 | const pos_1 = p.i; |
| 1022 | | const match_1 = try p.parseAndOp(); |
| 1051 | const match_1 = try p.parseRecoveryNonmixingOp(); |
| 1023 | 1052 | p.i = pos_1; |
| 1024 | 1053 | break :blk_1 !match_1; |
| 1025 | 1054 | }) break :blk_0 true; |
| ... | ... | @@ -1027,21 +1056,90 @@ const Parser = struct { |
| 1027 | 1056 | break :blk_0 false; |
| 1028 | 1057 | }; |
| 1029 | 1058 | } |
| 1030 | | pub fn parseCompareExpr(p: *Parser) Error!bool { |
| 1031 | | const def_index = @backingInt(Def.defCompareExpr); |
| 1059 | pub fn parseRecoveryNonmixingOp(p: *Parser) Error!bool { |
| 1060 | const def_index = @backingInt(Def.defRecoveryNonmixingOp); |
| 1032 | 1061 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1033 | 1062 | p.depths[def_index] += 1; |
| 1034 | 1063 | defer p.depths[def_index] -= 1; |
| 1035 | 1064 | return blk_0: { |
| 1036 | 1065 | const pos_0 = p.i; |
| 1037 | | if (try p.parseBitwiseExpr() and (blk_3: { |
| 1038 | | const pos_3 = p.i; |
| 1039 | | if (try p.parseCompareOp() and try p.parseBitwiseExpr()) break :blk_3 true; |
| 1040 | | p.i = pos_3; |
| 1041 | | break :blk_3 false; |
| 1042 | | } or true) and blk_1: { |
| 1066 | if (try p.parseControlOp()) break :blk_0 true; |
| 1067 | p.i = pos_0; |
| 1068 | if (try p.parseCompareOp()) break :blk_0 true; |
| 1069 | p.i = pos_0; |
| 1070 | if (try p.parseBitwiseNonmixingOp()) break :blk_0 true; |
| 1071 | p.i = pos_0; |
| 1072 | break :blk_0 false; |
| 1073 | }; |
| 1074 | } |
| 1075 | pub fn parseControlOp(p: *Parser) Error!bool { |
| 1076 | const def_index = @backingInt(Def.defControlOp); |
| 1077 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1078 | p.depths[def_index] += 1; |
| 1079 | defer p.depths[def_index] -= 1; |
| 1080 | return blk_0: { |
| 1081 | const pos_0 = p.i; |
| 1082 | if (try p.parseOrElseOp()) break :blk_0 true; |
| 1083 | p.i = pos_0; |
| 1084 | if (try p.parseCatchOp()) break :blk_0 true; |
| 1085 | p.i = pos_0; |
| 1086 | if (try p.parseAndOp()) break :blk_0 true; |
| 1087 | p.i = pos_0; |
| 1088 | if (try p.parseOrOp()) break :blk_0 true; |
| 1089 | p.i = pos_0; |
| 1090 | break :blk_0 false; |
| 1091 | }; |
| 1092 | } |
| 1093 | pub fn parseBoolExpr(p: *Parser) Error!bool { |
| 1094 | const def_index = @backingInt(Def.defBoolExpr); |
| 1095 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1096 | p.depths[def_index] += 1; |
| 1097 | defer p.depths[def_index] -= 1; |
| 1098 | return blk_0: { |
| 1099 | const pos_0 = p.i; |
| 1100 | if (try p.parseCompareExpr() and blk_2: { |
| 1101 | const pos_2 = p.i; |
| 1102 | if (try p.parseBoolAndExpr()) break :blk_2 true; |
| 1103 | p.i = pos_2; |
| 1104 | if (try p.parseBoolOrExpr()) break :blk_2 true; |
| 1105 | p.i = pos_2; |
| 1106 | if (blk_3: { |
| 1107 | const pos_3 = p.i; |
| 1108 | const match_3 = try p.parseControlOp(); |
| 1109 | p.i = pos_3; |
| 1110 | break :blk_3 !match_3; |
| 1111 | }) break :blk_2 true; |
| 1112 | p.i = pos_2; |
| 1113 | break :blk_2 false; |
| 1114 | }) break :blk_0 true; |
| 1115 | p.i = pos_0; |
| 1116 | break :blk_0 false; |
| 1117 | }; |
| 1118 | } |
| 1119 | pub fn parseBoolAndExpr(p: *Parser) Error!bool { |
| 1120 | const def_index = @backingInt(Def.defBoolAndExpr); |
| 1121 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1122 | p.depths[def_index] += 1; |
| 1123 | defer p.depths[def_index] -= 1; |
| 1124 | return blk_0: { |
| 1125 | const pos_0 = p.i; |
| 1126 | if (blk_1: { |
| 1127 | var match_1 = false; |
| 1128 | var i_1: usize = 0; |
| 1129 | while (blk_3: { |
| 1130 | const pos_3 = p.i; |
| 1131 | if (try p.parseAndOp() and try p.parsePrefixExpr() and try p.parseCompareExpr()) break :blk_3 true; |
| 1132 | p.i = pos_3; |
| 1133 | break :blk_3 false; |
| 1134 | }) { |
| 1135 | match_1 = true; |
| 1136 | if (i_1 > max_depth) return error.MaxDepth; |
| 1137 | i_1 += 1; |
| 1138 | } |
| 1139 | break :blk_1 match_1; |
| 1140 | } and blk_1: { |
| 1043 | 1141 | const pos_1 = p.i; |
| 1044 | | const match_1 = try p.parseCompareOp(); |
| 1142 | const match_1 = try p.parseControlOp(); |
| 1045 | 1143 | p.i = pos_1; |
| 1046 | 1144 | break :blk_1 !match_1; |
| 1047 | 1145 | }) break :blk_0 true; |
| ... | ... | @@ -1049,28 +1147,30 @@ const Parser = struct { |
| 1049 | 1147 | break :blk_0 false; |
| 1050 | 1148 | }; |
| 1051 | 1149 | } |
| 1052 | | pub fn parseBitwiseExpr(p: *Parser) Error!bool { |
| 1053 | | const def_index = @backingInt(Def.defBitwiseExpr); |
| 1150 | pub fn parseBoolOrExpr(p: *Parser) Error!bool { |
| 1151 | const def_index = @backingInt(Def.defBoolOrExpr); |
| 1054 | 1152 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1055 | 1153 | p.depths[def_index] += 1; |
| 1056 | 1154 | defer p.depths[def_index] -= 1; |
| 1057 | 1155 | return blk_0: { |
| 1058 | 1156 | const pos_0 = p.i; |
| 1059 | | if (try p.parseBitShiftExpr() and blk_1: { |
| 1157 | if (blk_1: { |
| 1158 | var match_1 = false; |
| 1060 | 1159 | var i_1: usize = 0; |
| 1061 | 1160 | while (blk_3: { |
| 1062 | 1161 | const pos_3 = p.i; |
| 1063 | | if (try p.parseBitwiseOp() and try p.parseBitShiftExpr()) break :blk_3 true; |
| 1162 | if (try p.parseOrOp() and try p.parsePrefixExpr() and try p.parseCompareExpr()) break :blk_3 true; |
| 1064 | 1163 | p.i = pos_3; |
| 1065 | 1164 | break :blk_3 false; |
| 1066 | 1165 | }) { |
| 1166 | match_1 = true; |
| 1067 | 1167 | if (i_1 > max_depth) return error.MaxDepth; |
| 1068 | 1168 | i_1 += 1; |
| 1069 | 1169 | } |
| 1070 | | break :blk_1 true; |
| 1170 | break :blk_1 match_1; |
| 1071 | 1171 | } and blk_1: { |
| 1072 | 1172 | const pos_1 = p.i; |
| 1073 | | const match_1 = try p.parseBitwiseOp(); |
| 1173 | const match_1 = try p.parseControlOp(); |
| 1074 | 1174 | p.i = pos_1; |
| 1075 | 1175 | break :blk_1 !match_1; |
| 1076 | 1176 | }) break :blk_0 true; |
| ... | ... | @@ -1078,32 +1178,153 @@ const Parser = struct { |
| 1078 | 1178 | break :blk_0 false; |
| 1079 | 1179 | }; |
| 1080 | 1180 | } |
| 1081 | | pub fn parseBitShiftExpr(p: *Parser) Error!bool { |
| 1082 | | const def_index = @backingInt(Def.defBitShiftExpr); |
| 1181 | pub fn parseCompareExpr(p: *Parser) Error!bool { |
| 1182 | const def_index = @backingInt(Def.defCompareExpr); |
| 1083 | 1183 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1084 | 1184 | p.depths[def_index] += 1; |
| 1085 | 1185 | defer p.depths[def_index] -= 1; |
| 1086 | 1186 | return blk_0: { |
| 1087 | 1187 | const pos_0 = p.i; |
| 1088 | | if (try p.parseAdditionExpr() and blk_1: { |
| 1188 | if (try p.parseCompareOperand() and (blk_3: { |
| 1189 | const pos_3 = p.i; |
| 1190 | if (try p.parseCompareOp() and try p.parsePrefixExpr() and try p.parseCompareOperand()) break :blk_3 true; |
| 1191 | p.i = pos_3; |
| 1192 | break :blk_3 false; |
| 1193 | } or true) and blk_1: { |
| 1194 | const pos_1 = p.i; |
| 1195 | const match_1 = blk_3: { |
| 1196 | const pos_3 = p.i; |
| 1197 | if (try p.parseCompareOp()) break :blk_3 true; |
| 1198 | p.i = pos_3; |
| 1199 | if (try p.parseOrElseOp()) break :blk_3 true; |
| 1200 | p.i = pos_3; |
| 1201 | if (try p.parseCatchOp()) break :blk_3 true; |
| 1202 | p.i = pos_3; |
| 1203 | break :blk_3 false; |
| 1204 | }; |
| 1205 | p.i = pos_1; |
| 1206 | break :blk_1 !match_1; |
| 1207 | }) break :blk_0 true; |
| 1208 | p.i = pos_0; |
| 1209 | break :blk_0 false; |
| 1210 | }; |
| 1211 | } |
| 1212 | pub fn parseCompareOperand(p: *Parser) Error!bool { |
| 1213 | const def_index = @backingInt(Def.defCompareOperand); |
| 1214 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1215 | p.depths[def_index] += 1; |
| 1216 | defer p.depths[def_index] -= 1; |
| 1217 | return blk_0: { |
| 1218 | const pos_0 = p.i; |
| 1219 | if (blk_1: { |
| 1220 | var match_1 = false; |
| 1089 | 1221 | var i_1: usize = 0; |
| 1090 | 1222 | while (blk_3: { |
| 1091 | 1223 | const pos_3 = p.i; |
| 1092 | | if (try p.parseBitShiftOp() and try p.parseAdditionExpr()) break :blk_3 true; |
| 1224 | if (try p.parseBitwiseOrOp() and try p.parsePrefixExpr()) break :blk_3 true; |
| 1093 | 1225 | p.i = pos_3; |
| 1094 | 1226 | break :blk_3 false; |
| 1095 | 1227 | }) { |
| 1228 | match_1 = true; |
| 1096 | 1229 | if (i_1 > max_depth) return error.MaxDepth; |
| 1097 | 1230 | i_1 += 1; |
| 1098 | 1231 | } |
| 1099 | | break :blk_1 true; |
| 1232 | break :blk_1 match_1; |
| 1233 | } and blk_1: { |
| 1234 | const pos_1 = p.i; |
| 1235 | const match_1 = try p.parseBitwiseNonmixingOp(); |
| 1236 | p.i = pos_1; |
| 1237 | break :blk_1 !match_1; |
| 1238 | }) break :blk_0 true; |
| 1239 | p.i = pos_0; |
| 1240 | if (blk_1: { |
| 1241 | var match_1 = false; |
| 1242 | var i_1: usize = 0; |
| 1243 | while (blk_3: { |
| 1244 | const pos_3 = p.i; |
| 1245 | if (try p.parseBitwiseAndOp() and try p.parsePrefixExpr()) break :blk_3 true; |
| 1246 | p.i = pos_3; |
| 1247 | break :blk_3 false; |
| 1248 | }) { |
| 1249 | match_1 = true; |
| 1250 | if (i_1 > max_depth) return error.MaxDepth; |
| 1251 | i_1 += 1; |
| 1252 | } |
| 1253 | break :blk_1 match_1; |
| 1254 | } and blk_1: { |
| 1255 | const pos_1 = p.i; |
| 1256 | const match_1 = try p.parseBitwiseNonmixingOp(); |
| 1257 | p.i = pos_1; |
| 1258 | break :blk_1 !match_1; |
| 1259 | }) break :blk_0 true; |
| 1260 | p.i = pos_0; |
| 1261 | if (blk_1: { |
| 1262 | var match_1 = false; |
| 1263 | var i_1: usize = 0; |
| 1264 | while (blk_3: { |
| 1265 | const pos_3 = p.i; |
| 1266 | if (try p.parseBitwiseXorOp() and try p.parsePrefixExpr()) break :blk_3 true; |
| 1267 | p.i = pos_3; |
| 1268 | break :blk_3 false; |
| 1269 | }) { |
| 1270 | match_1 = true; |
| 1271 | if (i_1 > max_depth) return error.MaxDepth; |
| 1272 | i_1 += 1; |
| 1273 | } |
| 1274 | break :blk_1 match_1; |
| 1100 | 1275 | } and blk_1: { |
| 1101 | 1276 | const pos_1 = p.i; |
| 1102 | | const match_1 = try p.parseBitShiftOp(); |
| 1277 | const match_1 = try p.parseBitwiseNonmixingOp(); |
| 1103 | 1278 | p.i = pos_1; |
| 1104 | 1279 | break :blk_1 !match_1; |
| 1105 | 1280 | }) break :blk_0 true; |
| 1106 | 1281 | p.i = pos_0; |
| 1282 | if (try p.parseBitShiftOp() and try p.parsePrefixExpr() and blk_1: { |
| 1283 | const pos_1 = p.i; |
| 1284 | const match_1 = try p.parseBitwiseNonmixingOp(); |
| 1285 | p.i = pos_1; |
| 1286 | break :blk_1 !match_1; |
| 1287 | }) break :blk_0 true; |
| 1288 | p.i = pos_0; |
| 1289 | if (blk_1: { |
| 1290 | const pos_1 = p.i; |
| 1291 | const match_1 = try p.parseBitOp(); |
| 1292 | p.i = pos_1; |
| 1293 | break :blk_1 !match_1; |
| 1294 | } and try p.parseAdditionExpr()) break :blk_0 true; |
| 1295 | p.i = pos_0; |
| 1296 | break :blk_0 false; |
| 1297 | }; |
| 1298 | } |
| 1299 | pub fn parseBitOp(p: *Parser) Error!bool { |
| 1300 | const def_index = @backingInt(Def.defBitOp); |
| 1301 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1302 | p.depths[def_index] += 1; |
| 1303 | defer p.depths[def_index] -= 1; |
| 1304 | return blk_0: { |
| 1305 | const pos_0 = p.i; |
| 1306 | if (try p.parseBitwiseOrOp()) break :blk_0 true; |
| 1307 | p.i = pos_0; |
| 1308 | if (try p.parseBitwiseAndOp()) break :blk_0 true; |
| 1309 | p.i = pos_0; |
| 1310 | if (try p.parseBitwiseXorOp()) break :blk_0 true; |
| 1311 | p.i = pos_0; |
| 1312 | if (try p.parseBitShiftOp()) break :blk_0 true; |
| 1313 | p.i = pos_0; |
| 1314 | break :blk_0 false; |
| 1315 | }; |
| 1316 | } |
| 1317 | pub fn parseBitwiseNonmixingOp(p: *Parser) Error!bool { |
| 1318 | const def_index = @backingInt(Def.defBitwiseNonmixingOp); |
| 1319 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1320 | p.depths[def_index] += 1; |
| 1321 | defer p.depths[def_index] -= 1; |
| 1322 | return blk_0: { |
| 1323 | const pos_0 = p.i; |
| 1324 | if (try p.parseMultiplyNonmixingOp()) break :blk_0 true; |
| 1325 | p.i = pos_0; |
| 1326 | if (try p.parseAdditionOp()) break :blk_0 true; |
| 1327 | p.i = pos_0; |
| 1107 | 1328 | break :blk_0 false; |
| 1108 | 1329 | }; |
| 1109 | 1330 | } |
| ... | ... | @@ -1114,11 +1335,11 @@ const Parser = struct { |
| 1114 | 1335 | defer p.depths[def_index] -= 1; |
| 1115 | 1336 | return blk_0: { |
| 1116 | 1337 | const pos_0 = p.i; |
| 1117 | | if (try p.parseMultiplyExpr() and blk_1: { |
| 1338 | if (try p.parseMulOrModExpr() and blk_1: { |
| 1118 | 1339 | var i_1: usize = 0; |
| 1119 | 1340 | while (blk_3: { |
| 1120 | 1341 | const pos_3 = p.i; |
| 1121 | | if (try p.parseAdditionOp() and try p.parseMultiplyExpr()) break :blk_3 true; |
| 1342 | if (try p.parseAdditionOp() and try p.parsePrefixExpr() and try p.parseMulOrModExpr()) break :blk_3 true; |
| 1122 | 1343 | p.i = pos_3; |
| 1123 | 1344 | break :blk_3 false; |
| 1124 | 1345 | }) { |
| ... | ... | @@ -1128,7 +1349,54 @@ const Parser = struct { |
| 1128 | 1349 | break :blk_1 true; |
| 1129 | 1350 | } and blk_1: { |
| 1130 | 1351 | const pos_1 = p.i; |
| 1131 | | const match_1 = try p.parseAdditionOp(); |
| 1352 | const match_1 = blk_3: { |
| 1353 | const pos_3 = p.i; |
| 1354 | if (try p.parseAdditionOp()) break :blk_3 true; |
| 1355 | p.i = pos_3; |
| 1356 | if (try p.parseBitOp()) break :blk_3 true; |
| 1357 | p.i = pos_3; |
| 1358 | if (try p.parseOrElseOp()) break :blk_3 true; |
| 1359 | p.i = pos_3; |
| 1360 | if (try p.parseCatchOp()) break :blk_3 true; |
| 1361 | p.i = pos_3; |
| 1362 | break :blk_3 false; |
| 1363 | }; |
| 1364 | p.i = pos_1; |
| 1365 | break :blk_1 !match_1; |
| 1366 | }) break :blk_0 true; |
| 1367 | p.i = pos_0; |
| 1368 | break :blk_0 false; |
| 1369 | }; |
| 1370 | } |
| 1371 | pub fn parseMulOrModExpr(p: *Parser) Error!bool { |
| 1372 | const def_index = @backingInt(Def.defMulOrModExpr); |
| 1373 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1374 | p.depths[def_index] += 1; |
| 1375 | defer p.depths[def_index] -= 1; |
| 1376 | return blk_0: { |
| 1377 | const pos_0 = p.i; |
| 1378 | if (try p.parseModExpr()) break :blk_0 true; |
| 1379 | p.i = pos_0; |
| 1380 | if (blk_1: { |
| 1381 | const pos_1 = p.i; |
| 1382 | const match_1 = try p.parseModOp(); |
| 1383 | p.i = pos_1; |
| 1384 | break :blk_1 !match_1; |
| 1385 | } and try p.parseMultiplyExpr()) break :blk_0 true; |
| 1386 | p.i = pos_0; |
| 1387 | break :blk_0 false; |
| 1388 | }; |
| 1389 | } |
| 1390 | pub fn parseModExpr(p: *Parser) Error!bool { |
| 1391 | const def_index = @backingInt(Def.defModExpr); |
| 1392 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1393 | p.depths[def_index] += 1; |
| 1394 | defer p.depths[def_index] -= 1; |
| 1395 | return blk_0: { |
| 1396 | const pos_0 = p.i; |
| 1397 | if (try p.parseModOp() and try p.parsePrefixExpr() and blk_1: { |
| 1398 | const pos_1 = p.i; |
| 1399 | const match_1 = try p.parseMultiplyNonmixingOp(); |
| 1132 | 1400 | p.i = pos_1; |
| 1133 | 1401 | break :blk_1 !match_1; |
| 1134 | 1402 | }) break :blk_0 true; |
| ... | ... | @@ -1143,7 +1411,7 @@ const Parser = struct { |
| 1143 | 1411 | defer p.depths[def_index] -= 1; |
| 1144 | 1412 | return blk_0: { |
| 1145 | 1413 | const pos_0 = p.i; |
| 1146 | | if (try p.parsePrefixExpr() and blk_1: { |
| 1414 | if (blk_1: { |
| 1147 | 1415 | var i_1: usize = 0; |
| 1148 | 1416 | while (blk_3: { |
| 1149 | 1417 | const pos_3 = p.i; |
| ... | ... | @@ -1157,7 +1425,7 @@ const Parser = struct { |
| 1157 | 1425 | break :blk_1 true; |
| 1158 | 1426 | } and blk_1: { |
| 1159 | 1427 | const pos_1 = p.i; |
| 1160 | | const match_1 = try p.parseMultiplyOp(); |
| 1428 | const match_1 = try p.parseMultiplyNonmixingOp(); |
| 1161 | 1429 | p.i = pos_1; |
| 1162 | 1430 | break :blk_1 !match_1; |
| 1163 | 1431 | }) break :blk_0 true; |
| ... | ... | @@ -1165,6 +1433,26 @@ const Parser = struct { |
| 1165 | 1433 | break :blk_0 false; |
| 1166 | 1434 | }; |
| 1167 | 1435 | } |
| 1436 | pub fn parseMultiplyNonmixingOp(p: *Parser) Error!bool { |
| 1437 | const def_index = @backingInt(Def.defMultiplyNonmixingOp); |
| 1438 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 1439 | p.depths[def_index] += 1; |
| 1440 | defer p.depths[def_index] -= 1; |
| 1441 | return blk_0: { |
| 1442 | const pos_0 = p.i; |
| 1443 | if (try p.parseMultiplyOp()) break :blk_0 true; |
| 1444 | p.i = pos_0; |
| 1445 | if (try p.parseModOp()) break :blk_0 true; |
| 1446 | p.i = pos_0; |
| 1447 | if (try p.parseBitOp()) break :blk_0 true; |
| 1448 | p.i = pos_0; |
| 1449 | if (try p.parseOrElseOp()) break :blk_0 true; |
| 1450 | p.i = pos_0; |
| 1451 | if (try p.parseCatchOp()) break :blk_0 true; |
| 1452 | p.i = pos_0; |
| 1453 | break :blk_0 false; |
| 1454 | }; |
| 1455 | } |
| 1168 | 1456 | pub fn parsePrefixExpr(p: *Parser) Error!bool { |
| 1169 | 1457 | const def_index = @backingInt(Def.defPrefixExpr); |
| 1170 | 1458 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| ... | ... | @@ -2259,70 +2547,170 @@ const Parser = struct { |
| 2259 | 2547 | break :blk_0 false; |
| 2260 | 2548 | }; |
| 2261 | 2549 | } |
| 2262 | | pub fn parseBitwiseOp(p: *Parser) Error!bool { |
| 2263 | | const def_index = @backingInt(Def.defBitwiseOp); |
| 2550 | pub fn parseBitwiseAndOp(p: *Parser) Error!bool { |
| 2551 | const def_index = @backingInt(Def.defBitwiseAndOp); |
| 2264 | 2552 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2265 | 2553 | p.depths[def_index] += 1; |
| 2266 | 2554 | defer p.depths[def_index] -= 1; |
| 2267 | 2555 | return blk_0: { |
| 2268 | 2556 | const pos_0 = p.i; |
| 2269 | | if (try p.parsepre_op_white() and try p.parseBitwiseOpTok() and try p.parsepost_op_white()) break :blk_0 true; |
| 2557 | if (try p.parsepre_op_white() and try p.parseBitwiseAndOpTok() and try p.parsepost_op_white()) break :blk_0 true; |
| 2270 | 2558 | p.i = pos_0; |
| 2271 | 2559 | if (blk_1: { |
| 2272 | 2560 | const pos_1 = p.i; |
| 2273 | 2561 | const match_1 = try p.parsepre_op_white(); |
| 2274 | 2562 | p.i = pos_1; |
| 2275 | 2563 | break :blk_1 !match_1; |
| 2276 | | } and try p.parseBitwiseOpTok() and blk_1: { |
| 2564 | } and try p.parseBitwiseAndOpTok() and blk_1: { |
| 2277 | 2565 | const pos_1 = p.i; |
| 2278 | 2566 | const match_1 = try p.parsepost_op_white(); |
| 2279 | 2567 | p.i = pos_1; |
| 2280 | 2568 | break :blk_1 !match_1; |
| 2281 | 2569 | }) break :blk_0 true; |
| 2282 | 2570 | p.i = pos_0; |
| 2283 | | if (try p.parsepre_op_white() and try p.parseKEYWORD_catch() and try p.parsepost_op_white() and (try p.parsePayload() or true)) break :blk_0 true; |
| 2571 | break :blk_0 false; |
| 2572 | }; |
| 2573 | } |
| 2574 | pub fn parseBitwiseAndOpTok(p: *Parser) Error!bool { |
| 2575 | const def_index = @backingInt(Def.defBitwiseAndOpTok); |
| 2576 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2577 | p.depths[def_index] += 1; |
| 2578 | defer p.depths[def_index] -= 1; |
| 2579 | return blk_0: { |
| 2580 | const pos_0 = p.i; |
| 2581 | if (try p.parseAMPERSAND() and blk_1: { |
| 2582 | const pos_1 = p.i; |
| 2583 | const match_1 = (p.i < p.source.len and switch (p.source[p.i]) { |
| 2584 | '&'...'&', |
| 2585 | => blk_2: { |
| 2586 | p.i += 1; |
| 2587 | break :blk_2 true; |
| 2588 | }, |
| 2589 | else => false, |
| 2590 | }); |
| 2591 | p.i = pos_1; |
| 2592 | break :blk_1 !match_1; |
| 2593 | }) break :blk_0 true; |
| 2594 | p.i = pos_0; |
| 2595 | break :blk_0 false; |
| 2596 | }; |
| 2597 | } |
| 2598 | pub fn parseBitwiseOrOp(p: *Parser) Error!bool { |
| 2599 | const def_index = @backingInt(Def.defBitwiseOrOp); |
| 2600 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2601 | p.depths[def_index] += 1; |
| 2602 | defer p.depths[def_index] -= 1; |
| 2603 | return blk_0: { |
| 2604 | const pos_0 = p.i; |
| 2605 | if (try p.parsepre_op_white() and try p.parseBitwiseOrOpTok() and try p.parsepost_op_white()) break :blk_0 true; |
| 2284 | 2606 | p.i = pos_0; |
| 2285 | 2607 | if (blk_1: { |
| 2286 | 2608 | const pos_1 = p.i; |
| 2287 | 2609 | const match_1 = try p.parsepre_op_white(); |
| 2288 | 2610 | p.i = pos_1; |
| 2289 | 2611 | break :blk_1 !match_1; |
| 2290 | | } and try p.parseKEYWORD_catch() and blk_1: { |
| 2612 | } and try p.parseBitwiseOrOpTok() and blk_1: { |
| 2291 | 2613 | const pos_1 = p.i; |
| 2292 | 2614 | const match_1 = try p.parsepost_op_white(); |
| 2293 | 2615 | p.i = pos_1; |
| 2294 | 2616 | break :blk_1 !match_1; |
| 2295 | | } and (try p.parsePayload() or true)) break :blk_0 true; |
| 2617 | }) break :blk_0 true; |
| 2296 | 2618 | p.i = pos_0; |
| 2297 | 2619 | break :blk_0 false; |
| 2298 | 2620 | }; |
| 2299 | 2621 | } |
| 2300 | | pub fn parseBitwiseOpTok(p: *Parser) Error!bool { |
| 2301 | | const def_index = @backingInt(Def.defBitwiseOpTok); |
| 2622 | pub fn parseBitwiseOrOpTok(p: *Parser) Error!bool { |
| 2623 | const def_index = @backingInt(Def.defBitwiseOrOpTok); |
| 2302 | 2624 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2303 | 2625 | p.depths[def_index] += 1; |
| 2304 | 2626 | defer p.depths[def_index] -= 1; |
| 2305 | 2627 | return blk_0: { |
| 2306 | 2628 | const pos_0 = p.i; |
| 2307 | | if (try p.parseAMPERSAND() and blk_1: { |
| 2629 | if (try p.parsePIPE()) break :blk_0 true; |
| 2630 | p.i = pos_0; |
| 2631 | break :blk_0 false; |
| 2632 | }; |
| 2633 | } |
| 2634 | pub fn parseBitwiseXorOp(p: *Parser) Error!bool { |
| 2635 | const def_index = @backingInt(Def.defBitwiseXorOp); |
| 2636 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2637 | p.depths[def_index] += 1; |
| 2638 | defer p.depths[def_index] -= 1; |
| 2639 | return blk_0: { |
| 2640 | const pos_0 = p.i; |
| 2641 | if (try p.parsepre_op_white() and try p.parseBitwiseXorOpTok() and try p.parsepost_op_white()) break :blk_0 true; |
| 2642 | p.i = pos_0; |
| 2643 | if (blk_1: { |
| 2308 | 2644 | const pos_1 = p.i; |
| 2309 | | const match_1 = (p.i < p.source.len and switch (p.source[p.i]) { |
| 2310 | | '&'...'&', |
| 2311 | | => blk_2: { |
| 2312 | | p.i += 1; |
| 2313 | | break :blk_2 true; |
| 2314 | | }, |
| 2315 | | else => false, |
| 2316 | | }); |
| 2645 | const match_1 = try p.parsepre_op_white(); |
| 2646 | p.i = pos_1; |
| 2647 | break :blk_1 !match_1; |
| 2648 | } and try p.parseBitwiseXorOpTok() and blk_1: { |
| 2649 | const pos_1 = p.i; |
| 2650 | const match_1 = try p.parsepost_op_white(); |
| 2317 | 2651 | p.i = pos_1; |
| 2318 | 2652 | break :blk_1 !match_1; |
| 2319 | 2653 | }) break :blk_0 true; |
| 2320 | 2654 | p.i = pos_0; |
| 2655 | break :blk_0 false; |
| 2656 | }; |
| 2657 | } |
| 2658 | pub fn parseBitwiseXorOpTok(p: *Parser) Error!bool { |
| 2659 | const def_index = @backingInt(Def.defBitwiseXorOpTok); |
| 2660 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2661 | p.depths[def_index] += 1; |
| 2662 | defer p.depths[def_index] -= 1; |
| 2663 | return blk_0: { |
| 2664 | const pos_0 = p.i; |
| 2321 | 2665 | if (try p.parseCARET()) break :blk_0 true; |
| 2322 | 2666 | p.i = pos_0; |
| 2323 | | if (try p.parsePIPE()) break :blk_0 true; |
| 2667 | break :blk_0 false; |
| 2668 | }; |
| 2669 | } |
| 2670 | pub fn parseCatchOp(p: *Parser) Error!bool { |
| 2671 | const def_index = @backingInt(Def.defCatchOp); |
| 2672 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2673 | p.depths[def_index] += 1; |
| 2674 | defer p.depths[def_index] -= 1; |
| 2675 | return blk_0: { |
| 2676 | const pos_0 = p.i; |
| 2677 | if (try p.parsepre_op_white() and try p.parseKEYWORD_catch() and try p.parsepost_op_white() and (try p.parsePayload() or true)) break :blk_0 true; |
| 2324 | 2678 | p.i = pos_0; |
| 2325 | | if (try p.parseKEYWORD_orelse()) break :blk_0 true; |
| 2679 | if (blk_1: { |
| 2680 | const pos_1 = p.i; |
| 2681 | const match_1 = try p.parsepre_op_white(); |
| 2682 | p.i = pos_1; |
| 2683 | break :blk_1 !match_1; |
| 2684 | } and try p.parseKEYWORD_catch() and blk_1: { |
| 2685 | const pos_1 = p.i; |
| 2686 | const match_1 = try p.parsepost_op_white(); |
| 2687 | p.i = pos_1; |
| 2688 | break :blk_1 !match_1; |
| 2689 | } and (try p.parsePayload() or true)) break :blk_0 true; |
| 2690 | p.i = pos_0; |
| 2691 | break :blk_0 false; |
| 2692 | }; |
| 2693 | } |
| 2694 | pub fn parseOrElseOp(p: *Parser) Error!bool { |
| 2695 | const def_index = @backingInt(Def.defOrElseOp); |
| 2696 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2697 | p.depths[def_index] += 1; |
| 2698 | defer p.depths[def_index] -= 1; |
| 2699 | return blk_0: { |
| 2700 | const pos_0 = p.i; |
| 2701 | if (try p.parsepre_op_white() and try p.parseKEYWORD_orelse() and try p.parsepost_op_white()) break :blk_0 true; |
| 2702 | p.i = pos_0; |
| 2703 | if (blk_1: { |
| 2704 | const pos_1 = p.i; |
| 2705 | const match_1 = try p.parsepre_op_white(); |
| 2706 | p.i = pos_1; |
| 2707 | break :blk_1 !match_1; |
| 2708 | } and try p.parseKEYWORD_orelse() and blk_1: { |
| 2709 | const pos_1 = p.i; |
| 2710 | const match_1 = try p.parsepost_op_white(); |
| 2711 | p.i = pos_1; |
| 2712 | break :blk_1 !match_1; |
| 2713 | }) break :blk_0 true; |
| 2326 | 2714 | p.i = pos_0; |
| 2327 | 2715 | break :blk_0 false; |
| 2328 | 2716 | }; |
| ... | ... | @@ -2452,8 +2840,6 @@ const Parser = struct { |
| 2452 | 2840 | p.i = pos_0; |
| 2453 | 2841 | if (try p.parseSLASH()) break :blk_0 true; |
| 2454 | 2842 | p.i = pos_0; |
| 2455 | | if (try p.parsePERCENT()) break :blk_0 true; |
| 2456 | | p.i = pos_0; |
| 2457 | 2843 | if (try p.parseASTERISKPERCENT()) break :blk_0 true; |
| 2458 | 2844 | p.i = pos_0; |
| 2459 | 2845 | if (try p.parseASTERISKPIPE()) break :blk_0 true; |
| ... | ... | @@ -2461,6 +2847,30 @@ const Parser = struct { |
| 2461 | 2847 | break :blk_0 false; |
| 2462 | 2848 | }; |
| 2463 | 2849 | } |
| 2850 | pub fn parseModOp(p: *Parser) Error!bool { |
| 2851 | const def_index = @backingInt(Def.defModOp); |
| 2852 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
| 2853 | p.depths[def_index] += 1; |
| 2854 | defer p.depths[def_index] -= 1; |
| 2855 | return blk_0: { |
| 2856 | const pos_0 = p.i; |
| 2857 | if (try p.parsepre_op_white() and try p.parsePERCENT() and try p.parsepost_op_white()) break :blk_0 true; |
| 2858 | p.i = pos_0; |
| 2859 | if (blk_1: { |
| 2860 | const pos_1 = p.i; |
| 2861 | const match_1 = try p.parsepre_op_white(); |
| 2862 | p.i = pos_1; |
| 2863 | break :blk_1 !match_1; |
| 2864 | } and try p.parsePERCENT() and blk_1: { |
| 2865 | const pos_1 = p.i; |
| 2866 | const match_1 = try p.parsepost_op_white(); |
| 2867 | p.i = pos_1; |
| 2868 | break :blk_1 !match_1; |
| 2869 | }) break :blk_0 true; |
| 2870 | p.i = pos_0; |
| 2871 | break :blk_0 false; |
| 2872 | }; |
| 2873 | } |
| 2464 | 2874 | pub fn parsePrefixOp(p: *Parser) Error!bool { |
| 2465 | 2875 | const def_index = @backingInt(Def.defPrefixOp); |
| 2466 | 2876 | if (p.depths[def_index] > max_depth) return error.MaxDepth; |
CMDRZero <gbell12907@gmail.com> 2026-07-13 15:47:13-05:00
Alex Rønne Petersen <alex@alexrp.com> 2026-10-22 12:21:43+02:00