Mercurial > projects > dil

comparison trunk/src/dil/parser/Parser.d @ 748:efd87fdb1c00

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tidied up dil.parser.Parser a bit.
author Aziz K?ksal <aziz.koeksal@gmail.com>
date Mon, 11 Feb 2008 17:23:27 +0100
parents 7917811f8116
children 7db35977b947
comparison
equal deleted inserted replaced
747:00f872d949ea 748:efd87fdb1c00
1919 1919
1920 auto params = new Parameters; 1920 auto params = new Parameters;
1921 Expression e; // Aggregate or LwrExpression 1921 Expression e; // Aggregate or LwrExpression
1922 1922
1923 require(T.LParen); 1923 require(T.LParen);
1924 while (1) 1924 auto paramsBegin = token;
1925 do
1925 { 1926 {
1926 auto paramBegin = token; 1927 auto paramBegin = token;
1927 StorageClass stc; 1928 StorageClass stc;
1928 Type type; 1929 Type type;
1929 Identifier* ident; 1930 Identifier* ident;
1945 default: 1946 default:
1946 type = parseDeclarator(ident); 1947 type = parseDeclarator(ident);
1947 } 1948 }
1948 1949
1949 params ~= set(new Parameter(stc, type, ident, null), paramBegin); 1950 params ~= set(new Parameter(stc, type, ident, null), paramBegin);
1950 1951 } while (skipped(T.Comma))
1951 if (token.kind != T.Comma) 1952 set(params, paramsBegin);
1952 break;
1953 nT();
1954 }
1955 require(T.Semicolon); 1953 require(T.Semicolon);
1956 e = parseExpression(); 1954 e = parseExpression();
1957 version(D2) 1955 version(D2)
1958 { //Foreach (ForeachType; LwrExpression .. UprExpression ) ScopeStatement 1956 { //Foreach (ForeachType; LwrExpression .. UprExpression ) ScopeStatement
1959 if (skipped(T.Slice)) 1957 if (skipped(T.Slice))
3232 3230
3233 nT(); 3231 nT();
3234 if (!skipped(T.RBracket)) 3232 if (!skipped(T.RBracket))
3235 { 3233 {
3236 e = parseAssignExpression(); 3234 e = parseAssignExpression();
3237 if (token.kind == T.Colon) 3235 if (skipped(T.Colon))
3238 goto LparseAssocArray; 3236 goto LparseAssocArray;
3239 if (skipped(T.Comma)) 3237 if (skipped(T.Comma))
3240 values = [e] ~ parseExpressionList(); 3238 values = [e] ~ parseExpressionList();
3241 require(T.RBracket); 3239 require(T.RBracket);
3242 } 3240 }
3243 3241
3244 e = new ArrayLiteralExpression(values); 3242 e = new ArrayLiteralExpression(values);
3245 break; 3243 break;
3246 3244
3247 LparseAssocArray: 3245 LparseAssocArray:
3248 Expression[] keys; 3246 Expression[] keys = [e];
3249 3247
3250 keys ~= e;
3251 nT(); // Skip colon.
3252 goto LenterLoop; 3248 goto LenterLoop;
3253 3249 do
3254 while (1)
3255 { 3250 {
3256 keys ~= parseAssignExpression(); 3251 keys ~= parseAssignExpression();
3257 require(T.Colon); 3252 require(T.Colon);
3258 LenterLoop: 3253 LenterLoop:
3259 values ~= parseAssignExpression(); 3254 values ~= parseAssignExpression();
3260 if (token.kind != T.Comma) 3255 } while (skipped(T.Comma))
3261 break;
3262 nT();
3263 }
3264 require(T.RBracket); 3256 require(T.RBracket);
3265 e = new AArrayLiteralExpression(keys, values); 3257 e = new AArrayLiteralExpression(keys, values);
3266 break; 3258 break;
3267 case T.LBrace: 3259 case T.LBrace:
3268 // DelegateLiteral := { Statements } 3260 // DelegateLiteral := { Statements }
3777 auto params = new Parameters(); 3769 auto params = new Parameters();
3778 3770
3779 if (skipped(T.RParen)) 3771 if (skipped(T.RParen))
3780 return set(params, begin); 3772 return set(params, begin);
3781 3773
3782 Loop:
3783 while (1) 3774 while (1)
3784 { 3775 {
3785 auto paramBegin = token; 3776 auto paramBegin = token;
3786 StorageClass stc, tmp; 3777 StorageClass stc, stc_;
3787 Type type; 3778 Type type;
3788 Identifier* ident; 3779 Identifier* ident;
3789 Expression defValue; 3780 Expression defValue;
3790 3781
3791 void pushParameter() 3782 void pushParameter()
3795 3786
3796 if (skipped(T.Ellipses)) 3787 if (skipped(T.Ellipses))
3797 { 3788 {
3798 stc = StorageClass.Variadic; 3789 stc = StorageClass.Variadic;
3799 pushParameter(); // type, ident and defValue will be null. 3790 pushParameter(); // type, ident and defValue will be null.
3800 break Loop; 3791 break;
3801 } 3792 }
3802 3793
3803 Lstc_loop: 3794 while (1)
3804 switch (token.kind) 3795 { // Parse storage classes.
3805 { 3796 switch (token.kind)
3806 version(D2) 3797 {
3807 { 3798 version(D2)
3808 case T.Invariant: // D2.0 3799 {
3809 if (peekNext() == T.LParen) 3800 case T.Invariant: // D2.0
3810 goto default; 3801 if (peekNext() == T.LParen)
3811 tmp = StorageClass.Invariant; 3802 break;
3812 goto Lcommon; 3803 stc_ = StorageClass.Invariant;
3813 case T.Const: // D2.0 3804 goto Lcommon;
3814 if (peekNext() == T.LParen) 3805 case T.Const: // D2.0
3815 goto default; 3806 if (peekNext() == T.LParen)
3816 tmp = StorageClass.Const; 3807 break;
3817 goto Lcommon; 3808 stc_ = StorageClass.Const;
3818 case T.Final: // D2.0 3809 goto Lcommon;
3819 tmp = StorageClass.Final; 3810 case T.Final: // D2.0
3820 goto Lcommon; 3811 stc_ = StorageClass.Final;
3821 case T.Scope: // D2.0 3812 goto Lcommon;
3822 tmp = StorageClass.Scope; 3813 case T.Scope: // D2.0
3823 goto Lcommon; 3814 stc_ = StorageClass.Scope;
3824 case T.Static: // D2.0 3815 goto Lcommon;
3825 tmp = StorageClass.Static; 3816 case T.Static: // D2.0
3826 goto Lcommon; 3817 stc_ = StorageClass.Static;
3827 } 3818 goto Lcommon;
3828 case T.In: 3819 }
3829 tmp = StorageClass.In; 3820 case T.In:
3830 goto Lcommon; 3821 stc_ = StorageClass.In;
3831 case T.Out: 3822 goto Lcommon;
3832 tmp = StorageClass.Out; 3823 case T.Out:
3833 goto Lcommon; 3824 stc_ = StorageClass.Out;
3834 case T.Inout, T.Ref: 3825 goto Lcommon;
3835 tmp = StorageClass.Ref; 3826 case T.Inout, T.Ref:
3836 goto Lcommon; 3827 stc_ = StorageClass.Ref;
3837 case T.Lazy: 3828 goto Lcommon;
3838 tmp = StorageClass.Lazy; 3829 case T.Lazy:
3839 goto Lcommon; 3830 stc_ = StorageClass.Lazy;
3840 Lcommon: 3831 goto Lcommon;
3841 // Check for redundancy. 3832 Lcommon:
3842 if (stc & tmp) 3833 // Check for redundancy.
3843 error(MID.RedundantStorageClass, token.srcText); 3834 if (stc & stc_)
3835 error(MID.RedundantStorageClass, token.srcText);
3836 else
3837 stc |= stc_;
3838 nT();
3839 version(D2)
3840 continue;
3844 else 3841 else
3845 stc |= tmp; 3842 break; // In D1.0 the grammar only allows one storage class.
3846 nT(); 3843 default:
3847 version(D2)
3848 goto Lstc_loop;
3849 else
3850 goto default; // In D1.0 only one stc per parameter is allowed.
3851 default:
3852 type = parseDeclarator(ident, true);
3853
3854 if (skipped(T.Assign))
3855 defValue = parseAssignExpression();
3856
3857 if (skipped(T.Ellipses))
3858 {
3859 stc |= StorageClass.Variadic;
3860 pushParameter();
3861 break Loop;
3862 } 3844 }
3863 3845 break; // Break out of inner loop.
3846 }
3847 type = parseDeclarator(ident, true);
3848
3849 if (skipped(T.Assign))
3850 defValue = parseAssignExpression();
3851
3852 if (skipped(T.Ellipses))
3853 {
3854 stc |= StorageClass.Variadic;
3864 pushParameter(); 3855 pushParameter();
3865 3856 break;
3866 if (token.kind != T.Comma) 3857 }
3867 break Loop; 3858 pushParameter();
3868 nT(); 3859
3869 } 3860 } while (skipped(T.Comma))
3870 }
3871 require(T.RParen); 3861 require(T.RParen);
3872 return set(params, begin); 3862 return set(params, begin);
3873 } 3863 }
3874 3864
3875 TemplateArguments parseTemplateArguments() 3865 TemplateArguments parseTemplateArguments()
3900 3890
3901 TemplateArguments parseTemplateArguments_() 3891 TemplateArguments parseTemplateArguments_()
3902 { 3892 {
3903 auto begin = token; 3893 auto begin = token;
3904 auto targs = new TemplateArguments; 3894 auto targs = new TemplateArguments;
3905 while (1) 3895 do
3906 { 3896 {
3907 Type parseType_() 3897 Type parseType_()
3908 { 3898 {
3909 auto type = parseType(); 3899 auto type = parseType();
3910 if (token.kind == T.Comma || token.kind == T.RParen) 3900 if (token.kind == T.Comma || token.kind == T.RParen)
3921 targs ~= typeArgument; 3911 targs ~= typeArgument;
3922 else 3912 else
3923 // TemplateArgument: 3913 // TemplateArgument:
3924 // AssignExpression 3914 // AssignExpression
3925 targs ~= parseAssignExpression(); 3915 targs ~= parseAssignExpression();
3926 if (token.kind != T.Comma) 3916 } while (skipped(T.Comma))
3927 break; // Exit loop.
3928 nT();
3929 }
3930 set(targs, begin); 3917 set(targs, begin);
3931 return targs; 3918 return targs;
3932 } 3919 }
3933 3920
3934 TemplateParameters parseTemplateParameterList() 3921 TemplateParameters parseTemplateParameterList()
3959 TemplateParameters parseTemplateParameterList_() 3946 TemplateParameters parseTemplateParameterList_()
3960 { 3947 {
3961 auto begin = token; 3948 auto begin = token;
3962 auto tparams = new TemplateParameters; 3949 auto tparams = new TemplateParameters;
3963 3950
3964 while (1) 3951 do
3965 { 3952 {
3966 auto paramBegin = token; 3953 auto paramBegin = token;
3967 TemplateParameter tp; 3954 TemplateParameter tp;
3968 Identifier* ident; 3955 Identifier* ident;
3969 Type specType, defType; 3956 Type specType, defType;
4042 } 4029 }
4043 4030
4044 // Push template parameter. 4031 // Push template parameter.
4045 tparams ~= set(tp, paramBegin); 4032 tparams ~= set(tp, paramBegin);
4046 4033
4047 if (token.kind != T.Comma) 4034 } while (skipped(T.Comma))
4048 break;
4049 nT();
4050 }
4051 set(tparams, begin); 4035 set(tparams, begin);
4052 return tparams; 4036 return tparams;
4053 } 4037 }
4054 4038
4055 void expected(TOK tok) 4039 void expected(TOK tok)