antlr4 Hello.g4

HelloLexer.interp
HelloLexer.java
HelloLexer.tokens
Hello.interp
HelloParser.java
HelloListener.java
HelloBaseListener.java
Hello.tokens

javac Hello*.java

/usr/share/antlr4/grun Hello r -tree
or
/usr/share/antlr4/grun Hello r -gui

grammar Calc;
parse : expr EOF;
expr  : expr '*' expr
      | expr '/' expr
      | expr '+' expr
      | expr '-' expr
      | N
      | '-' N;
N     : [0-9]
      | [1-9][0-9]+;
WS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines

export CLASSPATH=.:/usr/share/java/antlr4.jar:/usr/share/java/antlr4-runtime.jar:/usr/share/java:${CLASSPATH}
antlr4 Calc.g4
javac Calc*java

/usr/share/antlr4/grun Calc parse -gui

grammar Calc;
parse : expr EOF;
expr  : '(' expr ')'
      | expr '*' expr
      | expr '/' expr
      | expr '+' expr
      | expr '-' expr
      | N
      | '-' N
      | '-' '(' expr ')' ;
N     : [0-9]
      | [1-9][0-9]+;
WS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines

export CLASSPATH=.:/usr/share/java/antlr4.jar:/usr/share/java/antlr4-runtime.jar:/usr/share/java:${CLASSPATH}
antlr4 Calc.g4
javac Calc*java

/usr/share/antlr4/grun Calc parse -gui

grammar Calc;
lines:
     | equation
     | lines equation
     | EOF;
equation : expr CR
	 | expr EOF;
expr  : '(' expr ')'
      | expr '*' expr
      | expr '/' expr
      | expr '+' expr
      | expr '-' expr
      | N
      | '-' N
      | '-' '(' expr ')' ;
N     : [0-9]
      | [1-9][0-9]+;
CR  : [\n;];          // newlines, semicolons
WS : [ \t]+ -> skip ; // skip spaces, tabs

export CLASSPATH=.:/usr/share/java/antlr4.jar:/usr/share/java/antlr4-runtime.jar:/usr/share/java:${CLASSPATH}
antlr4 Calc.g4
javac Calc*java

/usr/share/antlr4/grun Calc lines -gui

grammar Calc;
lines:
     | equation
     | lines equation
     | EOF;
equation : expr CR
	 | expr EOF;
expr  : '(' expr ')' #myBr
      | expr '*' expr #myMul
      | expr '/' expr #myDiv
      | expr '+' expr #myAdd
      | expr '-' expr #mySub
      | N #myNum
      | '-' N #myMinusNum
      | '-' '(' expr ')' #myMinus ;
N     : [0-9]
      | [1-9][0-9]+;
CR  : [\n;];           // newlines, semicolons
WS : [ \t]+ -> skip ;  // skip spaces, tabs

antlr4 -Dlanguage=Python3 Calc.g4

import ipdb
import sys
from antlr4 import *
from CalcLexer import CalcLexer
from CalcParser import CalcParser
from CalcListener import CalcListener

class KeyPrinter(CalcListener):
    def exitKey(self, ctx):
        pass

def main(argv):
    input = InputStream(argv[1])
    lexer = CalcLexer(input)
    stream = CommonTokenStream(lexer)
    parser = CalcParser(stream)
    tree = parser.lines()
    #print(tree.getChild(0))
    #print(tree.getChild(0).getText())
    ##print(tree.getChild(0).toStringTree())
    #ipdb.set_trace()
    printer = KeyPrinter()
    walker = ParseTreeWalker()
    walker.walk(printer, tree)

if __name__ == '__main__':
    main(sys.argv)

# Generated from Calc.g4 by ANTLR 4.9.1
from antlr4 import *
if __name__ is not None and "." in __name__:
    from .CalcParser import CalcParser
else:
    from CalcParser import CalcParser

# This class defines a complete listener for a parse tree produced by CalcParser.
class CalcListener(ParseTreeListener):

    # Enter a parse tree produced by CalcParser#lines.
    def enterLines(self, ctx:CalcParser.LinesContext):
        pass

    # Exit a parse tree produced by CalcParser#lines.
    def exitLines(self, ctx:CalcParser.LinesContext):
        print("exitLines")
        pass


    # Enter a parse tree produced by CalcParser#equation.
    def enterEquation(self, ctx:CalcParser.EquationContext):
        pass

    # Exit a parse tree produced by CalcParser#equation.
    def exitEquation(self, ctx:CalcParser.EquationContext):
        print("exitEquation")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myMul.
    def enterMyMul(self, ctx:CalcParser.MyMulContext):
        pass

    # Exit a parse tree produced by CalcParser#myMul.
    def exitMyMul(self, ctx:CalcParser.MyMulContext):
        print("exitMyMul")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myNum.
    def enterMyNum(self, ctx:CalcParser.MyNumContext):
        pass

    # Exit a parse tree produced by CalcParser#myNum.
    def exitMyNum(self, ctx:CalcParser.MyNumContext):
        print("exitMyNum")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myMinusNum.
    def enterMyMinusNum(self, ctx:CalcParser.MyMinusNumContext):
        pass

    # Exit a parse tree produced by CalcParser#myMinusNum.
    def exitMyMinusNum(self, ctx:CalcParser.MyMinusNumContext):
        print("exitMyMinusNum")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myMinus.
    def enterMyMinus(self, ctx:CalcParser.MyMinusContext):
        pass

    # Exit a parse tree produced by CalcParser#myMinus.
    def exitMyMinus(self, ctx:CalcParser.MyMinusContext):
        print("exitMyMinus")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#mySub.
    def enterMySub(self, ctx:CalcParser.MySubContext):
        pass

    # Exit a parse tree produced by CalcParser#mySub.
    def exitMySub(self, ctx:CalcParser.MySubContext):
        print("exitMySub")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myDiv.
    def enterMyDiv(self, ctx:CalcParser.MyDivContext):
        pass

    # Exit a parse tree produced by CalcParser#myDiv.
    def exitMyDiv(self, ctx:CalcParser.MyDivContext):
        print("exitMyDiv")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myAdd.
    def enterMyAdd(self, ctx:CalcParser.MyAddContext):
        pass

    # Exit a parse tree produced by CalcParser#myAdd.
    def exitMyAdd(self, ctx:CalcParser.MyAddContext):
        print("exitMyAdd")
        print(ctx.getText())
        pass


    # Enter a parse tree produced by CalcParser#myBr.
    def enterMyBr(self, ctx:CalcParser.MyBrContext):
        pass

    # Exit a parse tree produced by CalcParser#myBr.
    def exitMyBr(self, ctx:CalcParser.MyBrContext):
        pass



del CalcParser

# Generated from Calc.g4 by ANTLR 4.9.1
from antlr4 import *
from collections import deque
if __name__ is not None and "." in __name__:
    from .CalcParser import CalcParser
else:
    from CalcParser import CalcParser

# This class defines a complete listener for a parse tree produced by CalcParser.
class CalcListener(ParseTreeListener):
    s = deque([])

    # Enter a parse tree produced by CalcParser#lines.
    def enterLines(self, ctx:CalcParser.LinesContext):
        pass

    # Exit a parse tree produced by CalcParser#lines.
    def exitLines(self, ctx:CalcParser.LinesContext):
        #print("exitLines")
        pass


    # Enter a parse tree produced by CalcParser#equation.
    def enterEquation(self, ctx:CalcParser.EquationContext):
        pass

    # Exit a parse tree produced by CalcParser#equation.
    def exitEquation(self, ctx:CalcParser.EquationContext):
        print("***exitEquation")
        print(ctx.getText())
        if(len(self.s)>0):
            print(self.s.pop())
        pass


    # Enter a parse tree produced by CalcParser#myMul.
    def enterMyMul(self, ctx:CalcParser.MyMulContext):
        pass

    # Exit a parse tree produced by CalcParser#myMul.
    def exitMyMul(self, ctx:CalcParser.MyMulContext):
        #print("exitMyMul")
        #print(ctx.getText())
        a=self.s.pop()
        b=self.s.pop()
        self.s.append(a*b)
        pass

    # Enter a parse tree produced by CalcParser#myNum.
    def enterMyNum(self, ctx:CalcParser.MyNumContext):
        pass

    # Exit a parse tree produced by CalcParser#myNum.
    def exitMyNum(self, ctx:CalcParser.MyNumContext):
        #print("exitMyNum")
        #print(ctx.getText())
        self.s.append(int(ctx.getText()))
        pass


    # Enter a parse tree produced by CalcParser#myMinusNum.
    def enterMyMinusNum(self, ctx:CalcParser.MyMinusNumContext):
        pass

    # Exit a parse tree produced by CalcParser#myMinusNum.
    def exitMyMinusNum(self, ctx:CalcParser.MyMinusNumContext):
        #print("exitMyMinusNum")
        #print(ctx.getText())
        self.s.append(int(ctx.getText()))
        pass


    # Enter a parse tree produced by CalcParser#myMinus.
    def enterMyMinus(self, ctx:CalcParser.MyMinusContext):
        pass

    # Exit a parse tree produced by CalcParser#myMinus.
    def exitMyMinus(self, ctx:CalcParser.MyMinusContext):
        #print("exitMyMinus")
        #print(ctx.getText())
        a=self.s.pop()
        self.s.append(-a)
        pass


    # Enter a parse tree produced by CalcParser#mySub.
    def enterMySub(self, ctx:CalcParser.MySubContext):
        pass

    # Exit a parse tree produced by CalcParser#mySub.
    def exitMySub(self, ctx:CalcParser.MySubContext):
        #print("exitMySub")
        #print(ctx.getText())
        a=self.s.pop()
        b=self.s.pop()
        self.s.append(b-a)
        pass


    # Enter a parse tree produced by CalcParser#myDiv.
    def enterMyDiv(self, ctx:CalcParser.MyDivContext):
        pass

    # Exit a parse tree produced by CalcParser#myDiv.
    def exitMyDiv(self, ctx:CalcParser.MyDivContext):
        a=self.s.pop()
        b=self.s.pop()
        self.s.append(b/a)
        pass


    # Enter a parse tree produced by CalcParser#myAdd.
    def enterMyAdd(self, ctx:CalcParser.MyAddContext):
        pass

    # Exit a parse tree produced by CalcParser#myAdd.
    def exitMyAdd(self, ctx:CalcParser.MyAddContext):
        #print("exitMyAdd")
        #print(ctx.getText())
        a=self.s.pop()
        b=self.s.pop()
        self.s.append(a+b)
        pass


    # Enter a parse tree produced by CalcParser#myBr.
    def enterMyBr(self, ctx:CalcParser.MyBrContext):
        pass

    # Exit a parse tree produced by CalcParser#myBr.
    def exitMyBr(self, ctx:CalcParser.MyBrContext):
        pass



del CalcParser

python main.py "(1+3)*4;"

python main.py "(1+3)*4;5*4;8*3;-1+2*3;1+1;5-3;5/3;-6/3;-(1+3)*5+3;(1+3)/2;-4/(1+1)"

antlr4 MyLangParser.g4 MyLangLexer.g4 
javac MyLang*java
grun MyLang lines -gui

antlr4 MyLangParser.g4 MyLangLexer.g4 
javac MyLang*java
grun MyLang lines -gui

lexer grammar MyLangLexer;

N     : [0-9]
      | [1-9][0-9]+;
ADD   : '+'; 
SUB   : '-'; 
MUL   : '*'; 
DIV   : '/'; 
SB    : '=';
LBR   : '(';
RBR   : ')';
PRINT : 'print';
// VARIABLE : [A-Z]~[=; "'.+\-*/()\t\r\n]*;
VARIABLE : [a-zA-Z_][a-zA-Z0-9_]*;
EL : [;];          // semicolons
BLOCK_COMMENT
	: '/*' .*? '*/' -> channel(HIDDEN)
	;
LINE_COMMENT
	: '//' ~[\r\n]* -> channel(HIDDEN)
	;
WS : [ \t\r\n]+ -> skip ; // skip spaces, tabs, newlines

// String
LQUOTE : '"' -> more, mode(STR) ;
mode STR;
STRING : '"' -> mode(DEFAULT_MODE) ; // token we want parser to see
TEXT : . -> more ; // collect more text for string

antlr4 MyLangParser.g4 MyLangLexer.g4 
javac MyLang*java
grun MyLang lines -gui

python main.py "print (1+3)*4+5*3;print -(1-5)*3;print 4/2;"

31
12
2.0

# Generated from MyLangParser.g4 by ANTLR 4.9.1
from antlr4 import *
from collections import deque
if __name__ is not None and "." in __name__:
	from .MyLangParser import MyLangParser
else:
	from MyLangParser import MyLangParser

# This class defines a complete listener for a parse tree produced by MyLangParser.
class MyLangParserListener(ParseTreeListener):
	s = deque([])
	vdic = {}

	# Enter a parse tree produced by MyLangParser#lines.
	def enterLines(self, ctx:MyLangParser.LinesContext):
	    pass

	# Exit a parse tree produced by MyLangParser#lines.
	def exitLines(self, ctx:MyLangParser.LinesContext):
	    pass


	# Enter a parse tree produced by MyLangParser#mySubstitutionExpr.
	def enterMySubstitutionExpr(self, ctx:MyLangParser.MySubstitutionExprContext):
	    pass

	# Exit a parse tree produced by MyLangParser#mySubstitutionExpr.
	def exitMySubstitutionExpr(self, ctx:MyLangParser.MySubstitutionExprContext):
	    #print("exitMySubstitutionExpr")
	    self.vdic[ctx.getChild(0).getText()]=self.s.pop();
	    #print(self.vdic[ctx.getChild(0).getText()])
	    #print(ctx.getText())
	    pass


	# Enter a parse tree produced by MyLangParser#mySubstitutionStr.
	def enterMySubstitutionStr(self, ctx:MyLangParser.MySubstitutionStrContext):
	    pass

	# Exit a parse tree produced by MyLangParser#mySubstitutionStr.
	def exitMySubstitutionStr(self, ctx:MyLangParser.MySubstitutionStrContext):
	    #print("exitMySubstitutionStr")
	    self.vdic[ctx.getChild(0).getText()]=ctx.getChild(2).getText()[1:-1]
	    #print(self.vdic[ctx.getChild(0).getText()])
	    #print(ctx.getText())
	    pass


	# Enter a parse tree produced by MyLangParser#myPrintout.
	def enterMyPrintout(self, ctx:MyLangParser.MyPrintoutContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myPrintout.
	def exitMyPrintout(self, ctx:MyLangParser.MyPrintoutContext):
	    pass


	# Enter a parse tree produced by MyLangParser#myPrintOutExpr.
	def enterMyPrintOutExpr(self, ctx:MyLangParser.MyPrintOutExprContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myPrintOutExpr.
	def exitMyPrintOutExpr(self, ctx:MyLangParser.MyPrintOutExprContext):
	    #print(ctx.getText())
	    if(len(self.s)>0):
	       print(self.s.pop())
	    pass


	# Enter a parse tree produced by MyLangParser#myPrintOutString.
	def enterMyPrintOutString(self, ctx:MyLangParser.MyPrintOutStringContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myPrintOutString.
	def exitMyPrintOutString(self, ctx:MyLangParser.MyPrintOutStringContext):
	    #str=ctx.getText()
	    #print(ctx.getChild(0).getText())
	    #print(ctx.getChild(1).getText())
	    #print(str)
	    #str2=str[6:-2]
	    print(ctx.getChild(1).getText()[1:-1])
	    pass


	# Enter a parse tree produced by MyLangParser#myPrintOutVariable.
	def enterMyPrintOutVariable(self, ctx:MyLangParser.MyPrintOutVariableContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myPrintOutVariable.
	def exitMyPrintOutVariable(self, ctx:MyLangParser.MyPrintOutVariableContext):
	    print(self.vdic[ctx.getChild(1).getText()])
	    pass


	# Enter a parse tree produced by MyLangParser#myMul.
	def enterMyMul(self, ctx:MyLangParser.MyMulContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myMul.
	def exitMyMul(self, ctx:MyLangParser.MyMulContext):
	    a=self.s.pop()
	    b=self.s.pop()
	    self.s.append(a*b)
	    pass


	# Enter a parse tree produced by MyLangParser#myNum.
	def enterMyNum(self, ctx:MyLangParser.MyNumContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myNum.
	def exitMyNum(self, ctx:MyLangParser.MyNumContext):
	    self.s.append(int(ctx.getText()))
	    pass


	# Enter a parse tree produced by MyLangParser#myMinusNum.
	def enterMyMinusNum(self, ctx:MyLangParser.MyMinusNumContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myMinusNum.
	def exitMyMinusNum(self, ctx:MyLangParser.MyMinusNumContext):
	    self.s.append(int(ctx.getText()))
	    pass


	# Enter a parse tree produced by MyLangParser#myMinus.
	def enterMyMinus(self, ctx:MyLangParser.MyMinusContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myMinus.
	def exitMyMinus(self, ctx:MyLangParser.MyMinusContext):
	    a=self.s.pop()
	    self.s.append(-a)
	    pass


	# Enter a parse tree produced by MyLangParser#myMinusVal.
	def enterMyMinusVal(self, ctx:MyLangParser.MyMinusValContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myMinusVal.
	def exitMyMinusVal(self, ctx:MyLangParser.MyMinusValContext):
	    #print("exitMyMinusVal")
	    #print(ctx.getChild(1).getText())
	    self.s.append(-self.vdic[ctx.getChild(1).getText()])
	    pass


	# Enter a parse tree produced by MyLangParser#mySub.
	def enterMySub(self, ctx:MyLangParser.MySubContext):
	    pass

	# Exit a parse tree produced by MyLangParser#mySub.
	def exitMySub(self, ctx:MyLangParser.MySubContext):
	    a=self.s.pop()
	    b=self.s.pop()
	    self.s.append(b-a)
	    pass


	# Enter a parse tree produced by MyLangParser#myVal.
	def enterMyVal(self, ctx:MyLangParser.MyValContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myVal.
	def exitMyVal(self, ctx:MyLangParser.MyValContext):
	    self.s.append(self.vdic[ctx.getText()])
	    pass


	# Enter a parse tree produced by MyLangParser#myDiv.
	def enterMyDiv(self, ctx:MyLangParser.MyDivContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myDiv.
	def exitMyDiv(self, ctx:MyLangParser.MyDivContext):
	    a=self.s.pop()
	    b=self.s.pop()
	    self.s.append(b/a)
	    pass


	# Enter a parse tree produced by MyLangParser#myAdd.
	def enterMyAdd(self, ctx:MyLangParser.MyAddContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myAdd.
	def exitMyAdd(self, ctx:MyLangParser.MyAddContext):
	    a=self.s.pop()
	    b=self.s.pop()
	    self.s.append(a+b)
	    pass


	# Enter a parse tree produced by MyLangParser#myBr.
	def enterMyBr(self, ctx:MyLangParser.MyBrContext):
	    pass

	# Exit a parse tree produced by MyLangParser#myBr.
	def exitMyBr(self, ctx:MyLangParser.MyBrContext):
	    pass



del MyLangParser

python main.py "print 1+1;print \"hello\";X=\"sss\";print X;Y=-(5-1)*5;print Y;Z=5*Y;print -Z;print Z;"

2
hello
sss
-20
100
-100

import ipdb
import sys
from antlr4 import *
from MyLangLexer import MyLangLexer
from MyLangParser import MyLangParser
from MyLangParserListener import MyLangParserListener

class KeyPrinter(MyLangParserListener):
	def exitKey(self, ctx):
		pass

def main(argv):
	with open(argv[1]) as f:
	  input = InputStream(f.read())
	  lexer = MyLangLexer(input)
	  stream = CommonTokenStream(lexer)
	  parser = MyLangParser(stream)
	  tree = parser.lines()
	  #print(tree.getChild(0))
	  #print(tree.getChild(0).getText())
	  ##print(tree.getChild(0).toStringTree())
	  #ipdb.set_trace()
	  printer = KeyPrinter()
	  walker = ParseTreeWalker()
	  walker.walk(printer, tree)

if __name__ == '__main__':
	main(sys.argv)

/* 
   複数行のコメント
*/  
// 一行のコメント
X=12;
print 3*X;
print -X*5;
S="Hello";
print S;
print "World!";
print -(5-1)*5;
print -(5+1)*5;

python3 main2.py test01.mylang 
or 
python main2.py test01.mylang