import org.opendaylight.controller.antlrv4.code.gen.YangParser.Mandatory_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Mandatory_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Max_elements_stmtContext;
+import org.opendaylight.controller.antlrv4.code.gen.YangParser.Max_value_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Min_elements_stmtContext;
+import org.opendaylight.controller.antlrv4.code.gen.YangParser.Min_value_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Must_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Numerical_restrictionsContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_argContext;
}
if (value < -2147483648 || value > 2147483647) {
throw new YangParseException(
+ ctx.getStart().getLine(),
"Error on enum '"
+ name
+ "': the enum value MUST be in the range from -2147483648 to 2147483647, but was: "
try {
result = Long.valueOf(value);
} catch (NumberFormatException e) {
- throw new YangParseException("Error on line " + line
- + ": Unable to parse range value '" + value + "'.", e);
+ throw new YangParseException(line,
+ "Unable to parse range value '" + value + "'.", e);
}
}
return result;
}
+ /**
+ * Parse type body and return pattern constraints.
+ *
+ * @param ctx
+ * type body
+ * @return list of pattern constraints
+ */
private static List<PatternConstraint> getPatternConstraint(
final Type_body_stmtsContext ctx) {
List<PatternConstraint> patterns = new ArrayList<PatternConstraint>();
}
/**
- * Get fraction digits value from context.
+ * Get fraction digits value from type body.
*
* @param ctx
* type body context to parse
return result;
}
+ /**
+ * Parse decimal64 fraction-digits value.
+ *
+ * @param ctx
+ * decimal64 context
+ * @return fraction-digits value as Integer
+ */
private static Integer parseFractionDigits(
Decimal64_specificationContext ctx) {
Integer result = null;
try {
result = Integer.valueOf(value);
} catch (NumberFormatException e) {
- throw new YangParseException(
+ throw new YangParseException(ctx.getStart().getLine(),
"Unable to parse fraction digits value '" + value
+ "'.", e);
}
}
if (position < 0 || position > 4294967295L) {
throw new YangParseException(
+ ctx.getStart().getLine(),
"Error on bit '"
+ name
+ "': the position value MUST be in the range 0 to 4294967295");
public static TypeDefinition<?> parseUnknownTypeBody(QName typedefQName,
Type_body_stmtsContext ctx) {
UnknownType.Builder unknownType = new UnknownType.Builder(typedefQName);
-
if (ctx != null) {
List<RangeConstraint> rangeStatements = getRangeConstraints(ctx);
List<LengthConstraint> lengthStatements = getLengthConstraints(ctx);
unknownType.patterns(patternStatements);
unknownType.fractionDigits(fractionDigits);
}
-
return unknownType.build();
}
type = new Decimal64(actualPath, namespace, revision,
fractionDigits);
} else if (typeName.startsWith("int")) {
- if (typeName.equals("int8")) {
+ if ("int8".equals(typeName)) {
type = new Int8(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("int16")) {
+ } else if ("int16".equals(typeName)) {
type = new Int16(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("int32")) {
+ } else if ("int32".equals(typeName)) {
type = new Int32(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("int64")) {
+ } else if ("int64".equals(typeName)) {
type = new Int64(actualPath, namespace, revision,
rangeStatements, null, null);
}
} else if (typeName.startsWith("uint")) {
- if (typeName.equals("uint8")) {
+ if ("uint8".equals(typeName)) {
type = new Uint8(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("uint16")) {
+ } else if ("uint16".equals(typeName)) {
type = new Uint16(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("uint32")) {
+ } else if ("uint32".equals(typeName)) {
type = new Uint32(actualPath, namespace, revision,
rangeStatements, null, null);
- } else if (typeName.equals("uint64")) {
+ } else if ("uint64".equals(typeName)) {
type = new Uint64(actualPath, namespace, revision,
rangeStatements, null, null);
}
return type;
}
+ /**
+ * Parse given context and find identityref base value.
+ *
+ * @param ctx
+ * type body
+ * @return identityref base value as String
+ */
public static String getIdentityrefBase(Type_body_stmtsContext ctx) {
String result = null;
outer: for (int i = 0; i < ctx.getChildCount(); i++) {
return result;
}
+ /**
+ * Parse given context and find require-instance value.
+ *
+ * @param ctx
+ * type body
+ * @return require-instance value
+ */
private static boolean isRequireInstance(Type_body_stmtsContext ctx) {
for (int i = 0; i < ctx.getChildCount(); i++) {
ParseTree child = ctx.getChild(i);
return false;
}
+ /**
+ * Parse given context and find leafref path.
+ *
+ * @param ctx
+ * type body
+ * @return leafref path as String
+ */
private static String parseLeafrefPath(Type_body_stmtsContext ctx) {
for (int i = 0; i < ctx.getChildCount(); i++) {
ParseTree child = ctx.getChild(i);
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree childNode = ctx.getChild(i);
if (childNode instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(childNode));
- constraints.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) childNode);
+ constraints.setMaxElements(max);
} else if (childNode instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(childNode));
+ Integer min = parseMinElements((Min_elements_stmtContext) childNode);
constraints.setMinElements(min);
} else if (childNode instanceof Must_stmtContext) {
MustDefinition must = parseMust((Must_stmtContext) childNode);
}
}
+ private static Integer parseMinElements(Min_elements_stmtContext ctx) {
+ Integer result = null;
+ try {
+ for (int j = 0; j < ctx.getChildCount(); j++) {
+ ParseTree minArg = ctx.getChild(j);
+ if (minArg instanceof Min_value_argContext) {
+ result = Integer.valueOf(stringFromNode(minArg));
+ }
+ }
+ if (result == null) {
+ throw new IllegalArgumentException();
+ }
+ return result;
+ } catch (Exception e) {
+ throw new YangParseException(ctx.getStart().getLine(),
+ "Failed to parse min-elements.", e);
+ }
+ }
+
+ private static Integer parseMaxElements(Max_elements_stmtContext ctx) {
+ Integer result = null;
+ try {
+ for (int j = 0; j < ctx.getChildCount(); j++) {
+ ParseTree maxArg = ctx.getChild(j);
+ if (maxArg instanceof Max_value_argContext) {
+ result = Integer.valueOf(stringFromNode(maxArg));
+ }
+ }
+ if (result == null) {
+ throw new IllegalArgumentException();
+ }
+ return result;
+ } catch (Exception e) {
+ throw new YangParseException(ctx.getStart().getLine(),
+ "Failed to parse max-elements.", e);
+ }
+ }
+
/**
* Parse given context and return yin value.
*
} else if ("leafref".equals(typeName)) {
throw new YangParseException(moduleName, line,
"The 'path' statement MUST be present if the type is 'leafref'.");
- } else if("bits".equals(typeName)) {
+ } else if ("bits".equals(typeName)) {
throw new YangParseException(moduleName, line,
"The 'bit' statement MUST be present if the type is 'bits'.");
- } else if("enumeration".equals(typeName)) {
+ } else if ("enumeration".equals(typeName)) {
throw new YangParseException(moduleName, line,
"The 'enum' statement MUST be present if the type is 'enumeration'.");
}
}
- public static RefineHolder parseRefine(Refine_stmtContext child) {
- final String refineTarget = stringFromNode(child);
- final RefineHolder refine = new RefineHolder(refineTarget, child
+ /**
+ * Parse refine statement.
+ *
+ * @param refineCtx
+ * refine statement
+ * @param line
+ * current line in yang model
+ * @return RefineHolder object representing this refine statement
+ */
+ public static RefineHolder parseRefine(Refine_stmtContext refineCtx) {
+ final String refineTarget = stringFromNode(refineCtx);
+ final RefineHolder refine = new RefineHolder(refineTarget, refineCtx
.getStart().getLine());
- for (int j = 0; j < child.getChildCount(); j++) {
- ParseTree refinePom = child.getChild(j);
+ for (int j = 0; j < refineCtx.getChildCount(); j++) {
+ ParseTree refinePom = refineCtx.getChild(j);
if (refinePom instanceof Refine_pomContext) {
for (int k = 0; k < refinePom.getChildCount(); k++) {
ParseTree refineStmt = refinePom.getChild(k);
+ parseRefineDefault(refine, refineStmt);
+
if (refineStmt instanceof Refine_leaf_stmtsContext) {
parseRefine(refine,
(Refine_leaf_stmtsContext) refineStmt);
return refine;
}
+ private static void parseRefineDefault(RefineHolder refine,
+ ParseTree refineStmt) {
+ for (int i = 0; i < refineStmt.getChildCount(); i++) {
+ ParseTree refineArg = refineStmt.getChild(i);
+ if (refineArg instanceof Description_stmtContext) {
+ String description = stringFromNode(refineArg);
+ refine.setDescription(description);
+ } else if (refineArg instanceof Reference_stmtContext) {
+ String reference = stringFromNode(refineArg);
+ refine.setReference(reference);
+ } else if (refineArg instanceof Config_stmtContext) {
+ boolean config = parseConfig((Config_stmtContext) refineArg);
+ refine.setConfig(config);
+ }
+ }
+ }
+
private static RefineHolder parseRefine(RefineHolder refine,
Refine_leaf_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
MustDefinition must = parseMust((Must_stmtContext) refineArg);
refine.setMust(must);
} else if (refineArg instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(refineArg));
- refine.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) refineArg);
+ refine.setMaxElements(max);
} else if (refineArg instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(refineArg));
+ Integer min = parseMinElements((Min_elements_stmtContext) refineArg);
refine.setMinElements(min);
}
}
MustDefinition must = parseMust((Must_stmtContext) refineArg);
refine.setMust(must);
} else if (refineArg instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(refineArg));
- refine.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) refineArg);
+ refine.setMaxElements(max);
} else if (refineArg instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(refineArg));
+ Integer min = parseMinElements((Min_elements_stmtContext) refineArg);
refine.setMinElements(min);
}
}