public class_constant_definition(string name, location loc, common_type_node comprehensive_type, field_access_level field_access_level)
:
base(name, loc)
{
_comprehensive_type = comprehensive_type;
_fal = field_access_level;
}
public common_property_node(string name, common_type_node comprehensive_type, location loc,
field_access_level field_access_level, polymorphic_state polymorphic_state)
{
_name = name;
_comprehensive_type = comprehensive_type;
_loc = loc;
_field_access_level = field_access_level;
_polymorphic_state = polymorphic_state;
}
private ElementScope CreateInterfaceProperty(string name, int offset)
{
ElementScope prop = members[offset] as ElementScope;
if (prop != null)
{
return(prop);
}
int name_ref = br.ReadInt32();
TypeScope type = GetTypeReference();
if (br.ReadByte() == 1)
{
br.ReadInt32();
}
if (br.ReadByte() == 1)
{
br.ReadInt32();
}
int num = br.ReadInt32();
List <ElementScope> prms = new List <ElementScope>();
for (int i = 0; i < num; i++)
{
prms.Add(GetParameter(null));
}
br.ReadInt32();
field_access_level fal = (field_access_level)br.ReadByte();
polymorphic_state ps = (polymorphic_state)br.ReadByte();
//ReadDebugInfo();
prop = new ElementScope(new SymInfo(name, SymbolKind.Property, name), type, cur_scope);
prop.declaringUnit = root_scope;
switch (fal)
{
case field_access_level.fal_internal: prop.acc_mod = access_modifer.internal_modifer; break;
case field_access_level.fal_private: prop.acc_mod = access_modifer.private_modifer; return(null);
case field_access_level.fal_protected: prop.acc_mod = access_modifer.protected_modifer; break;
case field_access_level.fal_public: prop.acc_mod = access_modifer.public_modifer; break;
}
switch (ps)
{
case polymorphic_state.ps_static: prop.is_static = true; break;
case polymorphic_state.ps_virtual: prop.is_virtual = true; break;
}
//members[offset] = prop;
AddMember(prop, offset);
return(prop);
}
public class_field(string name, type_node type, common_type_node cont_class,
polymorphic_state polymorphic_state, field_access_level field_access_level,
location loc) :
base(name, type)
{
_cont_class = cont_class;
_polymorphic_state = polymorphic_state;
_field_access_level = field_access_level;
_loc = loc;
}
public common_event(string name, type_node del_type, common_type_node cont_type, common_method_node add_method, common_method_node remove_method, common_method_node raise_method,
field_access_level fal, polymorphic_state ps, location loc)
{
this._name = name;
this.del_type = del_type;
this._add_method = add_method;
this._remove_method = remove_method;
this._raise_method = raise_method;
this._field_access_level = fal;
this._polymorphic_state = ps;
this._cont_type = cont_type;
this._loc = loc;
}
public common_property_node(string name, common_type_node comprehensive_type, type_node property_type,
function_node get_function, function_node set_function, location loc,
field_access_level field_access_level, polymorphic_state polymorphic_state)
{
_name = name;
_comprehensive_type = comprehensive_type;
_property_type = property_type;
_get_function = get_function;
_set_function = set_function;
_loc = loc;
_field_access_level = field_access_level;
_polymorphic_state = polymorphic_state;
}
private ElementScope CreateInterfaceClassField(string name, int offset)
{
ElementScope field = members[offset] as ElementScope;
if (field != null)
{
return(field);
}
int name_off = br.ReadInt32();
TypeScope type = GetTypeReference();
field = new ElementScope(new SymInfo(name, SymbolKind.Field, name), type, cur_scope);
field.declaringUnit = root_scope;
AddMember(field, offset);
object initv = null;
if (CanReadObject())
{
initv = CreateExpression();
}
br.ReadInt32();
field_access_level fal = (field_access_level)br.ReadByte();
polymorphic_state ps = (polymorphic_state)br.ReadByte();
switch (fal)
{
case field_access_level.fal_internal: field.acc_mod = access_modifer.internal_modifer; break;
case field_access_level.fal_private: field.acc_mod = access_modifer.private_modifer; return(null);
case field_access_level.fal_protected: field.acc_mod = access_modifer.protected_modifer; break;
case field_access_level.fal_public: field.acc_mod = access_modifer.public_modifer; break;
}
switch (ps)
{
case polymorphic_state.ps_static: field.is_static = true; break;
case polymorphic_state.ps_virtual: field.is_virtual = true; break;
}
//field = new class_field(name,type,cont,ps,fal,loc);
field.cnst_val = initv;
//members[offset] = field;
AddMember(field, offset);
return(field);
}
public ICommonClassFieldNode[] GetFields(ICommonTypeNode ctn, field_access_level fal)
{
List <ICommonClassFieldNode> lst = new List <ICommonClassFieldNode>();
while (ctn != null)
{
foreach (ICommonClassFieldNode p in ctn.fields)
{
if (p.field_access_level == fal && HelpUtils.can_write(p))
{
lst.Add(p);
}
}
ctn = ctn.base_type as ICommonTypeNode;
}
lst.Sort(new FieldComparer());
return(lst.ToArray());
}
public ICommonMethodNode[] GetMethods(ICommonTypeNode ctn, field_access_level fal)
{
List <ICommonMethodNode> lst = new List <ICommonMethodNode>();
ICommonPropertyNode[] props = GetProperties(ctn);
while (ctn != null)
{
foreach (ICommonMethodNode m in ctn.methods)
{
if (!m.is_constructor && m.field_access_level == fal && m.Location != null && !is_getter_or_setter(m, props) &&
!is_event_special_method(m) && HelpUtils.can_write(m))
{
lst.Add(m);
}
}
ctn = ctn.base_type as ICommonTypeNode;
}
lst.Sort(new MethodComparer());
return(lst.ToArray());
}
private FieldAttributes ConvertFALToFieldAttributes(field_access_level fal)
{
switch (fal)
{
case field_access_level.fal_public: return FieldAttributes.Public;
case field_access_level.fal_internal: return FieldAttributes.Assembly;
case field_access_level.fal_protected: return FieldAttributes.FamORAssem;
case field_access_level.fal_private: return FieldAttributes.Assembly;
}
return FieldAttributes.Assembly;
}
private ProcScope CreateInterfaceMethod(string name, int offset)
{
ProcScope cmn = members[offset] as ProcScope;
if (cmn != null)
{
return(cmn);
}
cmn = new ProcScope(name, cur_scope);
cmn.declaringUnit = root_scope;
//members[offset] = cmn;
AddMember(cmn, offset);
int name_ref = br.ReadInt32();
br.ReadByte();
br.ReadByte();
bool is_generic = br.ReadBoolean();
if (is_generic)
{
throw new NotSupportedException();
}
//ssyy
//\ssyy
if (br.ReadByte() == 1) //return_value_type
{
cmn.return_type = GetTypeReference();
if (br.ReadByte() == 1)
{
GetLocalVariable(cmn);
}
}
int num_par = br.ReadInt32();
for (int i = 0; i < num_par; i++)
{
cmn.parameters.Add(GetParameter(cmn));
}
br.ReadInt32();
br.ReadInt32();
cmn.is_constructor = br.ReadBoolean();
cmn.is_forward = br.ReadBoolean();
br.ReadBoolean();
field_access_level fal = (field_access_level)br.ReadByte();
polymorphic_state ps = (polymorphic_state)br.ReadByte();
switch (fal)
{
case field_access_level.fal_internal: cmn.acc_mod = access_modifer.internal_modifer; break;
case field_access_level.fal_private: cmn.acc_mod = access_modifer.private_modifer; return(null);
case field_access_level.fal_protected: cmn.acc_mod = access_modifer.protected_modifer; break;
case field_access_level.fal_public: cmn.acc_mod = access_modifer.public_modifer; break;
}
switch (ps)
{
case polymorphic_state.ps_static: cmn.is_static = true; break;
case polymorphic_state.ps_virtual: cmn.is_virtual = true; break;
}
br.ReadInt32(); br.ReadInt32();
cmn.is_override = br.ReadBoolean() == true;
cmn.Complete();
return(cmn);
}
private EventInfo[] GetEvents(Type t, field_access_level mod)
{
EventInfo[] flds = t.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
List<EventInfo> fields = new List<EventInfo>();
foreach (EventInfo fi in flds)
{
MethodInfo add_meth = fi.GetAddMethod(true);
if (add_meth != null)
if (mod == field_access_level.fal_public && add_meth.IsPublic)
fields.Add(fi);
else if (mod == field_access_level.fal_protected && (add_meth.IsFamily || add_meth.IsFamilyOrAssembly))
fields.Add(fi);
}
return fields.ToArray();
}
private PropertyInfo[] GetProperties(Type t, field_access_level mod)
{
PropertyInfo[] flds = t.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
List<PropertyInfo> fields = new List<PropertyInfo>();
foreach (PropertyInfo fi in flds)
{
MethodInfo get_meth = fi.GetGetMethod(true);
if (get_meth != null)
if (mod == field_access_level.fal_public && get_meth.IsPublic)
fields.Add(fi);
else if (mod == field_access_level.fal_protected && (get_meth.IsFamily || get_meth.IsFamilyOrAssembly))
fields.Add(fi);
}
return fields.ToArray();
}
private MethodInfo[] GetMethods(Type t, field_access_level mod)
{
MethodInfo[] mths = t.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
List<MethodInfo> meths = new List<MethodInfo>();
foreach (MethodInfo mi in mths)
{
if (mod == field_access_level.fal_public && mi.IsPublic)
meths.Add(mi);
else if (mod == field_access_level.fal_protected && (mi.IsFamily || mi.IsFamilyOrAssembly))
meths.Add(mi);
}
return meths.ToArray();
}
private FieldInfo[] GetFields(Type t, field_access_level mod)
{
FieldInfo[] flds = t.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
List<FieldInfo> fields = new List<FieldInfo>();
foreach (FieldInfo fi in flds)
{
if (mod == field_access_level.fal_public && fi.IsPublic)
fields.Add(fi);
else if (mod == field_access_level.fal_protected && (fi.IsFamily || fi.IsFamilyOrAssembly))
fields.Add(fi);
}
return fields.ToArray();
}
public static string get_text_for_access_level(field_access_level fal)
{
switch(fal)
{
case field_access_level.fal_public : return "public";
case field_access_level.fal_protected : return "protected";
case field_access_level.fal_private : return "private";
case field_access_level.fal_internal : return "internal";
}
return "";
}
private MethodAttributes ConvertFALToMethodAttributes(field_access_level fal)
{
switch (fal)
{
case field_access_level.fal_public: return MethodAttributes.Public;
case field_access_level.fal_internal: return comp_opt.target == TargetType.Dll ? MethodAttributes.Public : MethodAttributes.Assembly;
case field_access_level.fal_protected: return MethodAttributes.FamORAssem;
case field_access_level.fal_private: return MethodAttributes.Assembly;
}
return MethodAttributes.Assembly;
}
