use of org.eclipse.titan.designer.AST.TTCN3.values.UniversalCharstring_Value in project titan.EclipsePlug-ins by eclipse.
the class RotateRightExpression method evaluateValue.
@Override
public /**
* {@inheritDoc}
*/
IValue evaluateValue(final CompilationTimeStamp timestamp, final Expected_Value_type expectedValue, final IReferenceChain referenceChain) {
if (lastTimeChecked != null && !lastTimeChecked.isLess(timestamp)) {
return lastValue;
}
isErroneous = false;
lastTimeChecked = timestamp;
lastValue = this;
if (value1 == null || value2 == null) {
return lastValue;
}
checkExpressionOperands(timestamp, expectedValue, referenceChain);
if (getIsErroneous(timestamp) || isUnfoldable(timestamp, referenceChain)) {
return lastValue;
}
final IValue last1 = value1.getValueRefdLast(timestamp, referenceChain);
final IValue last2 = value2.getValueRefdLast(timestamp, referenceChain);
String string;
int shiftSize;
switch(last1.getValuetype()) {
case BITSTRING_VALUE:
string = ((Bitstring_Value) last1).getValue();
shiftSize = ((Integer_Value) last2).intValue();
lastValue = new Bitstring_Value(rotateRight(string, shiftSize));
lastValue.copyGeneralProperties(this);
break;
case HEXSTRING_VALUE:
string = ((Hexstring_Value) last1).getValue();
shiftSize = ((Integer_Value) last2).intValue();
lastValue = new Hexstring_Value(rotateRight(string, shiftSize));
lastValue.copyGeneralProperties(this);
break;
case OCTETSTRING_VALUE:
string = ((Octetstring_Value) last1).getValue();
shiftSize = ((Integer_Value) last2).intValue() * 2;
lastValue = new Octetstring_Value(rotateRight(string, shiftSize));
lastValue.copyGeneralProperties(this);
break;
case CHARSTRING_VALUE:
string = ((Charstring_Value) last1).getValue();
shiftSize = ((Integer_Value) last2).intValue();
lastValue = new Charstring_Value(rotateRight(string, shiftSize));
lastValue.copyGeneralProperties(this);
break;
case UNIVERSALCHARSTRING_VALUE:
final UniversalCharstring string2 = ((UniversalCharstring_Value) last1).getValue();
shiftSize = ((Integer_Value) last2).intValue();
lastValue = new UniversalCharstring_Value(rotateRight(string2, shiftSize));
lastValue.copyGeneralProperties(this);
break;
default:
setIsErroneous(true);
break;
}
return lastValue;
}
use of org.eclipse.titan.designer.AST.TTCN3.values.UniversalCharstring_Value in project titan.EclipsePlug-ins by eclipse.
the class Unichar2CharExpression method checkExpressionOperands.
/**
* Checks the parameters of the expression and if they are valid in
* their position in the expression or not.
*
* @param timestamp
* the timestamp of the actual semantic check cycle.
* @param expectedValue
* the kind of value expected.
* @param referenceChain
* a reference chain to detect cyclic references.
*/
private void checkExpressionOperands(final CompilationTimeStamp timestamp, final Expected_Value_type expectedValue, final IReferenceChain referenceChain) {
if (value == null) {
return;
}
value.setLoweridToReference(timestamp);
final Type_type tempType = value.getExpressionReturntype(timestamp, expectedValue);
switch(tempType) {
case TYPE_UCHARSTRING:
final IValue last = value.getValueRefdLast(timestamp, expectedValue, referenceChain);
if (!last.isUnfoldable(timestamp)) {
UniversalCharstring string;
if (last instanceof Charstring_Value) {
// check not necessary, trivial case
return;
} else if (last instanceof UniversalCharstring_Value) {
string = ((UniversalCharstring_Value) last).getValue();
if (string == null) {
setIsErroneous(true);
return;
}
} else {
value.getLocation().reportSemanticError(OPERANDERROR1);
setIsErroneous(true);
return;
}
for (int i = 0; i < string.length(); i++) {
final UniversalChar uchar = string.get(i);
if (uchar.group() != 0 || uchar.plane() != 0 || uchar.row() != 0 || uchar.cell() > 127) {
value.getLocation().reportSemanticError(OPERANDERROR2);
setIsErroneous(true);
return;
}
}
}
return;
case TYPE_CHARSTRING:
break;
case TYPE_UNDEFINED:
setIsErroneous(true);
break;
default:
if (!isErroneous) {
location.reportSemanticError(OPERANDERROR1);
setIsErroneous(true);
}
return;
}
}
use of org.eclipse.titan.designer.AST.TTCN3.values.UniversalCharstring_Value in project titan.EclipsePlug-ins by eclipse.
the class Assignment_Statement method checkVarAssignment.
private void checkVarAssignment(final CompilationTimeStamp timestamp, final Assignment assignment, final IValue value) {
final IType varType = getType(timestamp, assignment);
if (varType == null || value == null) {
isErroneous = true;
return;
}
final IType type = varType.getFieldType(timestamp, reference, 1, Expected_Value_type.EXPECTED_DYNAMIC_VALUE, false);
if (type == null) {
isErroneous = true;
return;
}
value.setMyGovernor(type);
IValue lastValue = type.checkThisValueRef(timestamp, value);
final IReferenceChain referenceChain = ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
lastValue = lastValue.getValueRefdLast(timestamp, referenceChain);
referenceChain.release();
if (Value_type.OMIT_VALUE.equals(lastValue.getValuetype())) {
final ISubReference lastReference = reference.removeLastSubReference();
if (lastReference == null || lastReference.getId() == null) {
value.getLocation().reportSemanticError(OMITTOMANDATORYASSIGNMENT1);
isErroneous = true;
reference.addSubReference(lastReference);
return;
}
final Identifier lastField = lastReference.getId();
final List<ISubReference> baseReference = reference.getSubreferences(0, reference.getSubreferences().size() - 1);
reference.addSubReference(lastReference);
final Reference newReference = new TemporalReference(null, baseReference);
newReference.clearStringElementReferencing();
IType baseType = varType.getFieldType(timestamp, newReference, 1, Expected_Value_type.EXPECTED_DYNAMIC_VALUE, false);
if (baseType == null) {
isErroneous = true;
return;
}
baseType = baseType.getTypeRefdLast(timestamp);
if (baseType.getIsErroneous(timestamp)) {
isErroneous = true;
return;
}
CompField componentField;
switch(baseType.getTypetype()) {
case TYPE_TTCN3_SEQUENCE:
componentField = ((TTCN3_Sequence_Type) baseType).getComponentByName(lastField.getName());
if (componentField != null && !componentField.isOptional()) {
value.getLocation().reportSemanticError(MessageFormat.format(OMITTOMANDATORYASSIGNMENT2, lastField.getDisplayName(), baseType.getTypename()));
value.setIsErroneous(true);
}
break;
case TYPE_ASN1_SEQUENCE:
componentField = ((ASN1_Sequence_Type) baseType).getComponentByName(lastField);
if (componentField != null && !componentField.isOptional()) {
value.getLocation().reportSemanticError(MessageFormat.format(OMITTOMANDATORYASSIGNMENT2, lastField.getDisplayName(), baseType.getTypename()));
value.setIsErroneous(true);
}
break;
case TYPE_TTCN3_SET:
componentField = ((TTCN3_Set_Type) baseType).getComponentByName(lastField.getName());
if (componentField != null && !componentField.isOptional()) {
value.getLocation().reportSemanticError(MessageFormat.format(OMITTOMANDATORYASSIGNMENT2, lastField.getDisplayName(), baseType.getTypename()));
value.setIsErroneous(true);
}
break;
case TYPE_ASN1_SET:
componentField = ((ASN1_Set_Type) baseType).getComponentByName(lastField);
if (componentField != null && !componentField.isOptional()) {
value.getLocation().reportSemanticError(MessageFormat.format(OMITTOMANDATORYASSIGNMENT2, lastField.getDisplayName(), baseType.getTypename()));
value.setIsErroneous(true);
}
break;
default:
// TODO:check this!!!
value.getLocation().reportSemanticError(OMITTOMANDATORYASSIGNMENT1);
value.setIsErroneous(true);
isErroneous = true;
break;
}
} else {
final boolean isStringElement = reference.refersToStringElement();
selfReference = type.checkThisValue(timestamp, value, assignment, new ValueCheckingOptions(Expected_Value_type.EXPECTED_DYNAMIC_VALUE, true, false, !isStringElement, false, isStringElement));
if (isStringElement) {
// The length of the right hand side should be 1
final IType lastType = type.getTypeRefdLast(timestamp);
int stringLength = 1;
switch(lastType.getTypetype()) {
case TYPE_BITSTRING:
case TYPE_BITSTRING_A:
if (!Value_type.BITSTRING_VALUE.equals(lastValue.getValuetype())) {
return;
}
stringLength = ((Bitstring_Value) lastValue).getValueLength();
break;
case TYPE_HEXSTRING:
if (!Value_type.HEXSTRING_VALUE.equals(lastValue.getValuetype())) {
lastValue = null;
} else {
stringLength = ((Hexstring_Value) lastValue).getValueLength();
}
break;
case TYPE_OCTETSTRING:
if (!Value_type.OCTETSTRING_VALUE.equals(lastValue.getValuetype())) {
return;
}
stringLength = ((Octetstring_Value) lastValue).getValueLength();
break;
case TYPE_CHARSTRING:
case TYPE_NUMERICSTRING:
case TYPE_PRINTABLESTRING:
case TYPE_IA5STRING:
case TYPE_VISIBLESTRING:
case TYPE_UTCTIME:
case TYPE_GENERALIZEDTIME:
if (!Value_type.CHARSTRING_VALUE.equals(lastValue.getValuetype())) {
return;
}
stringLength = ((Charstring_Value) lastValue).getValueLength();
break;
case TYPE_UCHARSTRING:
case TYPE_UTF8STRING:
case TYPE_TELETEXSTRING:
case TYPE_VIDEOTEXSTRING:
case TYPE_GRAPHICSTRING:
case TYPE_GENERALSTRING:
case TYPE_UNIVERSALSTRING:
case TYPE_BMPSTRING:
case TYPE_OBJECTDESCRIPTOR:
if (Value_type.UNIVERSALCHARSTRING_VALUE.equals(lastValue.getValuetype())) {
stringLength = ((UniversalCharstring_Value) lastValue).getValueLength();
} else if (Value_type.CHARSTRING_VALUE.equals(lastValue.getValuetype())) {
stringLength = ((Charstring_Value) lastValue).getValueLength();
} else {
return;
}
break;
default:
lastValue = null;
return;
}
if (stringLength != 1) {
final String message = MessageFormat.format("The length of the string to be assigned to a string element of type `{0}'' should be 1 instead of {1}", type.getTypename(), stringLength);
value.getLocation().reportSemanticError(message);
value.setIsErroneous(true);
}
}
}
}
use of org.eclipse.titan.designer.AST.TTCN3.values.UniversalCharstring_Value in project titan.EclipsePlug-ins by eclipse.
the class SubType method addTtcnSingle.
/**
* add TTCN-3 single value sub-type constraint to this sub-type
*/
private boolean addTtcnSingle(final CompilationTimeStamp timestamp, final Value value, final int restrictionIndex) {
value.setMyScope(myOwner.getMyScope());
value.setMyGovernor(myOwner);
final BridgingNamedNode bridge = new BridgingNamedNode(myOwner, myOwner.getTypename() + ".<single_restriction_" + restrictionIndex + ">");
value.setFullNameParent(bridge);
IValue last = myOwner.checkThisValueRef(timestamp, value);
// check if this is type reference, if not then fall through
final IValue refValue = value.setLoweridToReference(timestamp);
// Value_type.REFERENCED_VALUE);
if (refValue.getValuetype() == Value.Value_type.REFERENCED_VALUE) {
final Reference ref = ((Referenced_Value) refValue).getReference();
final Assignment ass = ref.getRefdAssignment(timestamp, false);
if (ass == null) {
// definition was not found, error was reported
return false;
}
if (ass.getAssignmentType() == Assignment.Assignment_type.A_TYPE) {
IType t = ass.getType(timestamp);
t.check(timestamp);
if (t.getIsErroneous(timestamp)) {
return false;
}
final List<ISubReference> subrefs = ref.getSubreferences();
if (subrefs.size() > 1) {
// if there were sub-references then get the referenced field's type
t = t.getFieldType(timestamp, ref, 1, Expected_Value_type.EXPECTED_CONSTANT, false);
if ((t == null) || t.getIsErroneous(timestamp)) {
return false;
}
t.check(timestamp);
if (t.getIsErroneous(timestamp)) {
return false;
}
}
if (!t.isIdentical(timestamp, myOwner)) {
value.getLocation().reportSemanticError(MessageFormat.format("Reference `{0}'' must refer to a type which has the same root type as this type", ref.getDisplayName()));
return false;
}
// check subtype of referenced type
final SubType tSt = t.getSubtype();
if ((tSt == null) || (tSt.subtypeConstraint == null)) {
value.getLocation().reportSemanticError(MessageFormat.format("Type referenced by `{0}'' does not have a subtype", ref.getDisplayName()));
return false;
}
// check circular sub-type reference
if (!addParentSubtype(tSt)) {
return false;
}
if (tSt.getIsErroneous(timestamp)) {
return false;
}
if (tSt.subtypeType != subtypeType) {
ErrorReporter.INTERNAL_ERROR();
return false;
}
// add the sub-type as union
if (subtypeConstraint == null) {
subtypeConstraint = tSt.subtypeConstraint;
} else {
subtypeConstraint = subtypeConstraint.union(tSt.subtypeConstraint);
}
return true;
}
}
myOwner.checkThisValue(timestamp, last, null, new ValueCheckingOptions(Expected_Value_type.EXPECTED_CONSTANT, false, false, false, false, false));
final IReferenceChain chain = ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
last = last.getValueRefdLast(timestamp, chain);
chain.release();
if (last.getIsErroneous(timestamp) || last.isUnfoldable(timestamp)) {
return false;
}
// create a single value constraint
SubtypeConstraint sc;
switch(subtypeType) {
case ST_INTEGER:
sc = new RangeListConstraint(new IntegerLimit(((Integer_Value) last).getValueValue()));
break;
case ST_FLOAT:
sc = new RealRangeListConstraint(((Real_Value) last).getValue());
break;
case ST_BOOLEAN:
sc = new BooleanListConstraint(((Boolean_Value) last).getValue());
break;
case ST_VERDICTTYPE:
sc = new VerdicttypeListConstraint(((Verdict_Value) last).getValue());
break;
case ST_BITSTRING:
sc = new StringSizeAndValueListConstraint(StringSizeAndValueListConstraint.Type.BITSTRING, ((Bitstring_Value) last).getValue());
break;
case ST_HEXSTRING:
sc = new StringSizeAndValueListConstraint(StringSizeAndValueListConstraint.Type.HEXSTRING, ((Hexstring_Value) last).getValue());
break;
case ST_OCTETSTRING:
sc = new StringSizeAndValueListConstraint(StringSizeAndValueListConstraint.Type.OCTETSTRING, ((Octetstring_Value) last).getValue());
break;
case ST_CHARSTRING:
if (last.getValuetype() != Value.Value_type.CHARSTRING_VALUE) {
return false;
}
sc = new StringSetConstraint(StringSubtypeTreeElement.StringType.CHARSTRING, StringSetConstraint.ConstraintType.VALUE_CONSTRAINT, new StringValueConstraint(((Charstring_Value) last).getValue()));
break;
case ST_UNIVERSAL_CHARSTRING:
switch(last.getValuetype()) {
case CHARSTRING_VALUE:
sc = new StringSetConstraint(StringSubtypeTreeElement.StringType.UNIVERSAL_CHARSTRING, StringSetConstraint.ConstraintType.VALUE_CONSTRAINT, new UStringValueConstraint(new UniversalCharstring(((Charstring_Value) last).getValue())));
break;
case UNIVERSALCHARSTRING_VALUE:
sc = new StringSetConstraint(StringSubtypeTreeElement.StringType.UNIVERSAL_CHARSTRING, StringSetConstraint.ConstraintType.VALUE_CONSTRAINT, new UStringValueConstraint(((UniversalCharstring_Value) last).getValue()));
break;
default:
return false;
}
break;
case ST_OBJID:
case ST_ENUM:
case ST_UNION:
case ST_RECORD:
case ST_SET:
case ST_FUNCTION:
case ST_ALTSTEP:
case ST_TESTCASE:
sc = new ValueListConstraint(last);
break;
case ST_RECORDOF:
case ST_SETOF:
sc = new ValueListAndSizeConstraint(last);
break;
default:
ErrorReporter.INTERNAL_ERROR();
return false;
}
// add next value using union operation
if (subtypeConstraint == null) {
subtypeConstraint = sc;
} else {
subtypeConstraint = subtypeConstraint.union(sc);
}
return true;
}
use of org.eclipse.titan.designer.AST.TTCN3.values.UniversalCharstring_Value in project titan.EclipsePlug-ins by eclipse.
the class SubType method addTtcnRange.
private boolean addTtcnRange(final CompilationTimeStamp timestamp, final Value min, final boolean minExclusive, final Value max, final boolean maxExclusive, final int restrictionIndex) {
switch(subtypeType) {
case ST_INTEGER:
case ST_FLOAT:
case ST_CHARSTRING:
case ST_UNIVERSAL_CHARSTRING:
break;
default:
myOwner.getLocation().reportSemanticError(MessageFormat.format("Range subtyping is not allowed for type `{0}''", myOwner.getTypename()));
return false;
}
if (min == null || max == null) {
return false;
}
IValue vmin = null, vmax = null;
min.setMyScope(myOwner.getMyScope());
min.setMyGovernor(myOwner);
BridgingNamedNode bridge = new BridgingNamedNode(myOwner, myOwner.getFullName() + ".<range_restriction_" + restrictionIndex + "_lower>");
min.setFullNameParent(bridge);
IValue last = myOwner.checkThisValueRef(timestamp, min);
IType lastOwner = myOwner.getTypeRefdLast(timestamp);
if (lastOwner instanceof Integer_Type) {
((Integer_Type) lastOwner).checkThisValueLimit(timestamp, last, Expected_Value_type.EXPECTED_CONSTANT, false, false, false, false);
} else {
myOwner.checkThisValue(timestamp, last, null, new ValueCheckingOptions(Expected_Value_type.EXPECTED_CONSTANT, false, false, false, false, false));
}
IReferenceChain chain = ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
vmin = last.getValueRefdLast(timestamp, chain);
chain.release();
max.setMyScope(myOwner.getMyScope());
max.setMyGovernor(myOwner);
bridge = new BridgingNamedNode(myOwner, myOwner.getFullName() + ".<range_restriction_" + restrictionIndex + "_upper>");
max.setFullNameParent(bridge);
last = myOwner.checkThisValueRef(timestamp, max);
lastOwner = myOwner.getTypeRefdLast(timestamp);
if (lastOwner instanceof Integer_Type) {
((Integer_Type) lastOwner).checkThisValueLimit(timestamp, last, Expected_Value_type.EXPECTED_CONSTANT, false, false, false, false);
} else {
myOwner.checkThisValue(timestamp, last, null, new ValueCheckingOptions(Expected_Value_type.EXPECTED_CONSTANT, false, false, false, false, false));
}
chain = ReferenceChain.getInstance(IReferenceChain.CIRCULARREFERENCE, true);
vmax = last.getValueRefdLast(timestamp, chain);
chain.release();
if (vmin.getIsErroneous(timestamp) || vmin.isUnfoldable(timestamp)) {
// the error was already reported
return false;
}
if (vmax.getIsErroneous(timestamp) || vmax.isUnfoldable(timestamp)) {
// the error was already reported
return false;
}
SubtypeConstraint rangeConstraint;
switch(subtypeType) {
case ST_INTEGER:
{
IntegerLimit minLimit;
if (Value_type.REAL_VALUE.equals(vmin.getValuetype())) {
final Real_Value real = (Real_Value) vmin;
if (real.isNegativeInfinity()) {
minLimit = IntegerLimit.MINIMUM;
} else {
minLimit = IntegerLimit.MAXIMUM;
}
} else {
minLimit = new IntegerLimit(((Integer_Value) vmin).getValueValue());
}
IntegerLimit maxLimit;
if (Value_type.REAL_VALUE.equals(vmax.getValuetype())) {
final Real_Value real = (Real_Value) vmax;
if (real.isPositiveInfinity()) {
maxLimit = IntegerLimit.MAXIMUM;
} else {
maxLimit = IntegerLimit.MINIMUM;
}
} else {
maxLimit = new IntegerLimit(((Integer_Value) vmax).getValueValue());
}
if (minExclusive) {
if (minLimit.compareTo(IntegerLimit.MINIMUM) == 0) {
myOwner.getLocation().reportSemanticError("invalid lower boundary, -infinity cannot be excluded from an integer subtype range");
return false;
}
if (minLimit.compareTo(IntegerLimit.MAXIMUM) == 0) {
myOwner.getLocation().reportSemanticError("!infinity is not a valid lower boundary");
return false;
}
minLimit = (IntegerLimit) minLimit.increment();
}
if (maxExclusive) {
if (maxLimit.compareTo(IntegerLimit.MAXIMUM) == 0) {
myOwner.getLocation().reportSemanticError("invalid upper boundary, infinity cannot be excluded from an integer subtype range");
return false;
}
if (maxLimit.compareTo(IntegerLimit.MINIMUM) == 0) {
myOwner.getLocation().reportSemanticError("!-infinity is not a valid upper boundary");
return false;
}
maxLimit = (IntegerLimit) maxLimit.decrement();
}
if (maxLimit.compareTo(minLimit) < 0) {
Location.interval(min.getLocation(), max.getLocation()).reportSemanticError("lower boundary is bigger than upper boundary in integer subtype range");
return false;
}
rangeConstraint = new RangeListConstraint(minLimit, maxLimit);
break;
}
case ST_FLOAT:
{
if (Double.isNaN(((Real_Value) vmin).getValue())) {
min.getLocation().reportSemanticError("lower boundary cannot be not_a_number in float subtype range");
return false;
}
if (Double.isNaN(((Real_Value) vmax).getValue())) {
max.getLocation().reportSemanticError("upper boundary cannot be not_a_number in float subtype range");
return false;
}
RealLimit minLimit = new RealLimit(((Real_Value) vmin).getValue());
RealLimit maxLimit = new RealLimit(((Real_Value) vmax).getValue());
if (minExclusive) {
if (minLimit.compareTo(RealLimit.MAXIMUM) == 0) {
myOwner.getLocation().reportSemanticError("!infinity is not a valid lower boundary");
return false;
}
minLimit = (RealLimit) minLimit.increment();
}
if (maxExclusive) {
if (maxLimit.compareTo(RealLimit.MINIMUM) == 0) {
myOwner.getLocation().reportSemanticError("!-infinity is not a valid upper boundary");
return false;
}
maxLimit = (RealLimit) maxLimit.decrement();
}
if (maxLimit.compareTo(minLimit) < 0) {
Location.interval(min.getLocation(), max.getLocation()).reportSemanticError("lower boundary is bigger than upper boundary in float subtype range");
return false;
}
rangeConstraint = new RealRangeListConstraint(minLimit, maxLimit);
break;
}
case ST_CHARSTRING:
{
boolean erroneous = false;
if (Value_type.REAL_VALUE.equals(vmin.getValuetype()) && ((Real_Value) vmin).isNegativeInfinity()) {
getParsedLocation().reportSemanticError("lower boundary of a charstring subtype range cannot be -infinity");
erroneous = true;
}
if (Value_type.REAL_VALUE.equals(vmax.getValuetype()) && ((Real_Value) vmax).isPositiveInfinity()) {
getParsedLocation().reportSemanticError("upper boundary of a charstring subtype range cannot be infinity");
erroneous = true;
}
if (erroneous) {
return false;
}
String minString;
switch(vmin.getValuetype()) {
case CHARSTRING_VALUE:
minString = ((Charstring_Value) vmin).getValue();
break;
case UNIVERSALCHARSTRING_VALUE:
{
final UniversalCharstring ustr = ((UniversalCharstring_Value) vmin).getValue();
if ((ustr.length() < 1) || !ustr.get(0).isValidChar()) {
min.getLocation().reportSemanticError("lower boundary of charstring subtype range is not a valid char");
return false;
}
minString = String.valueOf((char) ustr.get(0).cell());
break;
}
default:
return false;
}
String maxString;
switch(vmax.getValuetype()) {
case CHARSTRING_VALUE:
maxString = ((Charstring_Value) vmax).getValue();
break;
case UNIVERSALCHARSTRING_VALUE:
{
final UniversalCharstring ustr = ((UniversalCharstring_Value) vmax).getValue();
if ((ustr.length() < 1) || !ustr.get(0).isValidChar()) {
max.getLocation().reportSemanticError("upper boundary of charstring subtype range is not a valid char");
return false;
}
maxString = String.valueOf((char) ustr.get(0).cell());
break;
}
default:
return false;
}
if (minString.length() != 1) {
min.getLocation().reportSemanticError("lower boundary of charstring subtype range must be a single element string");
return false;
}
if (maxString.length() != 1) {
max.getLocation().reportSemanticError("upper boundary of charstring subtype range must be a single element string");
return false;
}
CharLimit minLimit = new CharLimit(minString.charAt(0));
CharLimit maxLimit = new CharLimit(maxString.charAt(0));
if (minExclusive) {
if (minLimit.compareTo(CharLimit.MAXIMUM) == 0) {
min.getLocation().reportSemanticError("exclusive lower boundary is not a legal charstring character");
return false;
}
minLimit = (CharLimit) minLimit.increment();
}
if (maxExclusive) {
if (maxLimit.compareTo(CharLimit.MINIMUM) == 0) {
max.getLocation().reportSemanticError("exclusive upper boundary is not a legal charstring character");
return false;
}
maxLimit = (CharLimit) maxLimit.decrement();
}
if (maxLimit.compareTo(minLimit) < 0) {
Location.interval(min.getLocation(), max.getLocation()).reportSemanticError("lower boundary is bigger than upper boundary in charstring subtype range");
return false;
}
rangeConstraint = new StringSetConstraint(StringSubtypeTreeElement.StringType.CHARSTRING, StringSetConstraint.ConstraintType.ALPHABET_CONSTRAINT, new RangeListConstraint(minLimit, maxLimit));
break;
}
case ST_UNIVERSAL_CHARSTRING:
{
boolean erroneous = false;
if (Value_type.REAL_VALUE.equals(vmin.getValuetype()) && ((Real_Value) vmin).isNegativeInfinity()) {
min.getLocation().reportSemanticError("lower boundary of a universal charstring subtype range cannot be -infinity");
erroneous = true;
}
if (Value_type.REAL_VALUE.equals(vmax.getValuetype()) && ((Real_Value) vmax).isPositiveInfinity()) {
max.getLocation().reportSemanticError("upper boundary of a universal charstring subtype range cannot be infinity");
erroneous = true;
}
if (erroneous) {
return false;
}
UniversalCharstring minString;
switch(vmin.getValuetype()) {
case CHARSTRING_VALUE:
minString = new UniversalCharstring(((Charstring_Value) vmin).getValue());
break;
case UNIVERSALCHARSTRING_VALUE:
minString = ((UniversalCharstring_Value) vmin).getValue();
break;
default:
return false;
}
UniversalCharstring maxString;
switch(vmax.getValuetype()) {
case CHARSTRING_VALUE:
maxString = new UniversalCharstring(((Charstring_Value) vmax).getValue());
break;
case UNIVERSALCHARSTRING_VALUE:
maxString = ((UniversalCharstring_Value) vmax).getValue();
break;
default:
return false;
}
if (minString.length() != 1) {
min.getLocation().reportSemanticError("lower boundary of universal charstring subtype range must be a single element string");
return false;
}
if (maxString.length() != 1) {
max.getLocation().reportSemanticError("upper boundary of universal charstring subtype range must be a single element string");
return false;
}
UCharLimit minLimit = new UCharLimit(minString.get(0));
UCharLimit maxLimit = new UCharLimit(maxString.get(0));
if (minExclusive) {
if (minLimit.compareTo(UCharLimit.MAXIMUM) == 0) {
min.getLocation().reportSemanticError("exclusive lower boundary is not a legal universal charstring character");
return false;
}
minLimit = (UCharLimit) minLimit.increment();
}
if (maxExclusive) {
if (maxLimit.compareTo(UCharLimit.MINIMUM) == 0) {
max.getLocation().reportSemanticError("exclusive upper boundary is not a legal universal charstring character");
return false;
}
maxLimit = (UCharLimit) maxLimit.decrement();
}
if (maxLimit.compareTo(minLimit) < 0) {
Location.interval(min.getLocation(), max.getLocation()).reportSemanticError("lower boundary is bigger than upper boundary in universal charstring subtype range");
return false;
}
rangeConstraint = new StringSetConstraint(StringSubtypeTreeElement.StringType.UNIVERSAL_CHARSTRING, StringSetConstraint.ConstraintType.ALPHABET_CONSTRAINT, new RangeListConstraint(minLimit, maxLimit));
break;
}
default:
ErrorReporter.INTERNAL_ERROR();
return false;
}
subtypeConstraint = (subtypeConstraint == null) ? rangeConstraint : subtypeConstraint.union(rangeConstraint);
return true;
}
Aggregations