频道栏目
首页 > 程序开发 > 软件开发 > C语言 > 正文
Vczh Library++3.0之ManagedX语言检查类型的可见性
2011-07-19 10:48:46      个评论      
收藏   我要投稿

 Vczh Library++3.0的山寨C#的ManagedX今天完成了一个功能,就是编译器检查一个类型在他上下文里面是否可用。这个过程足够复杂,我写了足足3个小时。

    ManagedX的符号表里面的类型已经被大大简化了。函数指针是类,基本数字类型也是类,所以归根结底只有
    1:子类型
    2:类
    3:模板类型

    因为某些关系,对于类型别名没有直接在符号表里面体现出来。举个例子:

 1 generic<inout T>
 2 class A
 3 {
 4     generic<inout U>
 5     public using S = B<T, U>;
 6 }
 7
 8 generic<inout T, inout U>
 9 class B
10 {
11     public using T = Dictionary<T, U>;
12 }
    下面的类型与符号表中类型结构的展开后关系是:

 1 ================================================
 2 A<int> ->
 3     TypeSymbol(A<int>)
 4     {
 5         GetSymbol() = A
 6         GetParentType() = 0
 7         GetGenericDeclaration() = TypeSymbol(A)
 8         {
 9             GetSymbol() = A
10             GetParentType() = 0
11             GetGenericDeclaration() = 0
12             GetGenericArguments() = []
13         }
14         GetGenericArguments() = [int]
15     }
16 ================================================
17 A<int>.S<string> ->
18     TypeSymbol(A<int>.S<string>)
19     {
20         GetSymbol() = A.S
21         GetParentType() = 0
22         GetGenericDeclaration() = TypeSymbol(A<int>.S)
23         {
24             GetSymbol() = A.S
25             GetParentType() = TypeSymbol(A<int>)
26             GetGenericDeclaration() = 0
27             GetGenericArguments() = []
28         }
29         GetGenericArguments() = [string]
30     }
31 ================================================
32 A<int>.S<string>.T ->
33     TypeSymbol(Dictionary<int, string>)
34     {
35         GetSymbol() = Dictionary
36         GetParentType() = 0
37         GetGenericDeclaration() = TypeSymbol(Dictionary)
38         GetGenericArguments() = [int, string]
39     }
40 ================================================
    对于展开前的类型结构,A<int>.S<string>.T其实上是指向了GetSymbol()是A<T>.S<U>.T,而ParentType()是A<int>.S<string>的这样一个结构。然后再经过符号表把所有类型别名的目标类型(譬如A.S就是B<T,U>)拿出来,替换掉必要的模板参数,最后获得展开后的类型。

    因为有了继承关系、父子类型和类型别名,所以在判断他们的accessor(也就是public、protected、private、internal和protected internal)是否可见的时候,就非常复杂。代码已经上传到Vczh Library++3.0的主页了,下面是核心函数的代码:

  1             void EnsureTypeVisibility(
  2                 ManagedLanguageElement* languageElement,
  3                 ManagedTypeSymbol* type,
  4                 const MAP& argument,
  5                 List<ManagedTypeSymbol*>& thisTypes,
  6                 List<ManagedTypeSymbol*>& baseTypes
  7                 )
  8             {
  9                 List<ManagedTypeSymbol*> typeLevels;
 10                 {
 11                     ManagedTypeSymbol* currentType=type;
 12                     while(currentType)
 13                     {
 14                         typeLevels.Add(currentType);
 15                         currentType=currentType->GetGenericDeclaration()
 16                             ?currentType->GetGenericDeclaration()->GetParentType()
 17                             :currentType->GetParentType()
 18                             ;
 19                     }
 20                 }
 21
 22                 ManagedTypeSymbol* parentType=0;
 23                 for(vint i=typeLevels.Count()-1;i>=0;i--)
 24                 {
 25                     ManagedTypeSymbol* currentType=typeLevels[i];
 26                     ManagedTypeSymbol* currentDeclaration=currentType->GetGenericDeclaration()
 27                         ?currentType->GetGenericDeclaration()
 28                         :currentType
 29                         ;
 30                     if(currentType->GetGenericDeclaration())
 31                     {
 32                         FOREACH(ManagedTypeSymbol*, genericArgument, currentType->GetGenericArguments())
 33                         {
 34                             EnsureTypeVisibility(languageElement, genericArgument, argument, thisTypes, baseTypes);
 35                         }
 36                     }
 37
 38                     ManagedSymbolItem* currentSymbol=currentDeclaration->GetSymbol();
 39                     declatt::Accessor currentAccessor=declatt::Public;
 40                     switch(currentSymbol->GetSymbolType())
 41                     {
 42                     case ManagedSymbolItem::Class:
 43                     case ManagedSymbolItem::Structure:
 44                     case ManagedSymbolItem::Interface:
 45                         {
 46                             ManagedSymbolDeclaration* symbol=dynamic_cast<ManagedSymbolDeclaration*>(currentSymbol);
 47                             currentAccessor=symbol->accessor;
 48                         }
 49                         break;
 50                     case ManagedSymbolItem::TypeRename:
 51                         {
 52                             ManagedSymbolTypeRename* symbol=dynamic_cast<ManagedSymbolTypeRename*>(currentSymbol);
 53                             currentAccessor=symbol->accessor;
 54                         }
 55                         break;
 56                     case ManagedSymbolItem::GenericParameter:
 57                         break;
 58                     default:
 59                         argument.errors.Add(ManagedLanguageCodeException::GetTypeInvisible(languageElement, currentType));
 60                         return;
 61                     }
 62
 63                     if(!parentType)
 64                     {
 65                         ManagedSymbolItem* parentSymbol=currentSymbol->GetParentItem();
 66                         switch(parentSymbol->GetSymbolType())
 67                         {
 68                         case ManagedSymbolItem::Class:
 69                         case ManagedSymbolItem::Structure:
 70                         case ManagedSymbolItem::Interface:
 71                             {
 72                                 ManagedSymbolDeclaration* parentDeclaration=dynamic_cast<ManagedSymbolDeclaration*>(parentSymbol);
 73                                 parentType=argument.symbolManager->GetThisType(parentDeclaration);
 74                             }
 75                             break;
 76                         }
 77                     }
 78                     if(parentType && !thisTypes.Contains(parentType))
 79                     {
 80                         if(baseTypes.Contains(parentType))
 81                         {
 82                             switch(currentAccessor)
 83                             {
 84                             case declatt::Public:
 85                             case declatt::Protected:
 86                             case declatt::Internal:
 87                             case declatt::ProtectedInternal:
 88                                 break;
 89                             default:
 90                                 argument.errors.Add(ManagedLanguageCodeException::GetTypeInvisible(languageElement, currentType));
 91                                 return;
 92                             }
 93                         }
 94                         else
 95                         {
 96                             switch(currentAccessor)
 97                             {
 98                             case declatt::Public:
 99                             case declatt::Internal:
100                             case declatt::ProtectedInternal:
101                                 break;
102                             default:
103                                 argument.errors.Add(ManagedLanguageCodeException::GetTypeInvisible(languageElement, currentType));
104                                 return;
105                             }
106                         }
107                     }
108
109                     if(currentSymbol->GetSymbolType()==ManagedSymbolItem::TypeRename)
110                     {
111                         ManagedSymbolTypeRename* symbol=dynamic_cast<ManagedSymbolTypeRename*>(currentSymbol);
112                         if(currentType->GetGenericDeclaration())
113                         {
114                             Dictionary<ManagedTypeSymbol*, ManagedTypeSymbol*> replacement;
115                             for(vint i=0;i<symbol->orderedGenericParameterNames.Count();i++)
116                             {
117                                 ManagedTypeSymbol* key=argument.symbolManager->GetType(symbol->ItemGroup(symbol->orderedGenericParameterNames[i])->Items()[0]);
118                                 ManagedTypeSymbol* value=currentType->GetGenericArguments()[i];
119                                 replacement.Add(key, value);
120                             }
121                             parentType=argument.symbolManager->ReplaceGenericArguments(currentType, replacement.Wrap());
122                         }
123                         else
124                         {
125                             parentType=symbol->type;
126                         }
127                     }
128                     else
129                     {
130                         parentType=currentType;
131                     }
132                 }
133             }
134
135             void CollectBaseTypes(ManagedTypeSymbol* thisType, List<ManagedTypeSymbol*>& baseTypes, const MAP& argument)
136             {
137                 vint oldCount=baseTypes.Count();
138                 if(thisType->GetGenericDeclaration())
139                 {
140                     ManagedSymbolDeclaration* symbol=dynamic_cast<ManagedSymbolDeclaration*>(thisType->GetGenericDeclaration()->GetSymbol());
141
142                     Dictionary<ManagedTypeSymbol*, ManagedTypeSymbol*> replacement;
143                     for(vint i=0;i<symbol->orderedGenericParameterNames.Count();i++)
144                     {
145                         ManagedTypeSymbol* key=argument.symbolManager->GetType(symbol->ItemGroup(symbol->orderedGenericParameterNames[i])->Items()[0]);
146                         ManagedTypeSymbol* value=thisType->GetGenericArguments()[i];
147                         replacement.Add(key, value);
148                     }
149
150                     FOREACH(ManagedTypeSymbol*, baseType, symbol->baseTypes.Wrap())
151                     {
152                         ManagedTypeSymbol* translatedBaseType=argument.symbolManager->ReplaceGenericArguments(baseType, replacement.Wrap());
153                         if(!baseTypes.Contains(translatedBaseType))
154                         {
155                             baseTypes.Add(translatedBaseType);
156                         }
157                     }
158                 }
159                 else
160                 {
161                     ManagedSymbolDeclaration* symbol=dynamic_cast<ManagedSymbolDeclaration*>(thisType->GetSymbol());
162                     FOREACH(ManagedTypeSymbol*, baseType, symbol->baseTypes.Wrap())
163                     {
164                         if(!baseTypes.Contains(baseType))
165                         {
166                             baseTypes.Add(baseType);
167                         }
168                     }
169                 }
170                 for(vint i=oldCount;i<baseTypes.Count();i++)
171                 {
172                     CollectBaseTypes(baseTypes[i], baseTypes, argument);
173                 }
174             }
175
176             void EnsureTypeVisibility(ManagedLanguageElement* languageElement, ManagedTypeSymbol* type, ManagedSymbolItem* scopeItem, const MAP& argument)
177             {
178                 CHECK_ERROR(
179                     !scopeItem
180                     || scopeItem->GetSymbolType()==ManagedSymbolItem::Class
181                     || scopeItem->GetSymbolType()==ManagedSymbolItem::Structure
182                     || scopeItem->GetSymbolType()==ManagedSymbolItem::Interface,
183                     L"EnsureTypeVisibility(ManagedLanguageElement*, ManagedTypeSymbol*, ManagedSymbolItem*, const MAP&)#scopeItem内容非法。"
184                     );
185
186                 List<ManagedTypeSymbol*> thisTypes, baseTypes;
187                 {
188                     ManagedSymbolDeclaration* currentDeclaration=dynamic_cast<ManagedSymbolDeclaration*>(scopeItem);
189                     while(currentDeclaration)
190                     {
191                         thisTypes.Add(argument.symbolManager->GetThisType(currentDeclaration));
192                         currentDeclaration=dynamic_cast<ManagedSymbolDeclaration*>(currentDeclaration->GetParentItem());
193                     }
194                 }
195                 FOREACH(ManagedTypeSymbol*, thisType, thisTypes.Wrap())
196                 {
197                     CollectBaseTypes(thisType, baseTypes, argument);
198                 }
199                 EnsureTypeVisibility(languageElement, type, argument, thisTypes, baseTypes);
200             }
    主要方法就是,判断A<int>.S<string>.T是否可见有下面两个判断:
    1:A<int>.S<string>是否可见
    2:A<int>.S<string>扩展后的类型是B<int, string>,判断B<int, string>.T是否可见。
    至于为什么这里不需要判断B<int, string>是否可见,是因为在using S=xxx这条声明的语义分析里面已经查过了,如果不可见就会有错误信息产生。因此这里可以当B<int, string>是可见的,减少多余的错误信息。

    然后判断A<int>.S<string>是否可见比较简单,主要就是判断A<int>.S和string是否可见。

    一直这么递归下去,就把整个类型都检查完了。

点击复制链接 与好友分享!回本站首页
相关TAG标签 语言 类型
上一篇:HDU 1102 Constructing Roads
下一篇:基于stl序列容器实现的通用集合类
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站