header {
/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.asn1.compiler.parser;

import java.util.*;
import org.apache.asn1.compiler.stages.parser.*;
import org.apache.asn1.compiler.stages.parser.primitive.*;
import org.apache.asn1.compiler.stages.parser.x680.*;
import org.apache.asn1.compiler.stages.parser.x680.element.*;
}

class ASN1Parser extends Parser;
options {
    k=5;
}

tokens {
    REAL_NUMBER;
    INTEGER_NUMBER;
}

compile returns [Environment environment]
{
    Module module;
    environment = new Environment();
}
    : (module = module_definition { environment.addModule(module); })+ ;

/*
 * X.680-0207
 */
module_definition returns [Module module]
{
    module = new Module();
    ModuleIdentifier id;
}
    : id=module_identifier { module.setModuleIdentifier(id); }
      DEFINITIONS
      (tag_default[module])?
      (extension_default[module])?
      ASSIGNMENT BEGIN module_body[module] END
    ;

module_identifier returns [ModuleIdentifier id]
{
    ModuleReference mr;
    DefinitiveIdentifier did;
    id = new ModuleIdentifier();
}
    : mr=module_reference { id.setModuleReference(mr); } (did=definative_identifier { id.setDefinitiveIdentifier(did); } )?
    ;

definative_identifier returns [DefinitiveIdentifier id]
{ id = new DefinitiveIdentifier(); }
    : LEFT_CURLY (definitive_obj_id_component[id])+ RIGHT_CURLY
    ;

definitive_obj_id_component[DefinitiveIdentifier id]
    : s1:IDENTIFIER { id.addNameForm(s1); }
    | n1:INTEGER_NUMBER { id.addNumberForm(new IntegerPrimitive(n1)); }
    | s2:IDENTIFIER LEFT_PAREN n2:INTEGER_NUMBER RIGHT_PAREN  { id.addNameAndNumberForm(s2, new IntegerPrimitive(n2)); }
    ;

tag_default[Module module]
    : EXPLICIT TAGS { module.setTagDefault(TagDefaultEnum.EXPLICIT); }
    | IMPLICIT TAGS { module.setTagDefault(TagDefaultEnum.IMPLICIT); }
    | AUTOMATIC TAGS { module.setTagDefault(TagDefaultEnum.AUTOMATIC); }
    ;

extension_default[Module module]
    : EXTENSIBILITY IMPLIED { module.setExtensibilityImplied(true); }
    ;

module_body[Module module]
    : (assignment[module])+
    ;

assignment[Module module]
{
    TypeAssignment ta;
    ValueAssignment va;
}
    : ta=type_assignment { module.addTypeAssignment(ta); }
    | va=value_assignment { module.addValueAssignment(va); }
    ;

type_assignment returns [TypeAssignment ta]
{
    ta = new TypeAssignment();
    Type t;
}
    : tr:TYPEREFERENCE { ta.setTypeReference(new TypeReference(tr)); } ASSIGNMENT t=type { ta.setType(t); }
    ;

type_assignment_test returns [TypeAssignment ta] { ta = null; } : ta=type_assignment ;

type returns [Type type]
{
    Type t;
    ConstrainedType ct;
    Constraint c;
    type = null;
}
    : t=builtin_type { type = t; } (c=constraint { ct = new ConstrainedType(); ct.setType(t); ct.setConstraint(c); type=ct; })?
    | type=referenced_type
    ;

builtin_type returns [Type type]
{ type = null; }
    : type=bitstring_type
    | type=boolean_type
    | type=octet_string_type
    | type=sequence_type
    | type=sequence_of_type
    | type=integer_type
    ;

bitstring_type returns [BitStringType bitStringType]
{ bitStringType = new BitStringType(); }
    : BIT STRING (LEFT_CURLY namedbit (COMMA namedbit)+ RIGHT_CURLY)?
    ;

namedbit
    : IDENTIFIER LEFT_PAREN INTEGER_NUMBER RIGHT_PAREN
    ;

boolean_type returns [BooleanType booleanType]
{ booleanType = new BooleanType(); }
    : b:BOOLEAN { booleanType.setToken(b); }
    ;

octet_string_type returns [OctetStringType octetStringType]
{ octetStringType = new OctetStringType(); }
    : o:OCTET STRING { octetStringType.setToken(o); }
    ;

character_string_type
    : BMPSTRING
    | GENERAL_STRING
    | GRAPHIC_STRING
    | IA5_STRING
    | ISO646_STRING
    | NUMERIC_STRING
    | PRINTABLE_STRING
    | TELETEX_STRING
    | T61_STRING
    | UNIVERSAL_STRING
    | UTF8_STRING
    | VIDEOTEX_STRING
    | VISIBLE_STRING
    | CHARACTER STRING
    ;

sequence_type returns [SequenceType sequenceType]
{
    ComponentTypeLists ctl;
    sequenceType = new SequenceType();
}
    : SEQUENCE LEFT_CURLY RIGHT_CURLY
    | SEQUENCE LEFT_CURLY ctl=component_type_lists RIGHT_CURLY { sequenceType.setComponentTypeLists(ctl); }
    ;

sequence_of_type returns [SequenceOfType sequenceOfType]
{
    Type t;
    sequenceOfType = new SequenceOfType();
}
    : SEQUENCE OF t=type { sequenceOfType.setType(t); }
    | SEQUENCE OF t=named_type { sequenceOfType.setType(t); }
    ;

referenced_type returns [ReferencedType referencedType]
{
    Object r;
    referencedType = new ReferencedType();
}
    : r=defined_type { referencedType.setReference(r); }
    ;

defined_type returns [DefinedType definedType]
{ definedType = new DefinedType(); }
    : tr:TYPEREFERENCE { definedType.setDefinition(new TypeReference(tr)); }
    ;

component_type_lists returns [ComponentTypeLists componentTypeLists]
{
    ComponentTypeList ctl;
    componentTypeLists = new ComponentTypeLists();
}
    : ctl=root_component_type_list { componentTypeLists.setComponentTypeList(ctl); }
    ;

root_component_type_list returns [ComponentTypeList componentTypeList]
{ componentTypeList = null; }
    : componentTypeList=component_type_list
    ;

component_type_list returns [ComponentTypeList componentTypeList]
  {
      Type t;
      componentTypeList = new ComponentTypeList();
  }

    : t=component_type { componentTypeList.add(t); } (COMMA t=component_type { componentTypeList.add(t); })*
    ;

component_type returns [ComponentType componentType]
{
    Type t;
    Value v;
    componentType = new ComponentType();
}
    : t=named_type { componentType.setType(t); }
      (  OPTIONAL { componentType.setComponentTypeEnum(ComponentTypeEnum.OPTIONAL); }
       | DEFAULT v=value { componentType.setValue(v); componentType.setComponentTypeEnum(ComponentTypeEnum.DEFAULT); })?
    | COMPONENTS OF t=type { componentType.setType(t); componentType.setComponentTypeEnum(ComponentTypeEnum.COMPONENTS_OF); }
    ;

named_type returns [NamedType namedType]
{
    Type t;
    namedType = new NamedType();
}
    : id:IDENTIFIER
      (LEFT_SQUARE tid:INTEGER_NUMBER RIGHT_SQUARE { namedType.setTag( new Tag(new IntegerPrimitive(tid))); } )?
      t=type { namedType.setName(id); namedType.setType(t); }
    ;

integer_type returns [IntegerType t]
{ t = new IntegerType(); }
    : i:INTEGER { t.setToken(i); }
    ;

value returns [Value v]
{ v = null; }
    : v=builtin_value
    | IDENTIFIER
    ;

builtin_value returns [Value value]
{ value = null; }
    : value=boolean_value
    | value=integer_value
    ;

boolean_value returns [BooleanPrimitive v]
{ v = new BooleanPrimitive(); }
    : b1:TRUE  { v.setToken(b1); }
    | b2:FALSE { v.setToken(b2); }
    ;

integer_value returns [IntegerPrimitive v]
{ v = new IntegerPrimitive(); }
    : MINUS i1:INTEGER_NUMBER  { v.setNegative(true); v.setToken(i1); }
    | i2:INTEGER_NUMBER { v.setToken(i2); }
    ;

value_assignment returns [ValueAssignment va]
{
    va = new ValueAssignment();
    Type t;
    Value v;
}
    : id:IDENTIFIER { va.setValueReference(new ValueReference(id)); } t=type { va.setType(t); } ASSIGNMENT v=value { va.setValue(v); }
    ;

constraint returns [Constraint constraint]
{
    ConstraintSpec cs;
    constraint = new Constraint();
}
    : LEFT_PAREN cs=constraint_spec RIGHT_PAREN { constraint.setConstraintSpec(cs); }
    ;

constraint_spec returns [ConstraintSpec constraintSpec]
{ constraintSpec = null; }
    : constraintSpec=subtype_constraint
    ;

subtype_constraint returns [SubtypeConstraintSpec subtypeConstraintSpec]
{
    ElementSetSpec ess;
    subtypeConstraintSpec = new SubtypeConstraintSpec();
}
    : ess=element_set_specs { subtypeConstraintSpec.setElementSetSpec(ess); }
    ;

element_set_specs returns [ElementSetSpec elementSetSpec]
{ elementSetSpec = null; }
    : elementSetSpec=root_element_set_spec
    ;

root_element_set_spec returns [ElementSetSpec elementSetSpec]
{ elementSetSpec = null; }
    : elementSetSpec=element_set_spec
    ;

element_set_spec returns [ElementSetSpec elementSetSpec]
{ elementSetSpec = null; }
    : elementSetSpec=unions
    ;

unions returns [Union union]
{
    Intersection i;
    union = new Union();
}
    : i=intersections { union.addIntersection(i); }
    ;

intersections returns [Intersection intersection]
{
    Element ie;
    intersection = new Intersection();
}
    : ie=intersection_elements { intersection.addElement(ie); }
    ;

intersection_elements returns [Element element]
{ element = null; }
    : element=elements
    ;

elements returns [Element element]
{ element = null; }
    : element=subtype_elements
    ;

subtype_elements returns [Element element]
{ element = null; }
    : element=value_range
    ;

value_range returns [ValueRange valueRange]
{
    LowerEndpoint le;
    UpperEndpoint ue;
    valueRange = new ValueRange();
}
    : le=lower_endpoint RANGE ue=upper_endpoint { valueRange.setLowerEndpoint(le); valueRange.setUpperEndpoint(ue); }
    ;

lower_endpoint returns [LowerEndpoint le]
{
    Value v;
    le = new LowerEndpoint();
}
    : v=value { le.setValue(v); } (LESS_THAN { le.setOpen(true); })?
    | MIN { le.setMin(true); } (LESS_THAN { le.setOpen(true); })?
    ;

upper_endpoint returns [UpperEndpoint ue]
{
    Value v;
    ue = new UpperEndpoint();
}
    :  (LESS_THAN { ue.setOpen(true); })? v=value { ue.setValue(v); }
    |  (LESS_THAN { ue.setOpen(true); })? MAX { ue.setMax(true); }
    ;


/*
 * X.681-0207
 */


/*
 * X.682-0207
 */

/*
 * X.683-0207
 */

number
    : INTEGER_NUMBER
    | REAL_NUMBER
    | BINARY_STRING
    | HEXADECIMAL_STRING
    ;

module_reference returns [ModuleReference reference]
{ reference = new ModuleReference(); }
    : tr:TYPEREFERENCE { reference.setToken(tr); }
    ;

value_reference : IDENTIFIER;
type_reference : TYPEREFERENCE;
object_reference : value_reference;
word : type_reference;
object_set_reference : type_reference;
type_field_reference : AMPERSAND type_reference;
value_field_reference : AMPERSAND value_reference;
value_set_field_reference : AMPERSAND value_reference;
object_field_reference : AMPERSAND object_reference;
object_set_field_reference : AMPERSAND object_reference;
object_class_reference : AMPERSAND type_reference;


{
import org.apache.asn1.compiler.*;
}
class ASN1Compiler extends TreeParser;
options {
    defaultErrorHandler=false;
}

modules : ( ABSENT );

class ASN1Lexer extends Lexer;
options {
    k=3;
    charVocabulary = '\3'..'\377' | '\u1000'..'\u1fff';
}

/*
 * X.680-0207
 */
tokens {
    ABSENT = "ABSENT";
    ABSTRACT_SYNTAX = "ABSTRACT-SYNTAX";
    ALL = "ALL";
    ANY = "ANY";
    ARGUMENT = "ARGUMENT";
    APPLICATION = "APPLICATION";
    AUTOMATIC = "AUTOMATIC";
    BASEDNUM = "BASEDNUM";
    BEGIN = "BEGIN";
    BIT = "BIT";
    BMPSTRING = "BMPString";
    BOOLEAN = "BOOLEAN";
    BY = "BY";
    CHARACTER = "CHARACTER";
    CHOICE = "CHOICE";
    CLASS = "CLASS";
    COMPONENTS = "COMPONENTS";
    COMPONENT = "COMPONENT";
    CONSTRAINED = "CONSTRAINED";
    DEFAULT = "DEFAULT";
    DEFINED= "DEFINED";
    DEFINITIONS = "DEFINITIONS";
    EMBEDDED = "EMBEDDED";
    END = "END";
    ENUMERATED  = "ENUMERATED";
    ERROR  = "ERROR";
    ERRORS = "ERRORS";
    EXCEPT = "EXCEPT";
    EXPLICIT = "EXPLICIT";
    EXPORTS = "EXPORTS";
    EXTENSIBILITY = "EXTENSIBILITY";
    EXTERNAL = "EXTERNAL";
    FALSE = "FALSE";
    FROM = "FROM";
    GENERALIZED_TIME = "GeneralizedTime";
    GENERAL_STRING = "GeneralString";
    GRAPHIC_STRING = "GraphicString";
    IA5_STRING = "IA5String";
    IDENTIFIER = "IDENTIFIER";
    IMPLICIT = "IMPLICIT";
    IMPLIED = "IMPLIED";
    IMPORTS = "IMPORTS";
    INCLUDES = "INCLUDES";
    INSTANCE = "INSTANCE";
    INTEGER = "INTEGER";
    INTERSECTION = "INTERSECTION";
    ISO646_STRING = "ISO646String";
    LINKED = "LINKED";
    MAX = "MAX";
    MINUS_INFINITY = "MINUSINFINITY";
    MIN = "MIN";
    NULL = "NULL";
    NUMERIC_STRING = "NumericString";
    OBJECT_DESCRIPTOR = "ObjectDescriptor";
    OBJECT = "OBJECT";
    OCTET = "OCTET";
    OPERATION = "OPERATION";
    OF = "OF";
    OID = "OID";
    OPTIONAL = "OPTIONAL";
    PARAMETER = "PARAMETER";
    PDV = "PDV";
    PLUS_INFINITY = "PLUSINFINITY";
    PRESENT = "PRESENT";
    PRINTABLE_STRING = "PrintableString";
    PRIVATE = "PRIVATE";
    REAL = "REAL";
    RELATIVE = "RELATIVE";
    RESULT = "RESULT";
    SEQUENCE = "SEQUENCE";
    SET = "SET";
    SIZE = "SIZE";
    STRING = "STRING";
    T61_STRING = "T61String";
    TAGS = "TAGS";
    TELETEX_STRING = "TeletexString";
    TRUE = "TRUE";
    TYPE_IDENTIFIER = "TYPE-IDENTIFIER";
    UNION = "UNION";
    UNIQUE = "UNIQUE";
    UNIVERSAL = "UNIVERSAL";
    UNIVERSAL_STRING = "UniversalString";
    UTC_TIME = "UTCTime";
    UTF8_STRING = "UTF8String";
    VIDEOTEX_STRING = "VideotexString";
    VISIBLE_STRING = "VisibleString";
    WITH = "WITH";

/*
 * X.680-0207
 */

    REFERENCE = "Reference";
}

NEWLINE
    : ((('\r''\n') => '\r''\n') | '\r' | '\n')
        { newline(); $setType(Token.SKIP); }
    ;

WS : ( ' ' | '\t' | '\f' ) { $setType(Token.SKIP); } ;

COMMENT : "--" ;

SL_COMMENT
	: COMMENT
	  ({ LA(2)!='-' }? '-' | ~('-'|'\n'|'\r'))*
	  (((('\r''\n') => '\r''\n') | '\r' | '\n') {newline();} | COMMENT)
        { $setType(Token.SKIP); }
	;

ASSIGNMENT : "::=";

IDENTIFIER : SMALL_LETTER ( (HYPHEN)? (SMALL_LETTER | CAPITAL_LETTER | DIGIT) )* ;
TYPEREFERENCE : CAPITAL_LETTER ( (HYPHEN)? (SMALL_LETTER | CAPITAL_LETTER | DIGIT) )* ;

NUMBER : DIGITS (DOT (DIGIT)* (EXPONENT)? { $setType(REAL_NUMBER); } | { $setType(INTEGER_NUMBER); } ) ;


protected DIGITS : ( ('1'..'9') (DIGIT)* | '0' );

protected EXPONENT
    : ('e'|'E') ('+'|'-')? (DIGIT)+
    ;

NUMBER_STRING : "'" (HEX_DIGIT | WS)* ("'B" {$setType(BINARY_STRING);} | "'H" {$setType(HEXADECIMAL_STRING);} );

protected CAPITAL_LETTER : 'A'..'Z';
protected SMALL_LETTER : 'a'..'z';
protected DIGIT : '0'..'9';
protected HEX_DIGIT : ('0'..'9' | 'A'..'F');
EXCLAMATION_MARK : '!';
QUOTATION_MARK : '"';
AMPERSAND : '&';
APOSTROPHE : '\'';
LEFT_PAREN : '(';
RIGHT_PAREN : ')';
ASTERISK : '*';
COMMA : ',';
HYPHEN : '-';
DOT : '.';
SOLIDUS : '/';
COLON : ':';
SEMICOLON : ';';
LESS_THAN : '<';
EQUALS : '=';
GREATER_THAN : '>';
AT : '@';
LEFT_SQUARE : '[';
RIGHT_SQUARE : ']';
CIRCUMFLEX : '^';
UNDERSCORE : '_';
LEFT_CURLY : '{';
BAR : '|';
RIGHT_CURLY : '}';
RANGE : "..";
ELLIPSIS : "...";