Datei: NDOEnhancer/ILCode/ILCustomElement.cs

Last Commit (0508969)
1 //
2 // Copyright ( c) 2002-2022 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Globalization;
 
 
 
25
26 namespace NDOEnhancer. ILCode
 
 
27 {
28 ····/// <summary>
29 ····/// Summary description for ILCustomElement.
30 ····/// </summary>
31 ····internal class ILCustomElement : ILElement
 
 
 
32 ····{
33 /*
34 ······.custom instance void [NDO]NDO.Linq.ServerFunctionAttribute::.ctor(string) = ( 01 00 15 4D 49 4E 5F 41 43 54 49 56 45 5F 52 4F·· // ...MIN_ACTIVE_RO
35 ···················································································· 57 56 45 52 53 49 4F 4E 00 00 )·················· // WVERSION..········
36 ········ */
37
38 ········public ILCustomElement( string firstLine, ILElement owner )
39 ············: base( firstLine, owner )
 
 
 
 
 
40 ········{
 
 
41 ········}
42
43 ········internal class ILCustomElementType : ILElementType
44 ········{
45 ············public ILCustomElementType()
46 : base( ". custom", typeof( ILCustomElement ) )
 
 
 
 
 
 
 
 
 
 
 
 
 
47 ············{
 
48 ············}
49 ········}
50
51 private static ILElementType m_elementType = new ILCustomElementType( ) ;
52 ········private AttributeInfo attributeInfo = null;
53
 
 
 
 
54
55 private void Resolve( )
 
56 ········{
57 if ( this. attributeInfo == null)
58 ················this.attributeInfo = GetAttributeInfo();
59 ········}
60
61 ········public bool
62 IsAttribute( Type type )
63 ········{
64 Resolve( ) ;
65 return this. attributeInfo. TypeName == type. FullName;
 
 
 
 
66 ········}
67
68
 
 
 
 
 
 
69 ········private object
70 ReadParam( byte[] bytes, Type type, ref int pos )
71 ········{
72 if ( type. FullName == "System. String" || type. FullName == "System. Type")
73 ············{
74 ················string para;
75 ················int len = PackedLength.Read(bytes, ref pos);
76 ················if (len == -1)
77 ····················para = null;
78 ················else
79 para = new System. Text. UTF8Encoding( ) . GetString( bytes, pos + 1, len ) ;
80 ················//string para = new string( chars, pos + 1, bytes[pos]);
81 ················pos += 1 + bytes[pos];
82 ················if (para != null && para != string.Empty)
83 ················{
84 ····················if (para[para.Length - 1] == '\0')
85 para = para. Substring( 0, para. Length - 1 ) ;
86 ················}
87 ················return para;
88 ············}
89 else if ( type == typeof( System. Boolean ) )
90 ············{
91 ················bool para = Convert.ToBoolean( bytes[pos] );
92 ················pos += 1;
93 ················return para;
94 ············}
95 else if ( type == typeof( System. Char ) )
96 ············{
97 ················char para = Convert.ToChar( bytes[pos+1] * 256 + bytes[pos] );
98 ················pos += 2;
99 ················return para;
100 ············}
101 else if ( type == typeof( System. Int16 ) )
102 ············{
103 ················short para = Convert.ToInt16( bytes[pos+1] * 256 + bytes[pos] );
104 ················pos += 2;
105 ················return para;
106 ············}
107 else if ( type == typeof( System. Int32 ) )
108 ············{
109 ················int para = ((bytes[pos+3] * 256 + bytes[pos+2]) * 256 + bytes[pos+1]) * 256 + bytes[pos];
110 ················pos += 4;
111 ················return para;
112 ············}
113 else if ( type. FullName == "NDO. RelationInfo")
114 ············{
115 ················short para = Convert.ToInt16( bytes[pos+1] * 256 + bytes[pos] );
116 ················pos += 2;
117 ················return (NDO.RelationInfo) para;
118 ············}
119 ············else if (typeof(System.Enum).IsAssignableFrom( type ) )
120 ············{
121 ················int para = ((bytes[pos+3] * 256 + bytes[pos+2]) * 256 + bytes[pos+1]) * 256 + bytes[pos];
122 ················pos += 4;
123 ················return Enum.ToObject( type, para );
124 ············}
125
126 ············MessageAdapter ma = new MessageAdapter();
127 ma. ShowError( $"Relation Attribute: Unknown type in attribute parameter list: { type. FullName} , owner type: { ( this. Owner as ILClassElement ) ?. Name ?? "-"} " ) ;
128
129 ············return null;
130 ········}
131
132
133 ········internal class AttributeInfo
134 ········{
135 public string TypeName;
136 ············public string AssemblyName;
137 ············public string[] ParamTypeNames = new string[]{};
138 ············public object[] ParamValues = new object[]{};
139 ········}
140
141
142 ········public AttributeInfo
143 GetAttributeInfo( )
144 ········{
145 ············string text = "";
146
147 for ( int i = 0; i < LineCount; i++)
148 ············{
149 string line = GetLine( i ) ;
150
151 ················int cmt = line.IndexOf( "//" );
152 if ( -1 < cmt)
153 ····················line = line.Substring( 0, cmt ).Trim();
154
155 ················text += " " + line;
156 ············}
157
158 ············int start, end;
159
160 ············// assembly name
161
162 ············start = text.IndexOf( "[" ) + 1;
163 end = text. IndexOf( "]", start ) ;
164 string assName = StripComment( text. Substring( start, end - start ) ) ;
165
166 ············// type name
167
168 ············start = text.IndexOf( "]" ) + 1;
169 end = text. IndexOf( "::", start ) ;
170 string typeName = StripComment( text. Substring( start, end - start ) ) ;
171
172 ············// constructor signature
173
174 ············start = text.IndexOf( "(" ) + 1;
175 end = text. IndexOf( ") ", start ) ;
176 string signature = StripComment( text. Substring( start, end - start ) ) ;
177
178 ············// parameter bytes
179
180 ············start = text.IndexOf( "= (" ) + 3;
181 end = text. IndexOf( ") ", start ) ;
182 string byteText = text. Substring( start, end - start ) . Trim( ) ;
183
184 char[] spc = { ' ' } ;
185 ············string[] byteStrings = byteText.Split( spc );
186 byte[] bytes = new byte[byteStrings. Length];
187 ············//············char[]···· chars········ = new char[byteStrings.Length];
188
189 for ( int i = 0; i < byteStrings. Length; i++)
190 ············{
191 ················bytes[i] = Byte.Parse( byteStrings[i], NumberStyles.HexNumber );
192 ················//················chars[i] = Convert.ToChar( bytes[i] );
193 ············}
194
195 ············//············char[] chars = new System.Text.UTF8Encoding().GetChars(bytes);
196
197 ············//············Type attributeType = Type.GetType( typeName + ", " + assName );
198 ············//············if ( null == attributeType )
199 ············//················return null;
200
201 ············char·· comma =··',';
202 ············string[] paramTypeNames = new string[]{};
203 ············object[] paramValues = new object[]{};
204 ············Type[] paramTypes = new Type[]{};
205 ············//CustomAttrib starts with a Prolog – an unsigned int16, with value 0x0001
206 ············int pos = 2;
207 ············if (signature != "")
208 ············{
209 ················paramTypeNames = signature.Split( comma );
210 paramTypes = new Type[paramTypeNames. Length];
211 paramValues = new Object[paramTypeNames. Length];
212
213 for ( int i = 0; i < paramTypeNames. Length; i++)
214 ················{
215 ····················string paramTypeName = paramTypeNames[i].Trim();
216 if ( paramTypeName == "string" || paramTypeName. IndexOf( "System. String" ) > -1)
217 ····················{
218 ························paramTypeNames[i] = "System.String";
219 paramTypes[i] = typeof( string ) ;
220 ····················}
221 else if ( paramTypeName == "bool")
222 ····················{
223 paramTypes[i] = typeof( bool ) ;
224 ························paramTypeNames[i] = "System.Boolean";
225 ····················}
226 else if ( paramTypeName == "char")
227 ····················{
228 paramTypes[i] = typeof( char ) ;
229 ························paramTypeNames[i] = "System.Char";
230 ····················}
231 else if ( paramTypeName == "short" || paramTypeName == "int16")
232 ····················{
233 ························paramTypeNames[i] = "System.Int16";
234 paramTypes[i] = typeof( System. Int16 ) ;
235 ····················}
236 else if ( paramTypeName == "int" || paramTypeName == "int32")
237 ····················{
238 ························paramTypeNames[i] = "System.Int32";
239 paramTypes[i] = typeof( System. Int32 ) ;
240 ····················}
241 ····················// Achtung: System.Type wird als string abgespeichert!!!
242 else if ( paramTypeName. IndexOf( "[mscorlib" ) > -1 && paramTypeName. IndexOf( "System. Type" ) > -1)
243 ····················{
244 paramTypes[i] = typeof( System. String ) ;
245 ························paramTypeNames[i] = "System.Type";
246 ····················}
247 else if ( paramTypeName == "valuetype [NDO]NDO. RelationInfo")
248 ····················{
249 paramTypes[i] = typeof( NDO. RelationInfo ) ;
250 ························paramTypeNames[i] = "NDO.RelationInfo, NDO";
251 ····················}
252 ····················else
253 ····················{
254 ························var paramTypeString = paramTypeName.Substring(paramTypeName.IndexOf(']') + 1);
255 ························var t = Type.GetType( paramTypeString );
256 ························if (t != null)
257 ························{
258 ····························paramTypes[i] = t;
259 ····························paramTypeNames[i] = "paramTypeString";
260 ························}
261 ························else
262 throw new Exception( $"Relation Attribute: Unknown type in attribute parameter list: { paramTypeName} , type: { ( this. Owner as ILClassElement ) ?. Name ?? ""} " ) ;
263 ····················}
264
265 ····················//paramTypes[i]··= Type.GetType( paramTypeNames[i] );
266 paramValues[i] = ReadParam( bytes, paramTypes[i], ref pos ) ;
267 ················}
268 ············}
269 ············//············ConstructorInfo ci···· = attributeType.GetConstructor( paramTypes );
270 AttributeInfo attr = new AttributeInfo( ) ;
271 attr. TypeName = typeName;
272 ············attr.AssemblyName = assName;
273 ············attr.ParamTypeNames = paramTypeNames;
274 ············attr.ParamValues = paramValues;
275
276 //TODO: Should we ever need to analyze named parameters
277 // we'll have to add lots of code here.
278 ············// We'd be better off, if we analyzed the IL code using the ECMA spec.
279
280 ············//············short count = (short) readParam( bytes, chars, Type.GetType( "System.Int16" ), ref pos );
281 ············//
282 ············//············for ( short i=0; i<count; i++ )
283 ············//············{
284 ············//················pos += 2;
285 ············//
286 ············//················string propName = readParam( bytes, chars, Type.GetType( "System.String" ), ref pos ) as string;
287 ············//
288 ············//················PropertyInfo pi = attributeType.GetProperty( propName );
289 ············//
290 ············//················object propVal = readParam( bytes, chars, pi.PropertyType, ref pos );
291 ············//
292 ············//················pi.SetValue( attr, propVal, null );
293 ············//············}
294
295 ············this.attributeInfo = attr;
296 ············return attr;
297 ········}
298
299 ········public void
300 ············replaceLines( string firstLine )
301 ········{
302 ClearLines( ) ;
303
304 AddLine( firstLine ) ;
305 ········}
306
307
308 ····}
309 }
310
New Commit (f892a37)
1 //
2 // Copyright ( c) 2002-2016 Mirko Matytschak
3 // (www.netdataobjects.de)
4 //
5 // Author: Mirko Matytschak
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8 // documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10 // Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11 // conditions:
12
13 // The above copyright notice and this permission notice shall be included in all copies or substantial portions
14 // of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19 // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 // DEALINGS IN THE SOFTWARE.
21
22
23 using System;
24 using System.Globalization;
25 using System.Diagnostics;
26 using System.Reflection;
27 using NDOEnhancer;
28
29 // using com. poet. util;
30
31 namespace ILCode
32 {
33 ····/// <summary>
34 ····/// Summary description for ILCustomElement.
35 ····/// </summary>
36 ····internal class ILCustomElement : ILElement
37 ····{
38 ········public ILCustomElement()
39 ············: base( false )
40 ········{
41 }
 
 
 
42
43 ········public ILCustomElement( string firstLine, ILElement owner )
44 ············: base( firstLine, owner )
45 ········{
46 ········}
47 /*
48 ········public ILCustomElement(string typeName, object[] parameters)
49 ············: base ( false )
50 ········{
51 ············string param = makeParameters(parameters);
52 ············//this.addLine
53 ········}
54 */
55 ········internal class ILCustomElementType : ILElementType
56 ········{
57 ············public ILCustomElementType()
58 : base( ". custom", typeof ( ILCustomElement) )
59 ············{
60 ············}
61 ········}
62
63 ········internal class Iterator : ILElementIterator
64 ········{
65 ············public Iterator( ILElement element )
66 ················: base( element, typeof (ILCustomElement) )
67 ············{
68 ············}
69
70 ············public new ILCustomElement
71 ················getNext()
72 ············{
73 ················return base.getNext() as ILCustomElement;
74 ············}
75 ········}
76
77 private static ILElementType m_elementType = new ILCustomElementType( ) ;
 
78 ········
79 ········public static void
80 ············initialize()
81 ········{
82 ········}
83
84 public static ILCustomElement. Iterator
85 ············getIterator( ILElement element )
86 ········{
87 return new Iterator( element ) ;
 
88 ········}
89
90 ········public bool
91 isAttribute( Type type )
92 ········{
93 if ( null == type )
94 return false;
95
96 ············string firstLine = getLine( 0 );
97
98 ············return (-1 < firstLine.IndexOf( type.FullName ));
99 ········}
100
101 /*
102 ········private string
103 ············makeParameters(object[] parameters)
104 ········{
105 ············return null;
106 ········}
107 */
108 ········private object
109 readParam( byte[] bytes, Type type, ref int pos )
110 ········{
111 if ( type. FullName == "System. String" || type. FullName == "System. Type")
112 ············{
113 ················string para;
114 ················int len = PackedLength.Read(bytes, ref pos);
115 ················if (len == -1)
116 ····················para = null;
117 ················else
118 para = new System. Text. UTF8Encoding( ) . GetString( bytes, pos + 1, len) ;
119 ················//string para = new string( chars, pos + 1, bytes[pos]);
120 ················pos += 1 + bytes[pos];
121 ················if (para != null && para != string.Empty)
122 ················{
123 ····················if (para[para.Length - 1] == '\0')
124 para = para. Substring( 0, para. Length - 1) ;
125 ················}
126 ················return para;
127 ············}
128 else if ( type == typeof( System. Boolean) )
129 ············{
130 ················bool para = Convert.ToBoolean( bytes[pos] );
131 ················pos += 1;
132 ················return para;
133 ············}
134 else if ( type == typeof( System. Char) )
135 ············{
136 ················char para = Convert.ToChar( bytes[pos+1] * 256 + bytes[pos] );
137 ················pos += 2;
138 ················return para;
139 ············}
140 else if ( type == typeof( System. Int16) )
141 ············{
142 ················short para = Convert.ToInt16( bytes[pos+1] * 256 + bytes[pos] );
143 ················pos += 2;
144 ················return para;
145 ············}
146 else if ( type == typeof( System. Int32) )
147 ············{
148 ················int para = ((bytes[pos+3] * 256 + bytes[pos+2]) * 256 + bytes[pos+1]) * 256 + bytes[pos];
149 ················pos += 4;
150 ················return para;
151 ············}
152 else if ( type. FullName == "NDO. RelationInfo" )
153 ············{
154 ················short para = Convert.ToInt16( bytes[pos+1] * 256 + bytes[pos] );
155 ················pos += 2;
156 ················return (NDO.RelationInfo) para;
157 ············}
158 ············else if (typeof(System.Enum).IsAssignableFrom( type ) )
159 ············{
160 ················int para = ((bytes[pos+3] * 256 + bytes[pos+2]) * 256 + bytes[pos+1]) * 256 + bytes[pos];
161 ················pos += 4;
162 ················return Enum.ToObject( type, para );
163 ············}
164
165 ············MessageAdapter ma = new MessageAdapter();
166 ma. ShowError( $"Relation Attribute: Unknown type in attribute parameter list: { type. FullName} , owner type: { ( this. getOwner( ) as ILClassElement ) ?. getName( ) ?? "-"} " ) ;
167
168 ············return null;
169 ········}
170
171
172 ········internal class AttributeInfo
173 ········{
174 public string Name;
175 ············public string AssemblyName;
176 ············public string[] ParamTypeNames = new string[]{};
177 ············public object[] ParamValues = new object[]{};
178 ········}
179
180
181 ········public AttributeInfo
182 getAttributeInfo( )
183 ········{
184 ············string text = "";
185
186 for ( int i=0; i<getLineCount( ) ; i++ )
187 ············{
188 string line = getLine( i ) ;
189 ················
190 ················int cmt = line.IndexOf( "//" );
191 if ( -1 < cmt )
192 ····················line = line.Substring( 0, cmt ).Trim();
193 ················
194 ················text += " " + line;
195 ············}
196
197 ············int start, end;
198
199 ············// assembly name
200
201 ············start = text.IndexOf( "[" ) + 1;
202 end = text. IndexOf( "]", start ) ;
203 string assName = stripComment( text. Substring( start, end - start ) ) ;
204
205 ············// type name
206
207 ············start = text.IndexOf( "]" ) + 1;
208 end = text. IndexOf( "::", start ) ;
209 string typeName = stripComment( text. Substring( start, end - start ) ) ;
210
211 ············// constructor signature
212
213 ············start = text.IndexOf( "(" ) + 1;
214 end = text. IndexOf( ") ", start ) ;
215 string signature = stripComment( text. Substring( start, end - start ) ) ;
216
217 ············// parameter bytes
218
219 ············start = text.IndexOf( "= (" ) + 3;
220 end = text. IndexOf( ") ", start ) ;
221 string byteText = text. Substring( start, end - start ) . Trim( ) ;
222
223 char[] spc = { ' ' } ;
224 ············string[] byteStrings = byteText.Split( spc );
225 byte[] bytes = new byte[byteStrings. Length];
226 ············//············char[]···· chars········ = new char[byteStrings.Length];
227
228 for ( int i=0; i<byteStrings. Length; i++ )
229 ············{
230 ················bytes[i] = Byte.Parse( byteStrings[i], NumberStyles.HexNumber );
231 ················//················chars[i] = Convert.ToChar( bytes[i] );
232 ············}
233
234 //············char[] chars = new System.Text.UTF8Encoding().GetChars(bytes);
235 ············
236 ············//············Type attributeType = Type.GetType( typeName + ", " + assName );
237 ············//············if ( null == attributeType )
238 ············//················return null;
239
240 ············char·· comma =··',';
241 ············string[] paramTypeNames = new string[]{};
242 ············object[] paramValues = new object[]{};
243 ············Type[] paramTypes = new Type[]{};
244 ············//CustomAttrib starts with a Prolog – an unsigned int16, with value 0x0001
245 ············int pos = 2;
246 ············if (signature != "")
247 ············{
248 ················paramTypeNames = signature.Split( comma );
249 paramTypes = new Type[paramTypeNames. Length];
250 paramValues = new Object[paramTypeNames. Length];
251
252 for ( int i=0; i<paramTypeNames. Length; i++ )
253 ················{
254 ····················string paramTypeName = paramTypeNames[i].Trim();
255 if ( paramTypeName == "string" || paramTypeName. IndexOf( "System. String") > -1)
256 ····················{
257 ························paramTypeNames[i] = "System.String";
258 paramTypes[i] = typeof( string) ;
259 ····················}
260 else if ( paramTypeName == "bool" )
261 ····················{
262 paramTypes[i] = typeof( bool) ;
263 ························paramTypeNames[i] = "System.Boolean";
264 ····················}
265 else if ( paramTypeName == "char" )
266 ····················{
267 paramTypes[i] = typeof( char) ;
268 ························paramTypeNames[i] = "System.Char";
269 ····················}
270 else if ( paramTypeName == "short" || paramTypeName == "int16" )
271 ····················{
272 ························paramTypeNames[i] = "System.Int16";
273 paramTypes[i] = typeof( System. Int16) ;
274 ····················}
275 else if ( paramTypeName == "int" || paramTypeName == "int32")
276 ····················{
277 ························paramTypeNames[i] = "System.Int32";
278 paramTypes[i] = typeof( System. Int32) ;
279 ····················}
280 ························// Achtung: System.Type wird als string abgespeichert!!!
281 else if ( paramTypeName. IndexOf( "[mscorlib") > -1 && paramTypeName. IndexOf( "System. Type") > -1 )
282 ····················{
283 paramTypes[i] = typeof( System. String) ;
284 ························paramTypeNames[i] = "System.Type";························
285 ····················}
286 else if ( paramTypeName == "valuetype [NDO]NDO. RelationInfo" )
287 ····················{
288 paramTypes[i] = typeof( NDO. RelationInfo) ;
289 ························paramTypeNames[i] = "NDO.RelationInfo, NDO";························
290 ····················}
291 ····················else
292 ····················{
293 ························var paramTypeString = paramTypeName.Substring(paramTypeName.IndexOf(']') + 1);
294 ························var t = Type.GetType( paramTypeString );
295 ························if (t != null)
296 ························{
297 ····························paramTypes[i] = t;
298 ····························paramTypeNames[i] = "paramTypeString";
299 ························}
300 ························else
301 throw new Exception( $"Relation Attribute: Unknown type in attribute parameter list: { paramTypeName} , type: { ( this. getOwner( ) as ILClassElement ) ?. getName( ) ?? ""} " ) ;
302 ····················}
303
304 ····················//paramTypes[i]··= Type.GetType( paramTypeNames[i] );
305 paramValues[i] = readParam( bytes, paramTypes[i], ref pos ) ;
306 ················}
307 ············}
308 ············//············ConstructorInfo ci···· = attributeType.GetConstructor( paramTypes );
309 AttributeInfo attr = new AttributeInfo( ) ;
310 attr. Name = typeName;
311 ············attr.AssemblyName = assName;
312 ············attr.ParamTypeNames = paramTypeNames;
313 ············attr.ParamValues = paramValues;
314
315 //TODO: sollten jemals benannte Parameter dazukommen
316 //TODO: müssten wir hier einigen Code hinzufügen
 
317
318 ············//············short count = (short) readParam( bytes, chars, Type.GetType( "System.Int16" ), ref pos );
319 ············//
320 ············//············for ( short i=0; i<count; i++ )
321 ············//············{
322 ············//················pos += 2;
323 ············//
324 ············//················string propName = readParam( bytes, chars, Type.GetType( "System.String" ), ref pos ) as string;
325 ············//
326 ············//················PropertyInfo pi = attributeType.GetProperty( propName );
327 ············//
328 ············//················object propVal = readParam( bytes, chars, pi.PropertyType, ref pos );
329 ············//
330 ············//················pi.SetValue( attr, propVal, null );
331 ············//············}
332
 
333 ············return attr;
334 ········}
335
336 ········public void
337 ············replaceLines( string firstLine )
338 ········{
339 clearLines( ) ;
340
341 addLine( firstLine ) ;
342 ········}
343
344 ····
345 ····}
346 }
347