generator.java

JAVA的加密库之一

		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "OBJECT_IDENTIFIER");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAOidBuiltInType(AOidBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "OBJECT_IDENTIFIER";
			break;
		}
	}

	public void inAPrintableBuiltInType(APrintableBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "PRINTABLE_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAPrintableBuiltInType(APrintableBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "PRINTABLE_STRING";
			break;
		}
	}

	public void inANumericBuiltInType(ANumericBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "NUMERIC_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outANumericBuiltInType(ANumericBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "NUMERIC_STRING";
			break;
		}
	}

	public void inATeletexBuiltInType(ATeletexBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "T61_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outATeletexBuiltInType(ATeletexBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "T61_STRING";
			break;
		}
	}

	public void inAVideotexBuiltInType(AVideotexBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "VIDEOTEX_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAVideotexBuiltInType(AVideotexBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "VIDEOTEX_STRING";
			break;
		}
	}

	public void inAVisibleBuiltInType(AVisibleBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "ISO646_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAVisibleBuiltInType(AVisibleBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "ISO646_STRING";
			break;
		}
	}

	public void inAIa5BuiltInType(AIa5BuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "IA5_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAIa5BuiltInType(AIa5BuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "IA5_STRING";
			break;
		}
	}

	public void inAGraphicBuiltInType(AGraphicBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "GRAPHIC_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAGraphicBuiltInType(AGraphicBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "GRAPHIC_STRING";
			break;
		}
	}

	public void inAGeneralBuiltInType(AGeneralBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "GENERAL_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAGeneralBuiltInType(AGeneralBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "GENERAL_STRING";
			break;
		}
	}

	public void inAUniversalBuiltInType(AUniversalBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "UNIVERSAL_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAUniversalBuiltInType(AUniversalBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "UNIVERSAL_STRING";
			break;
		}
	}

	public void inABmpBuiltInType(ABmpBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "BMP_STRING");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outABmpBuiltInType(ABmpBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "BMP_STRING";
			break;
		}
	}

	public void inAGmtBuiltInType(AGmtBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "GENERALIZED_TIME");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAGmtBuiltInType(AGmtBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "GENERALIZED_TIME";
			break;
		}
	}

	public void inAUtcBuiltInType(AUtcBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "UTC_TIME");
			state = REFERENCE_ONLY;
			break;
		}
	}

	public void outAUtcBuiltInType(AUtcBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			type = "UTC_TIME";
			break;
		}
	}

	public void inAChoiceBuiltInType(AChoiceBuiltInType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			data.clear();
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "CHOICE");
			state = REFERENCE_ONLY;
			break;
		case REFERENCE_ONLY:
			break;
		}
	}

	public void outAChoiceBuiltInType(AChoiceBuiltInType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			//
			// should handle inner classes here
			//
			if (data.isEmpty())
				throw new RuntimeException("CHOICE with no alternatives");
			generateChoice(data);
			type = "CHOICE";
			state = NOT_GENERATING;
			break;
		}
	}

	public void inATaggedAuxType(ATaggedAuxType node) {
		StringBuffer sb = new StringBuffer("new Tag(");
		Node c = node.getClazz();
		Node n = node.getClassNumber();
		Node t = node.getTagDefault();
		if (c == null)
			sb.append("Tag.CONTEXT, ");
		else if (c instanceof AUniversalClazz)
			sb.append("Tag.UNIVERSAL, ");
		else if (c instanceof AAppClazz)
			sb.append("Tag.APPLICATION, ");
		else if (c instanceof APrivateClazz)
			sb.append("Tag.PRIVATE, ");

		if (n instanceof ANumericClassNumber)
			sb.append(((ANumericClassNumber) n).getNumber().getText().trim());
		else
			throw new RuntimeException("Dont know how to handle this yet");

      if (t == null) // should use module default
         sb.append(", Module.EXPLICIT_TAGGING");
      else if (t instanceof AExplicitTagDefault)
         sb.append(", true");
      else
         sb.append(", false");

	   tag = sb.append(")").toString();
	}

	public void inASetOfAuxType(ASetOfAuxType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			outBuiltInClass(isPublic, className, "SET_OF");

			data.clear();

			state = REFERENCE_ONLY;
			break;
		case REFERENCE_ONLY:
			break;
		}
	}

	public void outASetOfAuxType(ASetOfAuxType node) {
		defaultOut(node);
		switch (state) {
		case GENERATING:
			break;
		case REFERENCE_ONLY:
			//
			// should handle inner classes here
			//
			if (data.isEmpty())
				generateCompound(type);
			else
				generateCompound(data);

			type = "SET_OF";

			state = NOT_GENERATING;
			break;
		}
	}

	public void inASetAuxType(ASetAuxType node) {
		defaultIn(node);
		switch (state) {
		case GENERATING:
			boolean isPublic = ast.isPublic(moduleName, className);
			String superType = "SET";