예제 #1
0
 void TypeDecl.IVisitor.Visit(GenericTypeDecl decl)
 {
     Fix(decl);
     Execute(decl.Element);
     foreach (var paremter in decl.TypeArguments)
     {
         Execute(paremter);
     }
 }
예제 #2
0
        public static bool ParseMiniType(string[] tokens, ref int index, out TypeDecl decl)
        {
            decl = null;
            if (CppParser.Token(tokens, ref index, "const"))
            {
                decl = new DecorateTypeDecl
                {
                    Decoration = Decoration.Const,
                    Element    = EnsureMiniType(tokens, ref index),
                };
                return(true);
            }
            else if (CppParser.Token(tokens, ref index, "volatile"))
            {
                decl = new DecorateTypeDecl
                {
                    Decoration = Decoration.Volatile,
                    Element    = EnsureMiniType(tokens, ref index),
                };
                return(true);
            }
            else if (CppParser.Token(tokens, ref index, "signed"))
            {
                decl = new DecorateTypeDecl
                {
                    Decoration = Decoration.Signed,
                    Element    = EnsureMiniType(tokens, ref index),
                };
                return(true);
            }
            else if (CppParser.Token(tokens, ref index, "unsigned"))
            {
                decl = new DecorateTypeDecl
                {
                    Decoration = Decoration.Unsigned,
                    Element    = EnsureMiniType(tokens, ref index),
                };
                return(true);
            }
            else if (CppParser.Token(tokens, ref index, "decltype"))
            {
                CppParser.EnsureToken(tokens, ref index, "(");
                int oldIndex = index;
                CppParser.SkipUntil(tokens, ref index, ")");

                decl = new DeclTypeDecl
                {
                    Expression = tokens
                                 .Skip(oldIndex)
                                 .Take(index - 1 - oldIndex)
                                 .Aggregate((a, b) => a + " " + b),
                };
                return(true);
            }
            else if (CppParser.Token(tokens, ref index, "false") || CppParser.Token(tokens, ref index, "true"))
            {
                decl = new ConstantTypeDecl
                {
                    Value = tokens[index - 1],
                };
                return(true);
            }
            else
            {
                if (index < tokens.Length)
                {
                    int value = 0;
                    if (int.TryParse(tokens[index], out value))
                    {
                        index++;
                        decl = new ConstantTypeDecl
                        {
                            Value = tokens[index - 1],
                        };
                        return(true);
                    }
                }

                string token = null;
                CppParser.Token(tokens, ref index, "typename");
                if (CppParser.Id(tokens, ref index, out token))
                {
                    if (token == "L" && index < tokens.Length)
                    {
                        if (tokens[index].StartsWith("\""))
                        {
                            token += tokens[index];
                            index++;
                        }
                    }

                    decl = new RefTypeDecl
                    {
                        Name = token,
                    };

                    if (token != "operator")
                    {
                        while (true)
                        {
                            if (CppParser.Token(tokens, ref index, "<"))
                            {
                                var genericDecl = new GenericTypeDecl
                                {
                                    Element       = decl,
                                    TypeArguments = new List <TypeDecl>(),
                                };
                                decl = genericDecl;

                                if (!CppParser.Token(tokens, ref index, ">"))
                                {
                                    while (true)
                                    {
                                        genericDecl.TypeArguments.Add(EnsureTypeWithoutNameInTemplate(tokens, ref index));

                                        if (CppParser.Token(tokens, ref index, ">"))
                                        {
                                            break;
                                        }
                                        else
                                        {
                                            CppParser.EnsureToken(tokens, ref index, ",");
                                        }
                                    }
                                }
                            }
                            else if (CppParser.Token(tokens, ref index, ":"))
                            {
                                CppParser.EnsureToken(tokens, ref index, ":");
                                CppParser.Token(tokens, ref index, "template");
                                if (CppParser.Id(tokens, ref index, out token))
                                {
                                    decl = new SubTypeDecl
                                    {
                                        Parent = decl,
                                        Name   = token,
                                    };
                                }
                                else
                                {
                                    index -= 2;
                                    break;
                                }
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }