projects/dil: trunk/src/dil/Parser.d comparison

comparison trunk/src/dil/Parser.d @ 483:180711cc4b66

Fixed parsing of C-style function pointers. Renamed some labels. Added calls to set().

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Sun, 25 Nov 2007 20:48:10 +0100
parents	cac9c8d637ad
children	265c0b655f18

comparison

equal deleted inserted replaced

-:1401e38d1e2e
+:180711cc4b66
 nT();
 decl = new EmptyDeclaration();
 break;
 // Declaration
 case T.Identifier, T.Dot, T.Typeof:
-// BasicType
+// IntegralType
 case T.Char,   T.Wchar,   T.Dchar,  T.Bool,
 T.Byte,   T.Ubyte,   T.Short,  T.Ushort,
 T.Int,    T.Uint,    T.Long,   T.Ulong,
 T.Float,  T.Double,  T.Real,
 T.Ifloat, T.Idouble, T.Ireal,
 T.Cfloat, T.Cdouble, T.Creal, T.Void:
 case_Declaration:
-decl = parseDeclaration();
+return parseDeclaration();
-break;
 /+case T.Module:
 // TODO: Error: module is optional and can appear only once at the top of the source file.
 break;+/
 default:
 error(MID.ExpectedButFound, "Declaration", token.srcText);
 Declaration parseDeclarationsBlockNoColon()
 {
 return parseDeclarationsBlock(true);
 }
-Declaration parseDeclaration(StorageClass stc = StorageClass.None)
+/++
-{
+Parses either a VariableDeclaration or a FunctionDeclaration.
+Params:
+stc = the previously parsed storage classes
+optionalParameterList = a hint for how to parse C-style function pointers
++/
+Declaration parseDeclaration(StorageClass stc = StorageClass.None, bool optionalParameterList = true)
+{
+auto begin = token;
 Type type;
 Token* ident;
 // Check for AutoDeclaration
 if (stc != StorageClass.None &&
 else
 {
 type = parseType();
 if (token.type == T.LParen)
 {
-parseCFunctionPointerType(type, ident);
+// C-style function pointers make the grammar ambiguous.
+// We have to treat them specially at function scope.
+// Example:
+//   void foo() {
+//     // A pointer to a function taking an integer and returning 'some_type'.
+//     some_type (*p_func)(int);
+//     // In the following case precedence is given to a CallExpression.
+//     something(*p); // 'something' may be a function/method or an object having opCall overloaded.
+//   }
+//   // A pointer to a function taking no parameters and returning 'something'.
+//   something(*p);
+type = parseCFunctionPointerType(type, ident, optionalParameterList);
 }
 else
 {
 ident = requireId();
 // Type FunctionName ( ParameterList ) FunctionBody
 }
 auto params = parseParameterList();
 // ReturnType FunctionName ( ParameterList )
 auto funcBody = parseFunctionBody();
-return new FunctionDeclaration(type, ident, tparams, params, funcBody);
+return set(new FunctionDeclaration(type, ident, tparams, params, funcBody), begin);
 }
 type = parseDeclaratorSuffix(type);
 }
 }
 }
 else
 values ~= null;
 }
 require(T.Semicolon);
-return new VariableDeclaration(type, idents, values);
+return set(new VariableDeclaration(type, idents, values), begin);
 }
 Expression parseInitializer()
 {
 if (token.type == T.Void)
 if (token.type == T.Struct)
 structDecl = parseAggregateDeclaration();
 else
 expected(T.Struct);
 d = new AlignDeclaration(size, structDecl ? structDecl : new Declarations);
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 /+ Not applicable for statements.
 //          T.Private,
 //          T.Package,
 //          T.Protected,
 //          T.Public,
 break;
 }
 goto case T.Dot;
 case T.Dot, T.Typeof:
 bool success;
-d = try_({return parseDeclaration();}, success);
+d = try_({return parseDeclaration(StorageClass.None, false);}, success);
 if (success)
-goto case_DeclarationStatement; // Declaration
+goto LreturnDeclarationStatement; // Declaration
 else
-goto case_ExpressionStatement; // Expression
+goto case_parseExpressionStatement; // Expression
-// BasicType
+// IntegralType
 case T.Char,   T.Wchar,   T.Dchar,  T.Bool,
 T.Byte,   T.Ubyte,   T.Short,  T.Ushort,
 T.Int,    T.Uint,    T.Long,   T.Ulong,
 T.Float,  T.Double,  T.Real,
 T.Ifloat, T.Idouble, T.Ireal,
 T.Cfloat, T.Cdouble, T.Creal, T.Void:
 case_parseDeclaration:
 d = parseDeclaration();
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 case T.If:
 s = parseIfStatement();
 break;
 case T.While:
 s = parseWhileStatement();
 case T.Pragma:
 s = parsePragmaStatement();
 break;
 case T.Mixin:
 if (peekNext() == T.LParen)
-goto case_ExpressionStatement; // Parse as expression.
+goto case_parseExpressionStatement; // Parse as expression.
 s = parseMixin!(MixinStatement)();
 break;
 case T.Static:
 switch (peekNext())
 {
 s = parseVersionStatement();
 break;
 // DeclDef
 case T.Alias, T.Typedef:
 d = parseDeclarationDefinition();
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 case T.Enum:
 d = parseEnumDeclaration();
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 case T.Class:
 d = parseClassDeclaration();
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 case T.Interface:
 d = parseInterfaceDeclaration();
-goto case_DeclarationStatement;
+goto LreturnDeclarationStatement;
 case T.Struct, T.Union:
 d = parseAggregateDeclaration();
-goto case_DeclarationStatement;
+// goto LreturnDeclarationStatement;
-case_DeclarationStatement:
+LreturnDeclarationStatement:
 set(d, begin);
 s = new DeclarationStatement(d);
 break;
 case T.LBrace:
 s = parseScopeStatement();
 T.Not,
 T.Tilde,
 T.New,
 T.Delete,
 T.Cast:
-case_ExpressionStatement:
+case_parseExpressionStatement:
 s = new ExpressionStatement(parseExpression());
 require(T.Semicolon);
 break;
 default:
 if (token.isSpecialToken)
-goto case_ExpressionStatement;
+goto case_parseExpressionStatement;
 // Assert that this isn't a valid expression.
 assert(
 delegate bool(){
 bool success;
 e = parseExpression();
 require(T.RParen);
 // TODO: create ParenExpression?
 }
 break;
-// BasicType . Identifier
+// IntegralType . Identifier
 case T.Char,   T.Wchar,   T.Dchar,  T.Bool,
 T.Byte,   T.Ubyte,   T.Short,  T.Ushort,
 T.Int,    T.Uint,    T.Long,   T.Ulong,
 T.Float,  T.Double,  T.Real,
 T.Ifloat, T.Idouble, T.Ireal,
 }
 set(t, begin);
 return t;
 }
-Type parseCFunctionPointerType(Type type, ref Token* ident)
+Type parseCFunctionPointerType(Type type, ref Token* ident, bool optionalParamList)
 {
 assert(token.type == T.LParen);
+assert(type !is null);
 auto begin = token;
 nT(); // Skip (
 type = parseBasicType2(type);
 if (token.type == T.LParen)
 {
 // Can be nested.
-type = parseCFunctionPointerType(type, ident);
+type = parseCFunctionPointerType(type, ident, true);
 }
 else if (token.type == T.Identifier)
 {
 // The identifier of the function pointer and the declaration.
 ident = token;
 nT();
 type = parseDeclaratorSuffix(type);
 }
 require(T.RParen);
-// Optional parameter list
-auto params = token.type == T.LParen ? parseParameterList() : null;
+Parameters params;
+if (optionalParamList)
+params = token.type == T.LParen ? parseParameterList() : null;
+else
+params = parseParameterList();
 type = set(new CFuncPointerType(type, params), begin);
 return type;
 }
 Type parseDeclarator(ref Token* ident, bool identOptional = false)
 {
 auto t = parseType();
 if (token.type == T.LParen)
 {
-t = parseCFunctionPointerType(t, ident);
+t = parseCFunctionPointerType(t, ident, true);
 }
 else if (token.type == T.Identifier)
 {
 ident = token;
 nT();

Mercurial > projects > dil

comparison trunk/src/dil/Parser.d @ 483:180711cc4b66