/**
* Adds a value
*/
public void addClassField(StringValue name,
Expr value,
FieldVisibility visibility,
string comment)
{
_cl.addClassField(name, value, visibility, comment);
}
public FieldDefinition(SmallType pType, string pName, object pValue, FieldVisibility pVisibility)
{
Type = pType;
Name = pName;
Value = pValue;
Visibility = pVisibility;
}
public CompilationUnitField(string name, string type, string requiredImport, FieldVisibility visibility)
{
Name = name;
Type = type;
Visibility = visibility;
RequiredImport = requiredImport;
}
private void __WriteVisibilitySpecifier(FieldVisibility visibility)
{
switch (visibility)
{
case FieldVisibility.PrivateScope:
this.__WriteVisibilitySpecifier(AccessSpecifier.PrivateScope, false);
break;
case FieldVisibility.Private:
this.__WriteVisibilitySpecifier(AccessSpecifier.Private, false);
break;
case FieldVisibility.FamilyAndAssembly:
this.__WriteVisibilitySpecifier(AccessSpecifier.PrivateProtected, false);
break;
case FieldVisibility.Assembly:
this.__WriteVisibilitySpecifier(AccessSpecifier.Internal, false);
break;
case FieldVisibility.Family:
this.__WriteVisibilitySpecifier(AccessSpecifier.Protected, false);
break;
case FieldVisibility.FamilyOrAssembly:
this.__WriteVisibilitySpecifier(AccessSpecifier.InternalProtected, false);
break;
case FieldVisibility.Public:
this.__WriteVisibilitySpecifier(AccessSpecifier.Public, false);
break;
}
}
public ClassField(StringValue name,
string declaringClassName,
Expr initValue,
FieldVisibility visibility,
string comment,
bool isTraitField)
{
_name = name;
_declaringClassName = declaringClassName;
_initValue = initValue;
_comment = comment;
_isTraitField = isTraitField;
if (visibility.isProtected())
{
StringValue sb = name.createStringBuilder();
_canonicalName = createProtectedCanonicalName(sb, name);
}
else if (visibility.isPrivate())
{
StringValue sb = name.createStringBuilder();
_canonicalName = createPrivateCanonicalName(sb, name, declaringClassName);
}
else
{
_canonicalName = name;
}
}
public FieldsViewModel(IList <PropertyType> propertyTypes, IList <DetailsMetadata> detailsMetadatas, IList <Page> pages)
{
PropertyTypes = new BindableCollection <PropertyType>(propertyTypes);
DetailsMetadatas = new BindableCollection <DetailsMetadata>(detailsMetadatas);
Pages = new BindableCollection <Page>(pages);
FieldVisibilitys = new BindableCollection <FieldVisibility>(FieldVisibility.GetValues());
}
public IFieldEditor VisibleNew(FieldVisibility visibility)
{
Configuration.VisibleNew = visibility;
ConfigurationChanged = true;
return(this);
}
public FieldEntry(Expr value, FieldVisibility visibility, string comment)
{
_value = value;
_visibility = visibility;
_comment = comment;
}
public FieldEntry(Expr value, FieldVisibility visibility)
{
_value = value;
_visibility = visibility;
_comment = null;
}
public Value unserialize(Env env)
{
int ch = read();
switch (ch)
{
case 'b':
{
expect(':');
long v = readInt();
expect(';');
Value value = v == 0 ? BooleanValue.FALSE : BooleanValue.TRUE;
if (_useReference)
{
value = createReference(value);
}
return(value);
}
case 's':
case 'S':
case 'u':
case 'U':
{
expect(':');
int len = (int)readInt();
expect(':');
expect('"');
if (!isValidString(len))
{
env.notice(L.l("expected string length of {0}", len));
return(BooleanValue.FALSE);
}
Value value;
if (ch == 's' || ch == 'S')
{
value = readStringValue(env, len);
}
else
{
value = readUnicodeValue(env, len);
}
expect('"');
expect(';');
if (_useReference)
{
value = createReference(value);
}
return(value);
}
case 'i':
{
expect(':');
long l = readInt();
expect(';');
Value value = LongValue.create(l);
if (_useReference)
{
value = createReference(value);
}
return(value);
}
case 'd':
{
expect(':');
StringBuilder sb = new StringBuilder();
for (ch = read(); ch >= 0 && ch != ';'; ch = read())
{
sb.append((char)ch);
}
if (ch != ';')
{
throw new IOException(L.l("expected ';'"));
}
Value value = new DoubleValue(Double.parseDouble(sb.ToString()));
if (_useReference)
{
value = createReference(value);
}
return(value);
}
case 'a':
{
expect(':');
int len = (int)readInt();
expect(':');
expect('{');
Value array = new ArrayValueImpl(len);
if (_useReference)
{
array = createReference(array);
}
for (int i = 0; i < len; i++)
{
Value key = unserializeKey(env);
Value value = unserialize(env);
array.put(key, value);
}
expect('}');
return(array);
}
case 'O':
{
expect(':');
int len = (int)readInt();
expect(':');
expect('"');
if (!isValidString(len))
{
return(BooleanValue.FALSE);
}
string className = readString(len);
expect('"');
expect(':');
int count = (int)readInt();
expect(':');
expect('{');
QuercusClass qClass = env.findClass(className);
Value obj;
if (qClass != null)
{
obj = qClass.createObject(env);
}
else
{
log.fine(L.l("{0} @is an undefined class in unserialize",
className));
obj = env.createIncompleteObject(className);
}
Value ref = null;
if (_useReference)
{
ref = createReference(obj);
}
for (int i = 0; i < count; i++)
{
StringValue key = unserializeKey(env).ToStringValue();
FieldVisibility visibility = FieldVisibility.PUBLIC;
if (key.length() == 0)
{
throw new IOException(L.l("field key @is empty for class {0})",
className));
}
if (key[0] == 0)
{
if (key.length() > 3 &&
key[1] == '*' &&
key[2] == 0)
{
visibility = FieldVisibility.PROTECTED;
//key = key.substring(3);
}
else if (key.length() > 4)
{
int end = key.indexOf("\u0000", 1);
if (end < 0)
{
throw new IOException(L.l("end of field visibility modifier @is not valid: 0x{0} ({1}, {2})",
Integer.toHexString(key[2]), className, key));
}
StringValue declaringClass = key.substring(1, end);
StringValue fieldName = key.substring(end + 1);
visibility = FieldVisibility.PRIVATE;
}
else
{
throw new IOException(L.l("field visibility modifier @is not valid: 0x{0} ({1}, {2})",
Integer.toHexString(key[1]), className, key));
}
}
Value value = unserialize(env);
obj.initIncompleteField(env, key, value, visibility);
}
expect('}');
if (ref != null)
{
return(ref);
}
else
{
return(obj);
}
}
public void WriteFieldVisibility(FieldVisibility visibility, IFormatter formatter)
{
switch (visibility)
{
case FieldVisibility.Public: formatter.WriteKeyword("public"); break;
case FieldVisibility.Private: formatter.WriteKeyword("strict private"); break;
case FieldVisibility.PrivateScope: formatter.WriteKeyword("private");
formatter.Write(" ");
formatter.WriteComment("{scope}"); break;
case FieldVisibility.Family: formatter.WriteKeyword("strict protected"); break;
case FieldVisibility.Assembly: formatter.WriteKeyword("private"); break;
case FieldVisibility.FamilyOrAssembly: formatter.WriteKeyword("protected"); break;
case FieldVisibility.FamilyAndAssembly: formatter.WriteKeyword("protected");
formatter.Write(" ");
formatter.WriteComment("{internal}"); break;
default: throw new NotSupportedException();
}
formatter.Write(" ");
}
