public class MyDslErrorMessageProvider extends SyntaxErrorMessageProvider {

	@Override
	public SyntaxErrorMessage getSyntaxErrorMessage(IParserErrorContext context) {
		//SyntaxErrorMessage syntaxError1=new SyntaxErrorMessage("Name should start with a letter", IssueCodes.AMBIGUOUS_FEATURE_CALL);
		if(context.getRecognitionException() instanceof RecognitionException){
			return new SyntaxErrorMessage("Name should start with a letter", IssueCodes.AMBIGUOUS_FEATURE_CALL);
			
		}
		return super.getSyntaxErrorMessage(context);
	}

	@Override
	public SyntaxErrorMessage getSyntaxErrorMessage(IValueConverterErrorContext context) {
		// TODO Auto-generated method stub
		return null;
	}

}

val unexpectedText = context?.recognitionException?.token?.text
val currNode = context?.currentNode

for (node : currNode.asTreeIterable) {
			println(unexpectedText)
			println(node.getGrammarElement())
			
			println(node.getGrammarElement() == MyDslGrammarAccess.getDefinitionStreamAccess().srcSource1ParserRuleCall_4_0)
			println(GrammarUtil::getAllKeywords(MyDslGrammarAccess.getGrammar()).contains(node.text))
			
			if(node.getGrammarElement() == MyDslGrammarAccess.getDefinitionStreamAccess().srcSource1ParserRuleCall_4_0 && GrammarUtil::getAllKeywords(MyDslGrammarAccess.getGrammar()).contains(node.text)){
				println(context.defaultMessage)
				return new SyntaxErrorMessage('''"«unexpectedText»" is a reserved keyword which is not allowed as Identifier.''',USED_RESERVED_KEYWORD)
			}
		}

val unexpectedText = context?.recognitionException?.token?.text

if (GrammarUtil::getAllKeywords(MyDslGrammarAccess.getGrammar()).contains(unexpectedText)) {

            return new SyntaxErrorMessage('''"«unexpectedText»" is a reserved keyword which is not allowed as Identifier.''',USED_RESERVED_KEYWORD)  
        }

Model:
	greetings+=Greeting*;
	
Greeting:
	'Hello' name=ID '!';

import com.google.inject.Inject
import org.antlr.runtime.RecognitionException
import org.eclipse.xtext.GrammarUtil
import org.eclipse.xtext.nodemodel.SyntaxErrorMessage
import org.eclipse.xtext.parser.antlr.SyntaxErrorMessageProvider
import org.xtext.example.mydsl2.services.MyDslGrammarAccess

class MyDslErrorMessageProvider extends SyntaxErrorMessageProvider {

	@Inject MyDslGrammarAccess ga

	override SyntaxErrorMessage getSyntaxErrorMessage(IParserErrorContext context) {
		if (context.getRecognitionException() instanceof RecognitionException) {
			val unexpectedText = context?.recognitionException?.token?.text

			if (GrammarUtil::getAllKeywords(ga.grammar).contains(unexpectedText)) {

				return new SyntaxErrorMessage('''"«unexpectedText»" is a reserved keyword which is not allowed as Identifier.''',
					"bääääääh")
			}
		}
		return super.getSyntaxErrorMessage(context)
	}

	override SyntaxErrorMessage getSyntaxErrorMessage(IValueConverterErrorContext context) {
		// TODO Auto-generated method stub
		return null
	}
}

Model:
         a*((=>b|=>c|=>d)=>(';'(=>b|=>c|=>d))*=>(';' e ';'?))
;

Model:
         a*((b)=>(';'(b))*=>(';' e ';'?))
;

Model:
	(elements += ExecutionPlan)*
;

ExecutionPlan:
	(appAnn+=AppAnnotation)*( 
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction)=>(';' 
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction))*
	=>(';'(exElement+=ExecutionElement))* ';'?) 
;

Model:
	(elements += ExecutionPlan)*
;

ExecutionPlan:
	(appAnn+=AppAnnotation)*( 
	(=>defStream+=DefinitionStream)=>(';' 
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction))*
	=>(';'(exElement+=ExecutionElement))* ';'?) 
;

Model:
	(elements += ExecutionPlan)*
;

ExecutionPlan:
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction)=>(';' 
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction))*
	=>(';'(exElement+=ExecutionElement))* ';'?
;
ExecutionElement:
	(que=Query)
;
DefinitionStream:
	{DefinitionStream}(ann += Annotation)* DEFINE STREAM src=Source1 
;
DefinitionTable:
	{DefinitionTable}(ann1 += Annotation)* DEFINE TABLE src=Source1 
;
DefinitionWindow:
	{DefinitionWindow}(ann2 += Annotation)* DEFINE WINDOW src=Source1  func_body=FunctionBody 
;
DefinitionTrigger:
	{DefinitionTrigger}(DEFINE TRIGGER) tn=TriggerName AT (every=EVERY sv=StringValue) 
;

DefinitionFunction:
	{DefinitionFunction}(DEFINE FUNCTION) fn=FunctionName '[' ln=LanguageName ']' RETURN func_body=FunctionBody 
;
Annotation:
	'@' na = ID ('(' (annElement += AnnotationElement | ann += Annotation) 
		( ',' (annElement += AnnotationElement | ann += Annotation))* ')'	)
;

AnnotationElement:
	(propName = PropertyName '=')? propVal = PropertyValue
;

PropertyValue:
	sv=StringValue
;

PropertyName:
	{PropertyName} na+=ID (ps+=PropertySeparator na += ID )*
;

PropertySeparator:
	{PropertySeparator}DOT |{PropertySeparator} MINUS |{PropertySeparator} COL
;

FunctionName:
	id=ID
;

LanguageName:
	id=ID
;

FunctionBody:
	value=SCRIPT
;

terminal SCRIPT:
	'{' SCRIPT_ATOM* '}'
;

terminal SCRIPT_ATOM:
  ! ('{' | '}')
  | '"' (!'"')* '"'
  | '//' !('\r'|'\n')*
  | SCRIPT
;
StringValue:
	sl=STRING_LITERAL
;
STRING_LITERAL:
	STRING
;
TriggerName:
	id=ID
;
Source:
	strId=[Source1|IdNew] 
;

Source1:
	inner='#'? name=IdNew
;
IdNew: ID;
Query:
	{Query}(ann3 += Annotation)* FROM source=Source 
;
Keyword:
	{Keyword} STREAM 
	|{Keyword} DEFINE 
	|{Keyword} FROM 
	|{Keyword} TABLE
	|{Keyword} WINDOW
	|{Keyword} RETURN
	|{Keyword} every=EVERY
;
EVERY: (every='every' );
fragment STREAM: (str='stream');
fragment DEFINE: (define='define' );
fragment TABLE: (table='table' );
fragment WINDOW: (window='window' );
fragment TRIGGER: (trigger='trigger' );
fragment AT: (at='at' );
fragment FUNCTION: (function='function');
fragment RETURN: (return='return');
fragment FROM: (from='from');

COL : ':';
DOT : '.';
MINUS : '-';

class MyDslErrorMessageProvider extends SyntaxErrorMessageProvider {
	
	public static val String USED_RESERVED_KEYWORD = "USED_RESERVED_KEYWORD"
	 
	override getSyntaxErrorMessage(IParserErrorContext context) {
		val unexpectedText = context?.recognitionException?.token?.text
		
	    if (GrammarUtil::getAllKeywords(siddhiGrammarAccess.getGrammar()).contains(unexpectedText)) {

            println(context.defaultMessage)

            return new SyntaxErrorMessage('''"«unexpectedText»" is a reserved keyword which is not allowed as Identifier.''',USED_RESERVED_KEYWORD)  

           }

        super.getSyntaxErrorMessage(context)
		
	}
	
	override getSyntaxErrorMessage(IValueConverterErrorContext context) {
		throw new UnsupportedOperationException("TODO: auto-generated method stub")
	}
	
}

define stream str1;
from str1;

define table table1;
from table1; 

define table stream

define stream str1;
from str1;

define table table1;
from table1;

//1st input
define stream table
//2nd input
define table 
//3rd input
define table window
//4th input
define stream str1;
from

Model:
	(elements += ExecutionPlan)*
;

ExecutionPlan:
	(=>defStream+=DefinitionStream)=>(';' 
	(=>defStream+=DefinitionStream|=>defTable+=DefinitionTable| =>def_window+=DefinitionWindow| =>defTrigger+=DefinitionTrigger|=>defFunction+=DefinitionFunction))*
	=>(';'(exElement+=ExecutionElement))* ';'?
;
ExecutionElement:
	(que=Query)
;
DefinitionStream:
	{DefinitionStream}(ann += Annotation)* DEFINE (STREAM|TABLE ) src=Source1 
;
DefinitionWindow:
	{DefinitionWindow}(ann2 += Annotation)* DEFINE WINDOW src=Source1  func_body=FunctionBody 
;
DefinitionTrigger:
	{DefinitionTrigger}(DEFINE TRIGGER) tn=TriggerName AT (every=EVERY sv=StringValue) 
;

DefinitionFunction:
	{DefinitionFunction}(DEFINE FUNCTION) fn=FunctionName '[' ln=LanguageName ']' RETURN func_body=FunctionBody 
;