Mercurial > projects > dil

comparison trunk/src/dil/Parser.d @ 335:b245b234fdd9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- Moved parsePostExpression() above parseUnaryExpression(). - parseMulExpression() calls parsePostExpression() now.
author aziz
date Wed, 22 Aug 2007 09:51:02 +0000
parents a48a987f7515
children 1accb3013bd2
comparison
equal deleted inserted replaced
334:ca8ad7c34d6a 335:b245b234fdd9
3093 assert(0); 3093 assert(0);
3094 } 3094 }
3095 3095
3096 Expression parseMulExpression() 3096 Expression parseMulExpression()
3097 { 3097 {
3098 alias parsePostExpression parseNext;
3099 auto begin = token;
3100 auto e = parseNext();
3101 while (1)
3102 {
3103 auto operator = token;
3104 switch (operator.type)
3105 {
3106 case T.Mul: nT(); e = new MulExpression(e, parseNext(), operator); break;
3107 case T.Div: nT(); e = new DivExpression(e, parseNext(), operator); break;
3108 case T.Mod: nT(); e = new ModExpression(e, parseNext(), operator); break;
3109 default:
3110 return e;
3111 }
3112 set(e, begin);
3113 }
3114 assert(0);
3115 }
3116
3117 Expression parsePostExpression()
3118 {
3098 auto begin = token; 3119 auto begin = token;
3099 auto e = parseUnaryExpression(); 3120 auto e = parseUnaryExpression();
3100 while (1) 3121 while (1)
3101 { 3122 {
3102 auto operator = token;
3103 switch (operator.type)
3104 {
3105 case T.Mul: nT(); e = new MulExpression(e, parseUnaryExpression(), operator); break;
3106 case T.Div: nT(); e = new DivExpression(e, parseUnaryExpression(), operator); break;
3107 case T.Mod: nT(); e = new ModExpression(e, parseUnaryExpression(), operator); break;
3108 default:
3109 return e;
3110 }
3111 set(e, begin);
3112 }
3113 assert(0);
3114 }
3115
3116 Expression parseUnaryExpression()
3117 {
3118 auto begin = token;
3119 Expression e;
3120 switch (token.type)
3121 {
3122 case T.AndBinary:
3123 nT();
3124 e = new AddressExpression(parseUnaryExpression());
3125 break;
3126 case T.PlusPlus:
3127 nT();
3128 e = new PreIncrExpression(parseUnaryExpression());
3129 break;
3130 case T.MinusMinus:
3131 nT();
3132 e = new PreDecrExpression(parseUnaryExpression());
3133 break;
3134 case T.Mul:
3135 nT();
3136 e = new DerefExpression(parseUnaryExpression());
3137 break;
3138 case T.Minus:
3139 case T.Plus:
3140 nT();
3141 e = new SignExpression(parseUnaryExpression());
3142 break;
3143 case T.Not:
3144 nT();
3145 e = new NotExpression(parseUnaryExpression());
3146 break;
3147 case T.Tilde:
3148 nT();
3149 e = new CompExpression(parseUnaryExpression());
3150 break;
3151 case T.New:
3152 e = parseNewExpression();
3153 return e;
3154 case T.Delete:
3155 nT();
3156 e = new DeleteExpression(parseUnaryExpression());
3157 break;
3158 case T.Cast:
3159 requireNext(T.LParen);
3160 Type type;
3161 switch (token.type) 3123 switch (token.type)
3162 { 3124 {
3163 version(D2)
3164 {
3165 auto begin2 = token;
3166 case T.Const:
3167 type = new ConstType(null);
3168 goto case_break;
3169 case T.Invariant:
3170 type = new InvariantType(null);
3171 case_break:
3172 nT();
3173 set(type, begin2);
3174 break;
3175 }
3176 default:
3177 type = parseType();
3178 }
3179 require(T.RParen);
3180 e = new CastExpression(parseUnaryExpression(), type);
3181 break;
3182 case T.LParen:
3183 // ( Type ) . Identifier
3184 Type parseType_()
3185 {
3186 nT();
3187 auto type = parseType();
3188 require(T.RParen);
3189 require(T.Dot);
3190 return type;
3191 }
3192 bool success;
3193 auto type = try_(parseType_(), success);
3194 if (success)
3195 {
3196 auto ident = requireId();
3197 e = new TypeDotIdExpression(type, ident);
3198 break;
3199 }
3200 goto default;
3201 default:
3202 e = parsePostExpression(parsePrimaryExpression());
3203 return e;
3204 }
3205 assert(e !is null);
3206 set(e, begin);
3207 return e;
3208 }
3209
3210 Expression parsePostExpression(Expression e)
3211 {
3212 typeof(token) begin;
3213 while (1)
3214 {
3215 begin = token;
3216 switch (token.type)
3217 {
3218 /*
3219 // Commented out because parseDotListExpression() handles this.
3220 case T.Dot:
3221 nT();
3222 if (token.type == T.Identifier)
3223 {
3224 string ident = token.identifier;
3225 nT();
3226 if (token.type == T.Not && peekNext() == T.LParen) // Identifier !( TemplateArguments )
3227 {
3228 nT(); // Skip !.
3229 e = new DotTemplateInstanceExpression(e, ident, parseTemplateArguments());
3230 }
3231 else
3232 {
3233 e = new DotIdExpression(e, ident);
3234 nT();
3235 }
3236 }
3237 else if (token.type == T.New)
3238 e = parseNewExpression(e);
3239 else
3240 expected(T.Identifier);
3241 continue;
3242 */
3243 case T.Dot: 3125 case T.Dot:
3244 e = new PostDotListExpression(e, parseDotListExpression()); 3126 e = new PostDotListExpression(e, parseDotListExpression());
3245 goto Lset; 3127 goto Lset;
3246 case T.PlusPlus: 3128 case T.PlusPlus:
3247 e = new PostIncrExpression(e); 3129 e = new PostIncrExpression(e);
3287 set(e, begin); 3169 set(e, begin);
3288 } 3170 }
3289 assert(0); 3171 assert(0);
3290 } 3172 }
3291 3173
3292 Expression parsePrimaryExpression() 3174 Expression parseUnaryExpression()
3293 { 3175 {
3294 auto begin = token; 3176 auto begin = token;
3295 Expression e; 3177 Expression e;
3296 switch (token.type) 3178 switch (token.type)
3297 { 3179 {
3298 /* 3180 case T.AndBinary:
3299 // Commented out because parseDotListExpression() handles this. 3181 nT();
3300 case T.Identifier: 3182 e = new AddressExpression(parseUnaryExpression());
3301 string ident = token.identifier; 3183 break;
3302 nT(); 3184 case T.PlusPlus:
3303 if (token.type == T.Not && peekNext() == T.LParen) // Identifier !( TemplateArguments ) 3185 nT();
3304 { 3186 e = new PreIncrExpression(parseUnaryExpression());
3305 nT(); // Skip !. 3187 break;
3306 e = new TemplateInstanceExpression(ident, parseTemplateArguments()); 3188 case T.MinusMinus:
3307 } 3189 nT();
3308 else 3190 e = new PreDecrExpression(parseUnaryExpression());
3309 e = new IdentifierExpression(ident); 3191 break;
3310 break; 3192 case T.Mul:
3311 case T.Dot: 3193 nT();
3312 nT(); 3194 e = new DerefExpression(parseUnaryExpression());
3313 e = new IdentifierExpression("."); 3195 break;
3314 break; 3196 case T.Minus:
3315 */ 3197 case T.Plus:
3198 nT();
3199 e = new SignExpression(parseUnaryExpression());
3200 break;
3201 case T.Not:
3202 nT();
3203 e = new NotExpression(parseUnaryExpression());
3204 break;
3205 case T.Tilde:
3206 nT();
3207 e = new CompExpression(parseUnaryExpression());
3208 break;
3209 case T.New:
3210 e = parseNewExpression();
3211 return e;
3212 case T.Delete:
3213 nT();
3214 e = new DeleteExpression(parseUnaryExpression());
3215 break;
3216 case T.Cast:
3217 requireNext(T.LParen);
3218 Type type;
3219 switch (token.type)
3220 {
3221 version(D2)
3222 {
3223 auto begin2 = token;
3224 case T.Const:
3225 type = new ConstType(null);
3226 goto case_break;
3227 case T.Invariant:
3228 type = new InvariantType(null);
3229 case_break:
3230 nT();
3231 set(type, begin2);
3232 break;
3233 }
3234 default:
3235 type = parseType();
3236 }
3237 require(T.RParen);
3238 e = new CastExpression(parseUnaryExpression(), type);
3239 break;
3240 case T.LParen:
3241 // ( Type ) . Identifier
3242 Type parseType_()
3243 {
3244 nT();
3245 auto type = parseType();
3246 require(T.RParen);
3247 require(T.Dot);
3248 return type;
3249 }
3250 bool success;
3251 auto type = try_(parseType_(), success);
3252 if (success)
3253 {
3254 auto ident = requireId();
3255 e = new TypeDotIdExpression(type, ident);
3256 break;
3257 }
3258 goto default;
3259 default:
3260 e = parsePrimaryExpression();
3261 return e;
3262 }
3263 assert(e !is null);
3264 set(e, begin);
3265 return e;
3266 }
3267
3268 Expression parsePrimaryExpression()
3269 {
3270 auto begin = token;
3271 Expression e;
3272 switch (token.type)
3273 {
3316 case T.Identifier, T.Dot, T.Typeof: 3274 case T.Identifier, T.Dot, T.Typeof:
3317 e = parseDotListExpression(); 3275 e = parseDotListExpression();
3318 break; 3276 break;
3319 case T.This: 3277 case T.This:
3320 nT(); 3278 nT();
3445 requireNext(T.LParen); 3403 requireNext(T.LParen);
3446 auto type = parseType(); 3404 auto type = parseType();
3447 require(T.RParen); 3405 require(T.RParen);
3448 e = new TypeidExpression(type); 3406 e = new TypeidExpression(type);
3449 break; 3407 break;
3450 /*
3451 // Commented out because parseDotListExpression() handles this.
3452 case T.Typeof:
3453 requireNext(T.LParen);
3454 auto type = new TypeofType(parseExpression());
3455 require(T.RParen);
3456 if (token.type == T.Dot)
3457 { // typeof ( Expression ) . Identifier
3458 nT();
3459 string ident = requireIdentifier;
3460 e = new TypeDotIdExpression(type, ident);
3461 }
3462 else // typeof ( Expression )
3463 e = new TypeofExpression(type);
3464 break;
3465 */
3466 case T.Is: 3408 case T.Is:
3467 requireNext(T.LParen); 3409 requireNext(T.LParen);
3468 3410
3469 Type type, specType; 3411 Type type, specType;
3470 Token* ident; // optional Identifier 3412 Token* ident; // optional Identifier