Mercurial > projects > dil

comparison trunk/src/Parser.d @ 143:e760d7552f66

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- Renamed parseArgumentList() to parseArguments(). - Renamed parseParameters() to parseParameterList(). - Renamed parseTemplateArgumentList() to parseTemplateArguments(). - Renamed parseTemplateParameters() to parseTemplateParameterList().
author aziz
date Wed, 11 Jul 2007 21:38:05 +0000
parents 7ab33ee1a641
children cfd890b250e6
comparison
equal deleted inserted replaced
142:50251b408965 143:e760d7552f66
544 544
545 Declaration parseConstructorDeclaration() 545 Declaration parseConstructorDeclaration()
546 { 546 {
547 assert(token.type == T.This); 547 assert(token.type == T.This);
548 nT(); // Skip 'this' keyword. 548 nT(); // Skip 'this' keyword.
549 auto parameters = parseParameters(); 549 auto parameters = parseParameterList();
550 require(T.LBrace); 550 require(T.LBrace);
551 auto statements = parseStatements(); 551 auto statements = parseStatements();
552 require(T.RBrace); 552 require(T.RBrace);
553 return new ConstructorDeclaration(parameters, statements); 553 return new ConstructorDeclaration(parameters, statements);
554 } 554 }
792 Declaration parseTemplateDeclaration() 792 Declaration parseTemplateDeclaration()
793 { 793 {
794 assert(token.type == T.Template); 794 assert(token.type == T.Template);
795 nT(); // Skip template keyword. 795 nT(); // Skip template keyword.
796 auto templateName = requireIdentifier(); 796 auto templateName = requireIdentifier();
797 auto templateParams = parseTemplateParameters(); 797 auto templateParams = parseTemplateParameterList();
798 require(T.LBrace); 798 require(T.LBrace);
799 auto decls = parseDeclarationDefinitions(); 799 auto decls = parseDeclarationDefinitions();
800 require(T.RBrace); 800 require(T.RBrace);
801 return new TemplateDeclaration(templateName, templateParams, decls); 801 return new TemplateDeclaration(templateName, templateParams, decls);
802 } 802 }
803 803
804 Declaration parseNewDeclaration() 804 Declaration parseNewDeclaration()
805 { 805 {
806 assert(token.type == T.New); 806 assert(token.type == T.New);
807 nT(); // Skip new keyword. 807 nT(); // Skip new keyword.
808 auto parameters = parseParameters(); 808 auto parameters = parseParameterList();
809 require(T.LBrace); 809 require(T.LBrace);
810 auto decls = parseDeclarationDefinitions(); 810 auto decls = parseDeclarationDefinitions();
811 require(T.RBrace); 811 require(T.RBrace);
812 return new NewDeclaration(parameters, decls); 812 return new NewDeclaration(parameters, decls);
813 } 813 }
814 814
815 Declaration parseDeleteDeclaration() 815 Declaration parseDeleteDeclaration()
816 { 816 {
817 assert(token.type == T.Delete); 817 assert(token.type == T.Delete);
818 nT(); // Skip delete keyword. 818 nT(); // Skip delete keyword.
819 auto parameters = parseParameters(); 819 auto parameters = parseParameterList();
820 // TODO: only one parameter of type void* allowed. 820 // TODO: only one parameter of type void* allowed.
821 require(T.LBrace); 821 require(T.LBrace);
822 auto decls = parseDeclarationDefinitions(); 822 auto decls = parseDeclarationDefinitions();
823 require(T.RBrace); 823 require(T.RBrace);
824 return new DeleteDeclaration(parameters, decls); 824 return new DeleteDeclaration(parameters, decls);
1135 break; 1135 break;
1136 case T.MinusMinus: 1136 case T.MinusMinus:
1137 e = new PostDecrExpression(e); 1137 e = new PostDecrExpression(e);
1138 break; 1138 break;
1139 case T.LParen: 1139 case T.LParen:
1140 e = new CallExpression(e, parseArgumentList(T.LParen)); 1140 e = new CallExpression(e, parseArguments(T.LParen));
1141 continue; 1141 continue;
1142 case T.LBracket: 1142 case T.LBracket:
1143 // parse Slice- and IndexExpression 1143 // parse Slice- and IndexExpression
1144 nT(); 1144 nT();
1145 if (token.type == T.RBracket) 1145 if (token.type == T.RBracket)
1157 require(T.RBracket); 1157 require(T.RBracket);
1158 continue; 1158 continue;
1159 } 1159 }
1160 else if (token.type == T.Comma) 1160 else if (token.type == T.Comma)
1161 { 1161 {
1162 es ~= parseArgumentList(T.RBracket); 1162 es ~= parseArguments(T.RBracket);
1163 } 1163 }
1164 else 1164 else
1165 require(T.RBracket); 1165 require(T.RBracket);
1166 1166
1167 e = new IndexExpression(e, es); 1167 e = new IndexExpression(e, es);
1246 { 1246 {
1247 e = parseAssignExpression(); 1247 e = parseAssignExpression();
1248 if (token.type == T.Colon) 1248 if (token.type == T.Colon)
1249 goto LparseAssocArray; 1249 goto LparseAssocArray;
1250 else if (token.type == T.Comma) 1250 else if (token.type == T.Comma)
1251 values = [e] ~ parseArgumentList(T.RBracket); 1251 values = [e] ~ parseArguments(T.RBracket);
1252 else 1252 else
1253 require(T.RBracket); 1253 require(T.RBracket);
1254 } 1254 }
1255 1255
1256 e = new ArrayLiteralExpression(values); 1256 e = new ArrayLiteralExpression(values);
1305 Parameters parameters; 1305 Parameters parameters;
1306 if (token.type != T.LBrace) 1306 if (token.type != T.LBrace)
1307 { 1307 {
1308 if (token.type != T.LParen) // Optional return type 1308 if (token.type != T.LParen) // Optional return type
1309 returnType = parseType(); 1309 returnType = parseType();
1310 parameters = parseParameters(); 1310 parameters = parseParameterList();
1311 } 1311 }
1312 require(T.LBrace); 1312 require(T.LBrace);
1313 auto decls = parseDeclarationDefinitions(); 1313 auto decls = parseDeclarationDefinitions();
1314 require(T.RBrace); 1314 require(T.RBrace);
1315 auto func = new FunctionType(returnType, parameters); 1315 auto func = new FunctionType(returnType, parameters);
1396 e = new IsExpression(type, ident, specType); 1396 e = new IsExpression(type, ident, specType);
1397 break; 1397 break;
1398 case T.LParen: 1398 case T.LParen:
1399 Token t; 1399 Token t;
1400 bool failed; 1400 bool failed;
1401 auto parameters = try_(parseParameters(), failed); 1401 auto parameters = try_(parseParameterList(), failed);
1402 if (!failed) 1402 if (!failed)
1403 { 1403 {
1404 // ( ArgumentList ) FunctionBody 1404 // ( ParameterList ) FunctionBody
1405 require(T.LBrace); 1405 require(T.LBrace);
1406 auto decls = parseDeclarationDefinitions(); 1406 auto decls = parseDeclarationDefinitions();
1407 require(T.RBrace); 1407 require(T.RBrace);
1408 auto func = new FunctionType(null, parameters); 1408 auto func = new FunctionType(null, parameters);
1409 e = new FunctionLiteralExpression(func, decls); 1409 e = new FunctionLiteralExpression(func, decls);
1506 t = parseArrayType(t); 1506 t = parseArrayType(t);
1507 break; 1507 break;
1508 case T.Function, T.Delegate: 1508 case T.Function, T.Delegate:
1509 TOK tok = token.type; 1509 TOK tok = token.type;
1510 nT(); 1510 nT();
1511 auto parameters = parseParameters(); 1511 auto parameters = parseParameterList();
1512 t = new FunctionType(t, parameters); 1512 t = new FunctionType(t, parameters);
1513 if (tok == T.Function) 1513 if (tok == T.Function)
1514 t = new PointerType(t); 1514 t = new PointerType(t);
1515 else 1515 else
1516 t = new DelegateType(t); 1516 t = new DelegateType(t);
1532 // Type Identifier ArrayType 1532 // Type Identifier ArrayType
1533 // ArrayType := [] or [Type] or [Expression..Expression] 1533 // ArrayType := [] or [Type] or [Expression..Expression]
1534 t = parseArrayType(t); 1534 t = parseArrayType(t);
1535 continue; 1535 continue;
1536 case T.LParen: 1536 case T.LParen:
1537 auto params = parseParameters(); 1537 auto params = parseParameterList();
1538 // TODO: handle ( TemplateParameterList ) ( ParameterList ) 1538 // TODO: handle ( TemplateParameterList ) ( ParameterList )
1539 // ReturnType FunctionName ( ParameterList ) 1539 // ReturnType FunctionName ( ParameterList )
1540 t = new FunctionType(t, params); 1540 t = new FunctionType(t, params);
1541 break; 1541 break;
1542 default: 1542 default:
1591 expected(T.Identifier); 1591 expected(T.Identifier);
1592 1592
1593 return t; 1593 return t;
1594 } 1594 }
1595 1595
1596 Expression[] parseArgumentList(TOK terminator) 1596 Expression[] parseArguments(TOK terminator)
1597 { 1597 {
1598 Expression[] args; 1598 Expression[] args;
1599 1599
1600 nT(); 1600 nT();
1601 if (token.type == terminator) 1601 if (token.type == terminator)
1614 1614
1615 require(terminator); 1615 require(terminator);
1616 return args; 1616 return args;
1617 } 1617 }
1618 1618
1619 Parameters parseParameters() 1619 Parameters parseParameterList()
1620 out(params) 1620 out(params)
1621 { 1621 {
1622 if (params.length > 1) 1622 if (params.length > 1)
1623 foreach (param; params.items[0..$-1]) 1623 foreach (param; params.items[0..$-1])
1624 { 1624 {
1682 } 1682 }
1683 require(T.RParen); 1683 require(T.RParen);
1684 return params; 1684 return params;
1685 } 1685 }
1686 1686
1687 Object[] parseTemplateArgumentList() 1687 Object[] parseTemplateArguments()
1688 { 1688 {
1689 Object[] args; 1689 Object[] args;
1690 1690
1691 require(T.LParen); 1691 require(T.LParen);
1692 if (token.type == T.RParen) 1692 if (token.type == T.RParen)
1721 1721
1722 require(T.RParen); 1722 require(T.RParen);
1723 return args; 1723 return args;
1724 } 1724 }
1725 1725
1726 TemplateParameter[] parseTemplateParameters() 1726 TemplateParameter[] parseTemplateParameterList()
1727 { 1727 {
1728 require(T.LParen); 1728 require(T.LParen);
1729 if (token.type == T.RParen) 1729 if (token.type == T.RParen)
1730 return null; 1730 return null;
1731 1731