1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// **********************************************************************
//
// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#include <Slice/DotNetNames.h>
#include <ctype.h>
using namespace std;
namespace Slice
{
namespace DotNet
{
struct Node
{
const char** names;
const Node** parents;
};
static const char* ObjectNames[] =
{
"Equals", "Finalize", "GetHashCode", "GetType",
"MemberwiseClone", "ReferenceEquals", "ToString", 0
};
static const Node* ObjectParents[] =
{
0
};
static const Node ObjectNode =
{
ObjectNames, &ObjectParents[0]
};
static const char* ICloneableNames[] =
{
"Clone", 0
};
static const Node* ICloneableParents[] =
{
&ObjectNode, 0
};
static const Node ICloneableNode =
{
ICloneableNames, &ICloneableParents[0]
};
static const char* ExceptionNames[] =
{
"GetBaseException", "GetObjectData", "HelpLink", "HResult", "InnerException",
"Message", "Source", "StackTrace", "TargetSite", 0
};
static const Node* ExceptionParents[] =
{
&ObjectNode, 0
};
static const Node ExceptionNode =
{
ExceptionNames, &ExceptionParents[0]
};
static const char* ApplicationExceptionNames[] =
{
0
};
static const Node* ApplicationExceptionParents[] =
{
&ExceptionNode, 0
};
static const Node ApplicationExceptionNode =
{
ApplicationExceptionNames, &ApplicationExceptionParents[0]
};
//
// Must be kept in same order as definition of BaseType in header file!
//
static const Node* nodes[] =
{
&ObjectNode, &ICloneableNode, &ExceptionNode, &ApplicationExceptionNode
};
static bool
ciEquals(const string& s, const char* p)
{
if(s.size() != strlen(p))
{
return false;
}
string::const_iterator i = s.begin();
while(i != s.end())
{
if(tolower(*i++) != tolower(*p++))
{
return false;
}
}
return true;
}
const char* manglePrefix = "_Ice_";
static bool
mangle(const string& s, const Node* np, string& newName)
{
const char** namep = np->names;
while(*namep)
{
if(ciEquals(s, *namep))
{
newName = manglePrefix + s;
return true;
}
++namep;
}
const Node** parentp = np->parents;
while(*parentp)
{
if(mangle(s, *parentp, newName))
{
return true;
}
++parentp;
}
return false;
}
}
}
string
Slice::DotNet::mangleName(const string& s, int baseTypes)
{
if(baseTypes == 0)
{
return s;
}
string newName;
for(unsigned int mask = 1, i=0; mask < END; mask <<= 1, ++i)
{
if(baseTypes & mask)
{
if(mangle(s, nodes[i], newName))
{
return newName;
}
}
}
return s;
}
|
