grammar SemwidgQL;

options {
    // antlr will generate java lexer and parser
    language = JavaScript;
    // generated parser should create abstract syntax tree
    output = AST;
}

tokens {
  Query; 
  SimpleQuery; 
  PathExpression; 
  MultiplePathExpression; 
  Resource; 
  NamedResource; 
  QualifiedResource; 
  PrefixedResource; 
  QualifiedProperty; 
  PrefixedProperty; 
  ForwardProperty;
  ForwardPropertyWithFilter; 
  ReversedProperty; 
  ReversedPropertyWithFilter; 
  ConditionalExpression; 
  ConditionalOrExpression; 
  ConditionalAndExpression; 
  Expression;
  RelationalExpression; 
  NumericExpression; 
  NestedQuery; 
  UnaryExpression; 
  PrimaryExpression; 
  Property; 
  NumericalLiteral; 
  NumericLiteralUnsigned; 
  NumericLiteralPositive; 
  NumericLiteralNegative;  
  RelationalOperator; 
  AdditiveExpression; 
  MultiplicativeExpression; 
  AdditionalUnaryExpression; 
  AdditionalExpression; 
  StringLiteral; 
  BooleanLiteral; 
  KeywordExpression;
  Language;
  Type;
  Self;
  Timeinterval;
  Timestart;
  Timeend;
  Aggregate;
  Hide;
  Optional;
  Predicate;
  StringExpression;
  Contains;
  ForwardWildcard;
  ForwardWildcardWithFilter;
  ReversedWildcard;
  ReversedWildcardWithFilter;
}

semwidg: query;

query
    : Whitespace* simpleQuery ( Whitespace* ConditionalOr Whitespace* simpleQuery )* Whitespace* -> ^(Query simpleQuery ( simpleQuery )*)
    ;
 
simpleQuery
    : resource ( Whitespace* Dot Whitespace* pathExpression)? -> ^(SimpleQuery resource ( pathExpression )?)
    ;


resource
    : namedResource -> ^(Resource namedResource)
    | qualifiedResource -> ^(Resource qualifiedResource)
    | prefixedResource -> ^(Resource prefixedResource)
    | forwardWildcard -> ^(Resource forwardWildcard)
    | forwardWildcardWithFilter -> ^(Resource forwardWildcardWithFilter)
    ;

namedResource
    : Name -> ^(NamedResource Name)
    ;

prefixedResource
    : NamespacePrefix Name -> ^(PrefixedResource NamespacePrefix Name)
    ;

qualifiedResource
    : RelationalLower Iri RelationalGreater -> ^(QualifiedResource Iri)
    ;


pathExpression
    : property ( Whitespace* Dot Whitespace* property)* ( Whitespace* Dot Whitespace* multiplePathExpression )? -> 
        ^(PathExpression property ( property )* ( multiplePathExpression )?)
    | multiplePathExpression -> ^(PathExpression multiplePathExpression)
    ;

property
    : forwardProperty -> ^(Property forwardProperty)
    | forwardPropertyWithFilter -> ^(Property forwardPropertyWithFilter)
    | reversedProperty -> ^(Property reversedProperty)
    | reversedPropertyWithFilter -> ^(Property reversedPropertyWithFilter)
    | forwardWildcard -> ^(Property forwardWildcard)
    | forwardWildcardWithFilter -> ^(Property forwardWildcardWithFilter)
    | reversedWildcard -> ^(Property reversedWildcard)
    | reversedWildcardWithFilter -> ^(Property reversedWildcardWithFilter)
    ;

forwardProperty
    : qualifiedProperty -> ^(ForwardProperty qualifiedProperty)
    | prefixedProperty -> ^(ForwardProperty prefixedProperty)
    ;

forwardPropertyWithFilter
    : qualifiedProperty Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis -> 
        ^(ForwardPropertyWithFilter qualifiedProperty conditionalExpression )
    | prefixedProperty Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis -> 
        ^(ForwardPropertyWithFilter prefixedProperty conditionalExpression )
    ;

reversedProperty
    : Caret Whitespace* qualifiedProperty -> ^(ReversedProperty qualifiedProperty)
    | Caret Whitespace* prefixedProperty -> ^(ReversedProperty prefixedProperty)
    ;

reversedPropertyWithFilter
    : Caret Whitespace* qualifiedProperty Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis -> 
        ^(ReversedPropertyWithFilter qualifiedProperty conditionalExpression )
    | Caret Whitespace* prefixedProperty Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis -> 
        ^(ReversedPropertyWithFilter prefixedProperty conditionalExpression )
    ;

forwardWildcard
    : wildcard -> ^(ForwardWildcard)
    ;

forwardWildcardWithFilter
    : wildcard Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis ->
        ^(ForwardWildcardWithFilter conditionalExpression)
    ;

reversedWildcard
    : Caret Whitespace* wildcard -> ^(ReversedWildcard)
    ;

reversedWildcardWithFilter
    : Caret Whitespace* wildcard Whitespace* OpenParenthesis Whitespace* conditionalExpression Whitespace* CloseParenthesis ->
        ^(ReversedWildcardWithFilter conditionalExpression)
    ;

qualifiedProperty
    : RelationalLower Iri RelationalGreater -> ^(QualifiedProperty RelationalLower Iri RelationalGreater)
    ;

prefixedProperty
    : NamespacePrefix Name -> ^(PrefixedProperty NamespacePrefix Name)
    ;

wildcard
    : Asterisk
    ;

multiplePathExpression
    : OpenBracket Whitespace* pathExpression Whitespace* ( Comma Whitespace* pathExpression Whitespace* )* CloseBracket -> 
        ^(MultiplePathExpression pathExpression ( pathExpression )* )
    ;

conditionalExpression
    : conditionalOrExpression -> ^(ConditionalExpression conditionalOrExpression)
    ;

conditionalOrExpression
    : conditionalAndExpression ( Whitespace+ ConditionalOr Whitespace+ conditionalAndExpression )* ->
      ^(ConditionalOrExpression conditionalAndExpression ( conditionalAndExpression )*)
    ;

conditionalAndExpression
    : expression ( Whitespace+ ConditionalAnd Whitespace+ expression )* ->
      ^(ConditionalAndExpression expression ( expression )*)
    ;
    
expression
    : relationalExpression -> ^(Expression relationalExpression)
    | keywordExpression -> ^(Expression keywordExpression)
    ;

relationalExpression
    : property ( Whitespace* Dot Whitespace* property)* ( Whitespace+ relationalOperator Whitespace+ numericExpression )? ->
      ^(RelationalExpression property ( property )* ( relationalOperator numericExpression )?)
    ;

numericExpression
    : additiveExpression -> ^(NumericExpression additiveExpression)
    ;
    
additiveExpression
    : multiplicativeExpression additionalExpression* -> ^(AdditiveExpression multiplicativeExpression additionalExpression*)
    ;

multiplicativeExpression
    : unaryExpression additionalUnaryExpression* -> ^(MultiplicativeExpression unaryExpression additionalUnaryExpression*)
    ;

additionalExpression /*added*/
    : Whitespace* Plus Whitespace* multiplicativeExpression -> ^(AdditionalExpression Plus multiplicativeExpression)
    | Whitespace* Minus Whitespace* multiplicativeExpression -> ^(AdditionalExpression Minus multiplicativeExpression) 
    | numericLiteralPositive -> ^(AdditionalExpression numericLiteralPositive) 
    | numericLiteralNegative -> ^(AdditionalExpression numericLiteralNegative)
    ;

additionalUnaryExpression /*added*/
    : Whitespace* Asterisk Whitespace* unaryExpression -> ^(AdditionalUnaryExpression Asterisk unaryExpression)
    | Whitespace* Divide Whitespace* unaryExpression -> ^(AdditionalUnaryExpression Divide unaryExpression)
    ;
    
unaryExpression
    : Not Whitespace* primaryExpression -> ^(UnaryExpression Not primaryExpression)
    | Plus Whitespace* primaryExpression -> ^(UnaryExpression Plus primaryExpression)
    | Minus Whitespace* primaryExpression -> ^(UnaryExpression Minus primaryExpression)
    | primaryExpression -> ^(UnaryExpression primaryExpression)
    ;
    
primaryExpression
    : forwardProperty -> ^(PrimaryExpression forwardProperty)
    | nestedQuery -> ^(PrimaryExpression nestedQuery)
    | stringLiteral -> ^(PrimaryExpression stringLiteral)
    | numericLiteral -> ^(PrimaryExpression numericLiteral)
    | booleanLiteral -> ^(PrimaryExpression booleanLiteral)
    ;

nestedQuery
    : OpenBrace Whitespace* simpleQuery Whitespace* CloseBrace -> ^(NestedQuery simpleQuery)
    ;
    
stringLiteral
    : StringLiteral1 -> ^(StringLiteral StringLiteral1)
    | StringLiteral2 -> ^(StringLiteral StringLiteral2)
    ;
    
booleanLiteral
    : Boolean -> ^(BooleanLiteral Boolean)
    ;
    
numericLiteral
    : numericLiteralUnsigned -> ^(NumericalLiteral numericLiteralUnsigned)
    | numericLiteralPositive -> ^(NumericalLiteral numericLiteralPositive)
    | numericLiteralNegative -> ^(NumericalLiteral numericLiteralNegative)
    ;

numericLiteralUnsigned
    : Integer -> ^(NumericLiteralUnsigned Integer)
    | Decimal -> ^(NumericLiteralUnsigned Decimal)
    | DoubleValue -> ^(NumericLiteralUnsigned DoubleValue)
    ;

numericLiteralPositive
    : IntegerPositive -> ^(NumericLiteralPositive IntegerPositive)
    | DecimalPositive -> ^(NumericLiteralPositive DecimalPositive)
    | DoublePositive -> ^(NumericLiteralPositive DoublePositive)
    ;

numericLiteralNegative
    : IntegerNegative -> ^(NumericLiteralNegative IntegerNegative)
    | DecimalNegative -> ^(NumericLiteralNegative DecimalNegative)
    | DoubleNegative -> ^(NumericLiteralNegative DoubleNegative)
    ;
    
keywordExpression
    : language -> ^(KeywordExpression language)
    | type -> ^(KeywordExpression type)
    | self -> ^(KeywordExpression self)
    | timeinterval -> ^(KeywordExpression timeinterval)
    | timestart -> ^(KeywordExpression timestart)
    | timeend -> ^(KeywordExpression timeend)
    | aggregate -> ^(KeywordExpression aggregate)
    | hide -> ^(KeywordExpression hide)
    | optional -> ^(KeywordExpression optional)
    | predicate -> ^(KeywordExpression predicate)
    ;
    
language
    : '@lang' Whitespace+ RelationalEqual Whitespace+ stringLiteral -> ^(Language stringLiteral)
    ;
    
type
    : '@type' Whitespace+ relationalEqualityOperator Whitespace+ forwardProperty -> ^(Type relationalEqualityOperator forwardProperty)
    ;
    
self
    : '@self' Whitespace+ relationalOperator Whitespace+ numericExpression -> ^(Self relationalOperator numericExpression)
    ;
    
timeinterval
    : '@timeinterval' Whitespace+ RelationalEqual Whitespace+ stringLiteral -> ^(Timeinterval stringLiteral)
    ;
    
timestart
    : '@timestart' Whitespace+ RelationalEqual Whitespace+ stringLiteral -> ^(Timestart stringLiteral)
    ;
    
timeend
    : '@timeend' Whitespace+ RelationalEqual Whitespace+ stringLiteral -> ^(Timeend stringLiteral)
    ;
    
aggregate
    : '@aggregate' Whitespace+ RelationalEqual Whitespace+ stringLiteral -> ^(Aggregate stringLiteral)
    ;

hide
    : '@hide' Whitespace+ RelationalEqual Whitespace+ booleanLiteral -> ^(Hide booleanLiteral)
    ;
    
optional
    : '@optional' Whitespace+ RelationalEqual Whitespace+ booleanLiteral -> ^(Optional booleanLiteral)
    ;
    
predicate
    : '@predicate' Whitespace+ RelationalEqual Whitespace+ booleanLiteral -> ^(Predicate booleanLiteral)
    ;
    
relationalOperator
    : RelationalEqual -> ^(RelationalOperator RelationalEqual)
    | RelationalNotEqual -> ^(RelationalOperator RelationalNotEqual)
    | RelationalGreater -> ^(RelationalOperator RelationalGreater)
    | RelationalGreaterEqual -> ^(RelationalOperator RelationalGreaterEqual)
    | RelationalLower -> ^(RelationalOperator RelationalLower)
    | RelationalLowerEqual -> ^(RelationalOperator RelationalLowerEqual)
    | ContainsOperator -> ^(RelationalOperator ContainsOperator)
    ;
    
relationalEqualityOperator
    : RelationalEqual -> ^(RelationalOperator RelationalEqual)
    | RelationalNotEqual -> ^(RelationalOperator RelationalNotEqual)
    ;
    

// LEXER rules

Whitespace
    : ' '
    | '\t'
    | '\f'
    | LineBreak
    ;

Dot 
    : '.'
    ;
    
Comma
    : ','
    ;

Caret 
    : '\u005E'
    ;

Integer
    : Digit+
    ;

IntegerPositive
    : Plus Integer
    ;

DecimalPositive
    : Plus Decimal
    ;

DoublePositive
    : Plus DoubleValue
    ;

IntegerNegative
    : Minus Integer
    ;

DecimalNegative
    : Minus Decimal
    ;

DoubleNegative
    : Minus DoubleValue
    ;

DoubleValue
    : Digit+ Dot Digit* Exponent
    | Dot Digit+ Exponent
    | Digit+ Exponent
    ;

Decimal
    : Digit+ Dot Digit*
    | Dot Digit+
    ;
    
StringLiteral1
    : '\'' ( ~( '\u0027' | '\u005C' | '\u000A' | '\u000D' )  | EscapedChar )* '\''
    ;

StringLiteral2
    : '"' ( ~( '\u0022' | '\u005C' | '\u000A' | '\u000D' )  | EscapedChar )* '"'
    ;

Boolean
    : ('T'|'t') ('R'|'r') ('U'|'u') ('E'|'e')
    | ('F'|'f') ('A'|'a') ('L'|'l') ('S'|'s') ('E'|'e')
    ;

Name
    : ( NameCharWithUnderscore | Digit ) ( ( CharValue )* CharValue )?
    ;

NamespacePrefix 
    : Prefix ':' 
    ;

fragment Prefix
		: NameChar CharValue*
		;

fragment NameChar
    : 'A'..'Z'
    | 'a'..'z'
    | '\u00C0'..'\u00D6'
    | '\u00D8'..'\u00F6'
    | '\u00F8'..'\u02FF'
    | '\u0370'..'\u037D'
    | '\u037F'..'\u1FFF'
    | '\u200C'..'\u200D'
    | '\u2070'..'\u218F'
    | '\u2C00'..'\u2FEF'
    | '\u3001'..'\uD7FF'
    | '\uF900'..'\uFDCF'
    | '\uFDF0'..'\uFFFD'
    | '\u1000'..'\uEFFF'
    ;

fragment CharValue
    : NameCharWithUnderscore
    | AdditionalNameChar
    | Digit
    | EscapedDot
    ;

fragment NameCharWithUnderscore
    : NameChar
    | Underscore
    ;

fragment Underscore
    : '_'
    ;
    
fragment AdditionalNameChar
    : '\u00B7'
    | '\u0300'..'\u036F'
    | '\u203F'..'\u2040'
    | Minus
    ;

Plus 
    : '+'
    ;

Minus 
    : '-'
    ;

Asterisk
    : '*'
    ;

Divide
    : '/'
    ;
    
EscapedDot
    : '\\.'
    ;

fragment Exponent
    : ( 'e' | 'E' ) ( Plus | Minus )? Digit+
    ;
    
fragment EscapedChar
    : '\\' ('t' | 'b' | 'n' | 'r' | 'f' | '\\' | '"' | '\'')
    ;

fragment LineBreak
    : '\n'
    | '\r'
    | '\r\n'
    ;

Not 
    : '!'
    ;
    
ConditionalOr
    : '|'
    | '||'
    ;

ConditionalAnd
    : '&'
    | '&&'
    ;
    
RelationalEqual
    : '='
    | '=='
    ;

RelationalNotEqual
    : '!='
    ;

RelationalGreater
    : '>'
    ;

RelationalGreaterEqual
    : '>='
    ;

RelationalLower
    : '<'
    ;

RelationalLowerEqual
    : '<='
    ;
    
ContainsOperator
    : '~'
    ;
    
OpenParenthesis
		: '('
		;

CloseParenthesis
		: ')'
		;

OpenBrace
    : '{'
    ;

CloseBrace
    : '}'
    ;
    
OpenBracket
    : '['
    ;
    
CloseBracket
    : ']'
    ;
    
fragment Digit
    : '0'..'9'
    ;

Iri
    : 'http' Any*
    ;
    
fragment Any
    : ~(RelationalLower | RelationalGreater)
    ;