forked from NUDT-compiler/nudt-compiler-cpp
1. 修改所有include路径为相对于项目根目录 - frontend/ -> src/frontend/ - ir/ -> include/ir/ - irgen/ -> include/irgen/ - sem/ -> include/sem/ - mir/ -> include/mir/ - utils/ -> include/utils/ 2. 生成ANTLR代码到src/frontend/目录 - 将SysYLexer/Parser等生成文件放在源码目录 - 移除third_party/antlr4-runtime避免重复定义 3. 添加build.sh和Makefile支持直接编译 4. 修复main.cpp的PassManager调用zhm
parent
fa028a3c67
commit
ac4be4ec7a
@ -0,0 +1,51 @@
|
||||
# Makefile for SysY Compiler
|
||||
# Competition build script
|
||||
# Usage: make
|
||||
|
||||
CXX = clang++
|
||||
CXXFLAGS = -std=c++17 -O2 -Wall -Wextra
|
||||
LDFLAGS = -lpthread
|
||||
|
||||
# Project root
|
||||
ROOT = $(shell pwd)
|
||||
|
||||
# Include paths
|
||||
INCLUDES = -I$(ROOT)/include \
|
||||
-I$(ROOT)/src \
|
||||
-I$(ROOT)/third_party/antlr4-runtime-4.13.2/runtime/src \
|
||||
-I$(ROOT)/build/generated/antlr4/src/antlr4
|
||||
|
||||
# Source files
|
||||
SRCDIR = $(ROOT)/src
|
||||
ANTLR_RUNTIME = $(ROOT)/third_party/antlr4-runtime-4.13.2/runtime/src
|
||||
GENERATED = $(ROOT)/build/generated/antlr4/src/antlr4
|
||||
|
||||
SRC = $(shell find $(SRCDIR) -name '*.cpp' 2>/dev/null)
|
||||
ANTLR_SRC = $(shell find $(ANTLR_RUNTIME) -name '*.cpp' 2>/dev/null)
|
||||
GEN_SRC = $(shell find $(GENERATED) -name '*.cpp' 2>/dev/null || echo "")
|
||||
|
||||
# Target
|
||||
TARGET = $(ROOT)/compiler
|
||||
|
||||
.PHONY: all clean generate
|
||||
|
||||
all: generate $(TARGET)
|
||||
|
||||
generate:
|
||||
@mkdir -p $(ROOT)/build/generated/antlr4
|
||||
@if [ ! -f "$(GENERATED)/SysYParser.h" ]; then \
|
||||
echo "[ANTLR4] Generating parser..."; \
|
||||
java -jar $(ROOT)/third_party/antlr-4.13.2-complete.jar \
|
||||
-Dlanguage=Cpp -visitor \
|
||||
-o $(ROOT)/build/generated/antlr4 \
|
||||
$(ROOT)/src/frontend/SysY.g4; \
|
||||
fi
|
||||
|
||||
$(TARGET): $(SRC) $(ANTLR_SRC) $(GEN_SRC)
|
||||
@echo "[CXX] Linking $(TARGET)..."
|
||||
$(CXX) $(CXXFLAGS) $(INCLUDES) \
|
||||
$(SRC) $(ANTLR_SRC) $(GEN_SRC) \
|
||||
$(LDFLAGS) -o $@
|
||||
|
||||
clean:
|
||||
rm -rf build $(TARGET)
|
||||
@ -0,0 +1,116 @@
|
||||
#!/usr/bin/env bash
|
||||
# ============================================================================
|
||||
# SysY Compiler - Competition Build Script
|
||||
# ============================================================================
|
||||
# This script compiles the SysY compiler for the 2026 Compiler Design Competition.
|
||||
# Usage:
|
||||
# ./build.sh - Build the compiler
|
||||
# ./build.sh clean - Clean build artifacts
|
||||
# ============================================================================
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
PROJ_DIR="$(cd "$(dirname "$0")" && pwd)"
|
||||
BUILD_DIR="${PROJ_DIR}/build"
|
||||
BIN_DIR="${BUILD_DIR}/bin"
|
||||
ANTLR4_GENERATED="${BUILD_DIR}/generated/antlr4/src/antlr4"
|
||||
|
||||
# Compiler settings
|
||||
CXX="${CXX:-clang++}"
|
||||
CXXSTD="-std=c++17"
|
||||
CXXFLAGS="${CXXFLAGS:--O2 -Wall -Wextra -Wpedantic}"
|
||||
LDFLAGS="-lpthread"
|
||||
|
||||
# Include paths (all relative to project root)
|
||||
INCLUDES=(
|
||||
"-I${PROJ_DIR}/include"
|
||||
"-I${PROJ_DIR}/src"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/atn"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/dfa"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/internal"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/misc"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/support"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/tree"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/tree/pattern"
|
||||
"-I${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src/tree/xpath"
|
||||
"-I${ANTLR4_GENERATED}"
|
||||
)
|
||||
|
||||
# ============================================================================
|
||||
# Functions
|
||||
# ============================================================================
|
||||
|
||||
generate_antlr() {
|
||||
echo "[ANTLR4] Generating parser code..."
|
||||
mkdir -p "${ANTLR4_GENERATED}"
|
||||
|
||||
if [ ! -f "${ANTLR4_GENERATED}/SysYParser.h" ]; then
|
||||
java -jar "${PROJ_DIR}/third_party/antlr-4.13.2-complete.jar" \
|
||||
-Dlanguage=Cpp \
|
||||
-o "${BUILD_DIR}/generated/antlr4" \
|
||||
-visitor \
|
||||
"${PROJ_DIR}/src/frontend/SysY.g4" 2>/dev/null || {
|
||||
echo "Warning: ANTLR4 generation failed, checking for existing files..."
|
||||
if [ ! -f "${ANTLR4_GENERATED}/SysYParser.h" ]; then
|
||||
echo "Error: No generated parser code found."
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
else
|
||||
echo "[ANTLR4] Parser code already exists, skipping."
|
||||
fi
|
||||
}
|
||||
|
||||
build() {
|
||||
echo "[CXX] Compiling compiler..."
|
||||
mkdir -p "${BIN_DIR}"
|
||||
|
||||
# Collect source files
|
||||
SRC_FILES=()
|
||||
while IFS= read -r -d '' file; do
|
||||
SRC_FILES+=("$file")
|
||||
done < <(find "${PROJ_DIR}/src" -name '*.cpp' -print0)
|
||||
|
||||
ANTLR_RUNTIME_FILES=()
|
||||
while IFS= read -r -d '' file; do
|
||||
ANTLR_RUNTIME_FILES+=("$file")
|
||||
done < <(find "${PROJ_DIR}/third_party/antlr4-runtime-4.13.2/runtime/src" -name '*.cpp' -print0)
|
||||
|
||||
GENERATED_FILES=()
|
||||
if [ -d "${ANTLR4_GENERATED}" ]; then
|
||||
while IFS= read -r -d '' file; do
|
||||
GENERATED_FILES+=("$file")
|
||||
done < <(find "${ANTLR4_GENERATED}" -name '*.cpp' -print0 2>/dev/null || true)
|
||||
fi
|
||||
|
||||
# Compile
|
||||
"${CXX}" ${CXXSTD} ${CXXFLAGS} \
|
||||
"${INCLUDES[@]}" \
|
||||
"${SRC_FILES[@]}" \
|
||||
"${ANTLR_RUNTIME_FILES[@]}" \
|
||||
"${GENERATED_FILES[@]}" \
|
||||
${LDFLAGS} \
|
||||
-o "${BIN_DIR}/compiler"
|
||||
|
||||
echo "[INFO] Build successful: ${BIN_DIR}/compiler"
|
||||
}
|
||||
|
||||
clean() {
|
||||
echo "[CLEAN] Removing build directory..."
|
||||
rm -rf "${BUILD_DIR}"
|
||||
}
|
||||
|
||||
# ============================================================================
|
||||
# Main
|
||||
# ============================================================================
|
||||
|
||||
case "${1:-}" in
|
||||
clean)
|
||||
clean
|
||||
;;
|
||||
*)
|
||||
generate_antlr
|
||||
build
|
||||
;;
|
||||
esac
|
||||
@ -0,0 +1,47 @@
|
||||
#!/bin/bash
|
||||
# fix_includes.sh - 修改所有include路径为相对于项目根目录
|
||||
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")"
|
||||
|
||||
echo "Fixing include paths in all source files..."
|
||||
|
||||
# 处理 src/ 下所有层级的文件
|
||||
for dir in src src/frontend src/ir src/ir/passes src/ir/analysis src/irgen src/sem src/mir src/mir/passes src/utils; do
|
||||
[[ ! -d "$dir" ]] && continue
|
||||
|
||||
# 计算相对前缀
|
||||
case "$dir" in
|
||||
src) prefix="." ;;
|
||||
src/frontend|src/utils) prefix=".." ;;
|
||||
src/ir|src/irgen|src/sem|src/mir) prefix="../.." ;;
|
||||
src/ir/passes|src/ir/analysis|src/mir/passes) prefix="../../.." ;;
|
||||
*) continue ;;
|
||||
esac
|
||||
|
||||
find "$dir" -maxdepth 1 -name '*.cpp' -o -name '*.h' | while read -r f; do
|
||||
[ "$f" = "src/main.cpp" ] && continue
|
||||
|
||||
# 修改 include 路径
|
||||
sed -i "s|#include \"ir/|#include \"${prefix}/include/ir/|g" "$f"
|
||||
sed -i "s|#include \"irgen/|#include \"${prefix}/include/irgen/|g" "$f"
|
||||
sed -i "s|#include \"sem/|#include \"${prefix}/include/sem/|g" "$f"
|
||||
sed -i "s|#include \"mir/|#include \"${prefix}/include/mir/|g" "$f"
|
||||
sed -i "s|#include \"utils/|#include \"${prefix}/include/utils/|g" "$f"
|
||||
sed -i "s|#include \"frontend/|#include \"${prefix}/src/frontend/|g" "$f"
|
||||
|
||||
echo " Fixed: $f"
|
||||
done
|
||||
done
|
||||
|
||||
# 处理 include/ 下的文件
|
||||
for dir in include include/ir include/irgen include/sem include/mir include/utils; do
|
||||
[[ ! -d "$dir" ]] && continue
|
||||
find "$dir" -maxdepth 1 -name '*.h' | while read -r f; do
|
||||
sed -i "s|#include \"ir/|#include \"ir/|g" "$f" # include下的不用改
|
||||
sed -i "s|#include \"frontend/|#include \"../src/frontend/|g" "$f"
|
||||
echo " Fixed: $f"
|
||||
done
|
||||
done
|
||||
|
||||
echo "Done!"
|
||||
@ -1,228 +0,0 @@
|
||||
// SysY 子集语法：支持形如
|
||||
// int main() { int a = 1; int b = 2; return a + b; }
|
||||
// 的最小返回表达式编译。
|
||||
|
||||
// 后续需要自行添加
|
||||
grammar SysY;
|
||||
|
||||
compUnit
|
||||
: (funcDef|decl)+ EOF
|
||||
;
|
||||
|
||||
funcDef
|
||||
: funcType Ident L_PAREN (funcFParams)? R_PAREN block
|
||||
;
|
||||
|
||||
funcType
|
||||
: Void | Int | Float
|
||||
;
|
||||
|
||||
funcFParams
|
||||
: funcFParam (Comma funcFParam)*
|
||||
;
|
||||
|
||||
funcFParam
|
||||
: bType Ident (L_BRACKET R_BRACKET (L_BRACKET exp R_BRACKET)*)?
|
||||
;
|
||||
|
||||
block
|
||||
: L_BRACE (blockItem)* R_BRACE
|
||||
;
|
||||
|
||||
blockItem
|
||||
: decl
|
||||
| stmt
|
||||
;
|
||||
|
||||
decl
|
||||
: varDecl | constDecl
|
||||
;
|
||||
|
||||
constDecl
|
||||
: Const bType constDef (Comma constDef)* Semi
|
||||
;
|
||||
|
||||
bType
|
||||
: Int | Float
|
||||
;
|
||||
|
||||
constDef
|
||||
: Ident (L_BRACKET constExp R_BRACKET)* Assign constInitVal
|
||||
;
|
||||
|
||||
constInitVal
|
||||
: constExp
|
||||
| L_BRACE ( constInitVal (Comma constInitVal)* )? R_BRACE
|
||||
;
|
||||
|
||||
stmt
|
||||
: lVal Assign exp Semi
|
||||
| (exp)? Semi
|
||||
| block
|
||||
| If L_PAREN cond R_PAREN stmt ( Else stmt )?
|
||||
| While L_PAREN cond R_PAREN stmt
|
||||
| Break Semi
|
||||
| Continue Semi
|
||||
| Return (exp)? Semi
|
||||
;
|
||||
|
||||
cond
|
||||
: lOrExp
|
||||
;
|
||||
|
||||
lVal
|
||||
: Ident (L_BRACKET exp R_BRACKET)*
|
||||
;
|
||||
|
||||
primaryExp
|
||||
: L_PAREN exp R_PAREN | lVal | number
|
||||
;
|
||||
|
||||
number
|
||||
: IntConst | FloatConst
|
||||
;
|
||||
|
||||
unaryExp
|
||||
: primaryExp
|
||||
| Ident L_PAREN (funcRParams)? R_PAREN
|
||||
| unaryOp unaryExp
|
||||
;
|
||||
|
||||
unaryOp
|
||||
: AddOp | SubOp | NotOp
|
||||
;
|
||||
|
||||
funcRParams
|
||||
: exp (Comma exp)*
|
||||
;
|
||||
|
||||
mulExp
|
||||
: unaryExp | mulExp (MulOp | DivOp | ModOp) unaryExp
|
||||
;
|
||||
|
||||
addExp
|
||||
: mulExp | addExp (AddOp | SubOp) mulExp
|
||||
;
|
||||
|
||||
relExp
|
||||
: addExp | relExp (LtOp | GtOp | LeOp | GeOp) addExp
|
||||
;
|
||||
|
||||
eqExp
|
||||
: relExp | eqExp (EqOp | NeOp) relExp
|
||||
;
|
||||
|
||||
lAndExp
|
||||
: eqExp | lAndExp AndOp eqExp
|
||||
;
|
||||
|
||||
lOrExp
|
||||
: lAndExp | lOrExp OrOp lAndExp
|
||||
;
|
||||
|
||||
constExp
|
||||
: addExp
|
||||
;
|
||||
|
||||
varDecl
|
||||
: bType varDef (Comma varDef)* Semi
|
||||
;
|
||||
|
||||
varDef
|
||||
: Ident (L_BRACKET constExp R_BRACKET)*
|
||||
| Ident (L_BRACKET constExp R_BRACKET)* Assign initVal
|
||||
;
|
||||
|
||||
initVal
|
||||
: exp | L_BRACE ( initVal (Comma initVal)* )? R_BRACE
|
||||
;
|
||||
|
||||
exp
|
||||
: addExp
|
||||
;
|
||||
|
||||
// 关键字
|
||||
Void : 'void';
|
||||
Int : 'int';
|
||||
Float : 'float';
|
||||
Const : 'const';
|
||||
If : 'if';
|
||||
Else : 'else';
|
||||
While : 'while';
|
||||
Break : 'break';
|
||||
Continue : 'continue';
|
||||
Return : 'return';
|
||||
|
||||
// 符号
|
||||
AddOp : '+';
|
||||
SubOp : '-';
|
||||
Assign : '=';
|
||||
MulOp : '*';
|
||||
DivOp : '/';
|
||||
ModOp : '%';
|
||||
NotOp : '!';
|
||||
AndOp : '&&';
|
||||
OrOp : '||';
|
||||
EqOp : '==';
|
||||
NeOp : '!=';
|
||||
LtOp : '<';
|
||||
GtOp : '>';
|
||||
LeOp : '<=';
|
||||
GeOp : '>=';
|
||||
Semi : ';';
|
||||
Comma : ',';
|
||||
L_PAREN : '(';
|
||||
R_PAREN : ')';
|
||||
L_BRACE : '{';
|
||||
R_BRACE : '}';
|
||||
L_BRACKET: '[';
|
||||
R_BRACKET: ']';
|
||||
|
||||
Ident
|
||||
: [a-zA-Z_][a-zA-Z_0-9]*
|
||||
;
|
||||
|
||||
IntConst
|
||||
: '0' [xX] [0-9a-fA-F]+
|
||||
| '0' [0-7]*
|
||||
| [1-9] [0-9]*
|
||||
;
|
||||
|
||||
FloatConst
|
||||
: DecFloatConst
|
||||
| HexFloatConst
|
||||
;
|
||||
fragment DecFloatConst
|
||||
: DecFrac DecExp?
|
||||
| [0-9]+ DecExp
|
||||
;
|
||||
fragment DecFrac
|
||||
: [0-9]+ '.' [0-9]*
|
||||
| '.' [0-9]+
|
||||
;
|
||||
fragment DecExp
|
||||
: [eE] [+\-]? [0-9]+
|
||||
;
|
||||
fragment HexFloatConst
|
||||
: '0' [xX] HexFrac BinExp
|
||||
| '0' [xX] [0-9a-fA-F]+ BinExp
|
||||
;
|
||||
fragment HexFrac
|
||||
: [0-9a-fA-F]+ '.' [0-9a-fA-F]*
|
||||
| '.' [0-9a-fA-F]+
|
||||
;
|
||||
fragment BinExp
|
||||
: [pP] [+\-]? [0-9]+
|
||||
;
|
||||
|
||||
WS
|
||||
: [ \t\r\n]+ -> skip
|
||||
;
|
||||
|
||||
COMMENT
|
||||
: '//' ~[\r\n]* -> skip
|
||||
;
|
||||
|
||||
BLOCK_COMMENT
|
||||
: '/*' .*? '*/' -> skip
|
||||
;
|
||||
@ -0,0 +1,7 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "SysYBaseListener.h"
|
||||
|
||||
|
||||
@ -0,0 +1,119 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "antlr4-runtime.h"
|
||||
#include "SysYListener.h"
|
||||
|
||||
|
||||
/**
|
||||
* This class provides an empty implementation of SysYListener,
|
||||
* which can be extended to create a listener which only needs to handle a subset
|
||||
* of the available methods.
|
||||
*/
|
||||
class SysYBaseListener : public SysYListener {
|
||||
public:
|
||||
|
||||
virtual void enterCompUnit(SysYParser::CompUnitContext * /*ctx*/) override { }
|
||||
virtual void exitCompUnit(SysYParser::CompUnitContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterFuncDef(SysYParser::FuncDefContext * /*ctx*/) override { }
|
||||
virtual void exitFuncDef(SysYParser::FuncDefContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterFuncType(SysYParser::FuncTypeContext * /*ctx*/) override { }
|
||||
virtual void exitFuncType(SysYParser::FuncTypeContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterFuncFParams(SysYParser::FuncFParamsContext * /*ctx*/) override { }
|
||||
virtual void exitFuncFParams(SysYParser::FuncFParamsContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterFuncFParam(SysYParser::FuncFParamContext * /*ctx*/) override { }
|
||||
virtual void exitFuncFParam(SysYParser::FuncFParamContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterBlock(SysYParser::BlockContext * /*ctx*/) override { }
|
||||
virtual void exitBlock(SysYParser::BlockContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterBlockItem(SysYParser::BlockItemContext * /*ctx*/) override { }
|
||||
virtual void exitBlockItem(SysYParser::BlockItemContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterDecl(SysYParser::DeclContext * /*ctx*/) override { }
|
||||
virtual void exitDecl(SysYParser::DeclContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterConstDecl(SysYParser::ConstDeclContext * /*ctx*/) override { }
|
||||
virtual void exitConstDecl(SysYParser::ConstDeclContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterBType(SysYParser::BTypeContext * /*ctx*/) override { }
|
||||
virtual void exitBType(SysYParser::BTypeContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterConstDef(SysYParser::ConstDefContext * /*ctx*/) override { }
|
||||
virtual void exitConstDef(SysYParser::ConstDefContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterConstInitVal(SysYParser::ConstInitValContext * /*ctx*/) override { }
|
||||
virtual void exitConstInitVal(SysYParser::ConstInitValContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterStmt(SysYParser::StmtContext * /*ctx*/) override { }
|
||||
virtual void exitStmt(SysYParser::StmtContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterCond(SysYParser::CondContext * /*ctx*/) override { }
|
||||
virtual void exitCond(SysYParser::CondContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterLVal(SysYParser::LValContext * /*ctx*/) override { }
|
||||
virtual void exitLVal(SysYParser::LValContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterPrimaryExp(SysYParser::PrimaryExpContext * /*ctx*/) override { }
|
||||
virtual void exitPrimaryExp(SysYParser::PrimaryExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterNumber(SysYParser::NumberContext * /*ctx*/) override { }
|
||||
virtual void exitNumber(SysYParser::NumberContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterUnaryExp(SysYParser::UnaryExpContext * /*ctx*/) override { }
|
||||
virtual void exitUnaryExp(SysYParser::UnaryExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterUnaryOp(SysYParser::UnaryOpContext * /*ctx*/) override { }
|
||||
virtual void exitUnaryOp(SysYParser::UnaryOpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterFuncRParams(SysYParser::FuncRParamsContext * /*ctx*/) override { }
|
||||
virtual void exitFuncRParams(SysYParser::FuncRParamsContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterMulExp(SysYParser::MulExpContext * /*ctx*/) override { }
|
||||
virtual void exitMulExp(SysYParser::MulExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterAddExp(SysYParser::AddExpContext * /*ctx*/) override { }
|
||||
virtual void exitAddExp(SysYParser::AddExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterRelExp(SysYParser::RelExpContext * /*ctx*/) override { }
|
||||
virtual void exitRelExp(SysYParser::RelExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterEqExp(SysYParser::EqExpContext * /*ctx*/) override { }
|
||||
virtual void exitEqExp(SysYParser::EqExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterLAndExp(SysYParser::LAndExpContext * /*ctx*/) override { }
|
||||
virtual void exitLAndExp(SysYParser::LAndExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterLOrExp(SysYParser::LOrExpContext * /*ctx*/) override { }
|
||||
virtual void exitLOrExp(SysYParser::LOrExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterConstExp(SysYParser::ConstExpContext * /*ctx*/) override { }
|
||||
virtual void exitConstExp(SysYParser::ConstExpContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterVarDecl(SysYParser::VarDeclContext * /*ctx*/) override { }
|
||||
virtual void exitVarDecl(SysYParser::VarDeclContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterVarDef(SysYParser::VarDefContext * /*ctx*/) override { }
|
||||
virtual void exitVarDef(SysYParser::VarDefContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterInitVal(SysYParser::InitValContext * /*ctx*/) override { }
|
||||
virtual void exitInitVal(SysYParser::InitValContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterExp(SysYParser::ExpContext * /*ctx*/) override { }
|
||||
virtual void exitExp(SysYParser::ExpContext * /*ctx*/) override { }
|
||||
|
||||
|
||||
virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
|
||||
virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
|
||||
virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { }
|
||||
virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { }
|
||||
|
||||
};
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "SysYBaseVisitor.h"
|
||||
|
||||
|
||||
@ -0,0 +1,144 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "antlr4-runtime.h"
|
||||
#include "SysYVisitor.h"
|
||||
|
||||
|
||||
/**
|
||||
* This class provides an empty implementation of SysYVisitor, which can be
|
||||
* extended to create a visitor which only needs to handle a subset of the available methods.
|
||||
*/
|
||||
class SysYBaseVisitor : public SysYVisitor {
|
||||
public:
|
||||
|
||||
virtual std::any visitCompUnit(SysYParser::CompUnitContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitFuncDef(SysYParser::FuncDefContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitFuncType(SysYParser::FuncTypeContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitBlock(SysYParser::BlockContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitBlockItem(SysYParser::BlockItemContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitDecl(SysYParser::DeclContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitConstDecl(SysYParser::ConstDeclContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitBType(SysYParser::BTypeContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitConstDef(SysYParser::ConstDefContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitConstInitVal(SysYParser::ConstInitValContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitStmt(SysYParser::StmtContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitCond(SysYParser::CondContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitLVal(SysYParser::LValContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitNumber(SysYParser::NumberContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitMulExp(SysYParser::MulExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitAddExp(SysYParser::AddExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitRelExp(SysYParser::RelExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitEqExp(SysYParser::EqExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitLAndExp(SysYParser::LAndExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitLOrExp(SysYParser::LOrExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitConstExp(SysYParser::ConstExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitVarDecl(SysYParser::VarDeclContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitVarDef(SysYParser::VarDefContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitInitVal(SysYParser::InitValContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual std::any visitExp(SysYParser::ExpContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
@ -0,0 +1,271 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "SysYLexer.h"
|
||||
|
||||
|
||||
using namespace antlr4;
|
||||
|
||||
|
||||
|
||||
using namespace antlr4;
|
||||
|
||||
namespace {
|
||||
|
||||
struct SysYLexerStaticData final {
|
||||
SysYLexerStaticData(std::vector<std::string> ruleNames,
|
||||
std::vector<std::string> channelNames,
|
||||
std::vector<std::string> modeNames,
|
||||
std::vector<std::string> literalNames,
|
||||
std::vector<std::string> symbolicNames)
|
||||
: ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)),
|
||||
modeNames(std::move(modeNames)), literalNames(std::move(literalNames)),
|
||||
symbolicNames(std::move(symbolicNames)),
|
||||
vocabulary(this->literalNames, this->symbolicNames) {}
|
||||
|
||||
SysYLexerStaticData(const SysYLexerStaticData&) = delete;
|
||||
SysYLexerStaticData(SysYLexerStaticData&&) = delete;
|
||||
SysYLexerStaticData& operator=(const SysYLexerStaticData&) = delete;
|
||||
SysYLexerStaticData& operator=(SysYLexerStaticData&&) = delete;
|
||||
|
||||
std::vector<antlr4::dfa::DFA> decisionToDFA;
|
||||
antlr4::atn::PredictionContextCache sharedContextCache;
|
||||
const std::vector<std::string> ruleNames;
|
||||
const std::vector<std::string> channelNames;
|
||||
const std::vector<std::string> modeNames;
|
||||
const std::vector<std::string> literalNames;
|
||||
const std::vector<std::string> symbolicNames;
|
||||
const antlr4::dfa::Vocabulary vocabulary;
|
||||
antlr4::atn::SerializedATNView serializedATN;
|
||||
std::unique_ptr<antlr4::atn::ATN> atn;
|
||||
};
|
||||
|
||||
::antlr4::internal::OnceFlag sysylexerLexerOnceFlag;
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
static thread_local
|
||||
#endif
|
||||
std::unique_ptr<SysYLexerStaticData> sysylexerLexerStaticData = nullptr;
|
||||
|
||||
void sysylexerLexerInitialize() {
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
if (sysylexerLexerStaticData != nullptr) {
|
||||
return;
|
||||
}
|
||||
#else
|
||||
assert(sysylexerLexerStaticData == nullptr);
|
||||
#endif
|
||||
auto staticData = std::make_unique<SysYLexerStaticData>(
|
||||
std::vector<std::string>{
|
||||
"Void", "Int", "Float", "Const", "If", "Else", "While", "Break", "Continue",
|
||||
"Return", "AddOp", "SubOp", "Assign", "MulOp", "DivOp", "ModOp", "NotOp",
|
||||
"AndOp", "OrOp", "EqOp", "NeOp", "LtOp", "GtOp", "LeOp", "GeOp", "Semi",
|
||||
"Comma", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACKET",
|
||||
"R_BRACKET", "Ident", "IntConst", "FloatConst", "DecFloatConst", "DecFrac",
|
||||
"DecExp", "HexFloatConst", "HexFrac", "BinExp", "WS", "COMMENT", "BLOCK_COMMENT"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"DEFAULT_MODE"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"", "'void'", "'int'", "'float'", "'const'", "'if'", "'else'", "'while'",
|
||||
"'break'", "'continue'", "'return'", "'+'", "'-'", "'='", "'*'", "'/'",
|
||||
"'%'", "'!'", "'&&'", "'||'", "'=='", "'!='", "'<'", "'>'", "'<='",
|
||||
"'>='", "';'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"", "Void", "Int", "Float", "Const", "If", "Else", "While", "Break",
|
||||
"Continue", "Return", "AddOp", "SubOp", "Assign", "MulOp", "DivOp",
|
||||
"ModOp", "NotOp", "AndOp", "OrOp", "EqOp", "NeOp", "LtOp", "GtOp",
|
||||
"LeOp", "GeOp", "Semi", "Comma", "L_PAREN", "R_PAREN", "L_BRACE",
|
||||
"R_BRACE", "L_BRACKET", "R_BRACKET", "Ident", "IntConst", "FloatConst",
|
||||
"WS", "COMMENT", "BLOCK_COMMENT"
|
||||
}
|
||||
);
|
||||
static const int32_t serializedATNSegment[] = {
|
||||
4,0,39,351,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
|
||||
6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
|
||||
7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
|
||||
7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
|
||||
7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
|
||||
7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
|
||||
7,42,2,43,7,43,2,44,7,44,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,2,1,2,
|
||||
1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,
|
||||
5,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,
|
||||
1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,11,1,11,1,12,
|
||||
1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,17,1,18,1,18,
|
||||
1,18,1,19,1,19,1,19,1,20,1,20,1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,23,
|
||||
1,24,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,
|
||||
1,30,1,31,1,31,1,32,1,32,1,33,1,33,5,33,203,8,33,10,33,12,33,206,9,33,
|
||||
1,34,1,34,1,34,4,34,211,8,34,11,34,12,34,212,1,34,1,34,5,34,217,8,34,
|
||||
10,34,12,34,220,9,34,1,34,1,34,5,34,224,8,34,10,34,12,34,227,9,34,3,34,
|
||||
229,8,34,1,35,1,35,3,35,233,8,35,1,36,1,36,3,36,237,8,36,1,36,4,36,240,
|
||||
8,36,11,36,12,36,241,1,36,3,36,245,8,36,1,37,4,37,248,8,37,11,37,12,37,
|
||||
249,1,37,1,37,5,37,254,8,37,10,37,12,37,257,9,37,1,37,1,37,4,37,261,8,
|
||||
37,11,37,12,37,262,3,37,265,8,37,1,38,1,38,3,38,269,8,38,1,38,4,38,272,
|
||||
8,38,11,38,12,38,273,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,4,39,284,
|
||||
8,39,11,39,12,39,285,1,39,3,39,289,8,39,1,40,4,40,292,8,40,11,40,12,40,
|
||||
293,1,40,1,40,5,40,298,8,40,10,40,12,40,301,9,40,1,40,1,40,4,40,305,8,
|
||||
40,11,40,12,40,306,3,40,309,8,40,1,41,1,41,3,41,313,8,41,1,41,4,41,316,
|
||||
8,41,11,41,12,41,317,1,42,4,42,321,8,42,11,42,12,42,322,1,42,1,42,1,43,
|
||||
1,43,1,43,1,43,5,43,331,8,43,10,43,12,43,334,9,43,1,43,1,43,1,44,1,44,
|
||||
1,44,1,44,5,44,342,8,44,10,44,12,44,345,9,44,1,44,1,44,1,44,1,44,1,44,
|
||||
1,343,0,45,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,
|
||||
25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,
|
||||
24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,
|
||||
71,36,73,0,75,0,77,0,79,0,81,0,83,0,85,37,87,38,89,39,1,0,12,3,0,65,90,
|
||||
95,95,97,122,4,0,48,57,65,90,95,95,97,122,2,0,88,88,120,120,3,0,48,57,
|
||||
65,70,97,102,1,0,48,55,1,0,49,57,1,0,48,57,2,0,69,69,101,101,2,0,43,43,
|
||||
45,45,2,0,80,80,112,112,3,0,9,10,13,13,32,32,2,0,10,10,13,13,371,0,1,
|
||||
1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,
|
||||
0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,
|
||||
1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,
|
||||
0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,
|
||||
0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,
|
||||
1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,
|
||||
0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,85,1,0,0,0,0,87,1,0,0,0,
|
||||
0,89,1,0,0,0,1,91,1,0,0,0,3,96,1,0,0,0,5,100,1,0,0,0,7,106,1,0,0,0,9,
|
||||
112,1,0,0,0,11,115,1,0,0,0,13,120,1,0,0,0,15,126,1,0,0,0,17,132,1,0,0,
|
||||
0,19,141,1,0,0,0,21,148,1,0,0,0,23,150,1,0,0,0,25,152,1,0,0,0,27,154,
|
||||
1,0,0,0,29,156,1,0,0,0,31,158,1,0,0,0,33,160,1,0,0,0,35,162,1,0,0,0,37,
|
||||
165,1,0,0,0,39,168,1,0,0,0,41,171,1,0,0,0,43,174,1,0,0,0,45,176,1,0,0,
|
||||
0,47,178,1,0,0,0,49,181,1,0,0,0,51,184,1,0,0,0,53,186,1,0,0,0,55,188,
|
||||
1,0,0,0,57,190,1,0,0,0,59,192,1,0,0,0,61,194,1,0,0,0,63,196,1,0,0,0,65,
|
||||
198,1,0,0,0,67,200,1,0,0,0,69,228,1,0,0,0,71,232,1,0,0,0,73,244,1,0,0,
|
||||
0,75,264,1,0,0,0,77,266,1,0,0,0,79,288,1,0,0,0,81,308,1,0,0,0,83,310,
|
||||
1,0,0,0,85,320,1,0,0,0,87,326,1,0,0,0,89,337,1,0,0,0,91,92,5,118,0,0,
|
||||
92,93,5,111,0,0,93,94,5,105,0,0,94,95,5,100,0,0,95,2,1,0,0,0,96,97,5,
|
||||
105,0,0,97,98,5,110,0,0,98,99,5,116,0,0,99,4,1,0,0,0,100,101,5,102,0,
|
||||
0,101,102,5,108,0,0,102,103,5,111,0,0,103,104,5,97,0,0,104,105,5,116,
|
||||
0,0,105,6,1,0,0,0,106,107,5,99,0,0,107,108,5,111,0,0,108,109,5,110,0,
|
||||
0,109,110,5,115,0,0,110,111,5,116,0,0,111,8,1,0,0,0,112,113,5,105,0,0,
|
||||
113,114,5,102,0,0,114,10,1,0,0,0,115,116,5,101,0,0,116,117,5,108,0,0,
|
||||
117,118,5,115,0,0,118,119,5,101,0,0,119,12,1,0,0,0,120,121,5,119,0,0,
|
||||
121,122,5,104,0,0,122,123,5,105,0,0,123,124,5,108,0,0,124,125,5,101,0,
|
||||
0,125,14,1,0,0,0,126,127,5,98,0,0,127,128,5,114,0,0,128,129,5,101,0,0,
|
||||
129,130,5,97,0,0,130,131,5,107,0,0,131,16,1,0,0,0,132,133,5,99,0,0,133,
|
||||
134,5,111,0,0,134,135,5,110,0,0,135,136,5,116,0,0,136,137,5,105,0,0,137,
|
||||
138,5,110,0,0,138,139,5,117,0,0,139,140,5,101,0,0,140,18,1,0,0,0,141,
|
||||
142,5,114,0,0,142,143,5,101,0,0,143,144,5,116,0,0,144,145,5,117,0,0,145,
|
||||
146,5,114,0,0,146,147,5,110,0,0,147,20,1,0,0,0,148,149,5,43,0,0,149,22,
|
||||
1,0,0,0,150,151,5,45,0,0,151,24,1,0,0,0,152,153,5,61,0,0,153,26,1,0,0,
|
||||
0,154,155,5,42,0,0,155,28,1,0,0,0,156,157,5,47,0,0,157,30,1,0,0,0,158,
|
||||
159,5,37,0,0,159,32,1,0,0,0,160,161,5,33,0,0,161,34,1,0,0,0,162,163,5,
|
||||
38,0,0,163,164,5,38,0,0,164,36,1,0,0,0,165,166,5,124,0,0,166,167,5,124,
|
||||
0,0,167,38,1,0,0,0,168,169,5,61,0,0,169,170,5,61,0,0,170,40,1,0,0,0,171,
|
||||
172,5,33,0,0,172,173,5,61,0,0,173,42,1,0,0,0,174,175,5,60,0,0,175,44,
|
||||
1,0,0,0,176,177,5,62,0,0,177,46,1,0,0,0,178,179,5,60,0,0,179,180,5,61,
|
||||
0,0,180,48,1,0,0,0,181,182,5,62,0,0,182,183,5,61,0,0,183,50,1,0,0,0,184,
|
||||
185,5,59,0,0,185,52,1,0,0,0,186,187,5,44,0,0,187,54,1,0,0,0,188,189,5,
|
||||
40,0,0,189,56,1,0,0,0,190,191,5,41,0,0,191,58,1,0,0,0,192,193,5,123,0,
|
||||
0,193,60,1,0,0,0,194,195,5,125,0,0,195,62,1,0,0,0,196,197,5,91,0,0,197,
|
||||
64,1,0,0,0,198,199,5,93,0,0,199,66,1,0,0,0,200,204,7,0,0,0,201,203,7,
|
||||
1,0,0,202,201,1,0,0,0,203,206,1,0,0,0,204,202,1,0,0,0,204,205,1,0,0,0,
|
||||
205,68,1,0,0,0,206,204,1,0,0,0,207,208,5,48,0,0,208,210,7,2,0,0,209,211,
|
||||
7,3,0,0,210,209,1,0,0,0,211,212,1,0,0,0,212,210,1,0,0,0,212,213,1,0,0,
|
||||
0,213,229,1,0,0,0,214,218,5,48,0,0,215,217,7,4,0,0,216,215,1,0,0,0,217,
|
||||
220,1,0,0,0,218,216,1,0,0,0,218,219,1,0,0,0,219,229,1,0,0,0,220,218,1,
|
||||
0,0,0,221,225,7,5,0,0,222,224,7,6,0,0,223,222,1,0,0,0,224,227,1,0,0,0,
|
||||
225,223,1,0,0,0,225,226,1,0,0,0,226,229,1,0,0,0,227,225,1,0,0,0,228,207,
|
||||
1,0,0,0,228,214,1,0,0,0,228,221,1,0,0,0,229,70,1,0,0,0,230,233,3,73,36,
|
||||
0,231,233,3,79,39,0,232,230,1,0,0,0,232,231,1,0,0,0,233,72,1,0,0,0,234,
|
||||
236,3,75,37,0,235,237,3,77,38,0,236,235,1,0,0,0,236,237,1,0,0,0,237,245,
|
||||
1,0,0,0,238,240,7,6,0,0,239,238,1,0,0,0,240,241,1,0,0,0,241,239,1,0,0,
|
||||
0,241,242,1,0,0,0,242,243,1,0,0,0,243,245,3,77,38,0,244,234,1,0,0,0,244,
|
||||
239,1,0,0,0,245,74,1,0,0,0,246,248,7,6,0,0,247,246,1,0,0,0,248,249,1,
|
||||
0,0,0,249,247,1,0,0,0,249,250,1,0,0,0,250,251,1,0,0,0,251,255,5,46,0,
|
||||
0,252,254,7,6,0,0,253,252,1,0,0,0,254,257,1,0,0,0,255,253,1,0,0,0,255,
|
||||
256,1,0,0,0,256,265,1,0,0,0,257,255,1,0,0,0,258,260,5,46,0,0,259,261,
|
||||
7,6,0,0,260,259,1,0,0,0,261,262,1,0,0,0,262,260,1,0,0,0,262,263,1,0,0,
|
||||
0,263,265,1,0,0,0,264,247,1,0,0,0,264,258,1,0,0,0,265,76,1,0,0,0,266,
|
||||
268,7,7,0,0,267,269,7,8,0,0,268,267,1,0,0,0,268,269,1,0,0,0,269,271,1,
|
||||
0,0,0,270,272,7,6,0,0,271,270,1,0,0,0,272,273,1,0,0,0,273,271,1,0,0,0,
|
||||
273,274,1,0,0,0,274,78,1,0,0,0,275,276,5,48,0,0,276,277,7,2,0,0,277,278,
|
||||
3,81,40,0,278,279,3,83,41,0,279,289,1,0,0,0,280,281,5,48,0,0,281,283,
|
||||
7,2,0,0,282,284,7,3,0,0,283,282,1,0,0,0,284,285,1,0,0,0,285,283,1,0,0,
|
||||
0,285,286,1,0,0,0,286,287,1,0,0,0,287,289,3,83,41,0,288,275,1,0,0,0,288,
|
||||
280,1,0,0,0,289,80,1,0,0,0,290,292,7,3,0,0,291,290,1,0,0,0,292,293,1,
|
||||
0,0,0,293,291,1,0,0,0,293,294,1,0,0,0,294,295,1,0,0,0,295,299,5,46,0,
|
||||
0,296,298,7,3,0,0,297,296,1,0,0,0,298,301,1,0,0,0,299,297,1,0,0,0,299,
|
||||
300,1,0,0,0,300,309,1,0,0,0,301,299,1,0,0,0,302,304,5,46,0,0,303,305,
|
||||
7,3,0,0,304,303,1,0,0,0,305,306,1,0,0,0,306,304,1,0,0,0,306,307,1,0,0,
|
||||
0,307,309,1,0,0,0,308,291,1,0,0,0,308,302,1,0,0,0,309,82,1,0,0,0,310,
|
||||
312,7,9,0,0,311,313,7,8,0,0,312,311,1,0,0,0,312,313,1,0,0,0,313,315,1,
|
||||
0,0,0,314,316,7,6,0,0,315,314,1,0,0,0,316,317,1,0,0,0,317,315,1,0,0,0,
|
||||
317,318,1,0,0,0,318,84,1,0,0,0,319,321,7,10,0,0,320,319,1,0,0,0,321,322,
|
||||
1,0,0,0,322,320,1,0,0,0,322,323,1,0,0,0,323,324,1,0,0,0,324,325,6,42,
|
||||
0,0,325,86,1,0,0,0,326,327,5,47,0,0,327,328,5,47,0,0,328,332,1,0,0,0,
|
||||
329,331,8,11,0,0,330,329,1,0,0,0,331,334,1,0,0,0,332,330,1,0,0,0,332,
|
||||
333,1,0,0,0,333,335,1,0,0,0,334,332,1,0,0,0,335,336,6,43,0,0,336,88,1,
|
||||
0,0,0,337,338,5,47,0,0,338,339,5,42,0,0,339,343,1,0,0,0,340,342,9,0,0,
|
||||
0,341,340,1,0,0,0,342,345,1,0,0,0,343,344,1,0,0,0,343,341,1,0,0,0,344,
|
||||
346,1,0,0,0,345,343,1,0,0,0,346,347,5,42,0,0,347,348,5,47,0,0,348,349,
|
||||
1,0,0,0,349,350,6,44,0,0,350,90,1,0,0,0,27,0,204,212,218,225,228,232,
|
||||
236,241,244,249,255,262,264,268,273,285,288,293,299,306,308,312,317,322,
|
||||
332,343,1,6,0,0
|
||||
};
|
||||
staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
|
||||
|
||||
antlr4::atn::ATNDeserializer deserializer;
|
||||
staticData->atn = deserializer.deserialize(staticData->serializedATN);
|
||||
|
||||
const size_t count = staticData->atn->getNumberOfDecisions();
|
||||
staticData->decisionToDFA.reserve(count);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
|
||||
}
|
||||
sysylexerLexerStaticData = std::move(staticData);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SysYLexer::SysYLexer(CharStream *input) : Lexer(input) {
|
||||
SysYLexer::initialize();
|
||||
_interpreter = new atn::LexerATNSimulator(this, *sysylexerLexerStaticData->atn, sysylexerLexerStaticData->decisionToDFA, sysylexerLexerStaticData->sharedContextCache);
|
||||
}
|
||||
|
||||
SysYLexer::~SysYLexer() {
|
||||
delete _interpreter;
|
||||
}
|
||||
|
||||
std::string SysYLexer::getGrammarFileName() const {
|
||||
return "SysY.g4";
|
||||
}
|
||||
|
||||
const std::vector<std::string>& SysYLexer::getRuleNames() const {
|
||||
return sysylexerLexerStaticData->ruleNames;
|
||||
}
|
||||
|
||||
const std::vector<std::string>& SysYLexer::getChannelNames() const {
|
||||
return sysylexerLexerStaticData->channelNames;
|
||||
}
|
||||
|
||||
const std::vector<std::string>& SysYLexer::getModeNames() const {
|
||||
return sysylexerLexerStaticData->modeNames;
|
||||
}
|
||||
|
||||
const dfa::Vocabulary& SysYLexer::getVocabulary() const {
|
||||
return sysylexerLexerStaticData->vocabulary;
|
||||
}
|
||||
|
||||
antlr4::atn::SerializedATNView SysYLexer::getSerializedATN() const {
|
||||
return sysylexerLexerStaticData->serializedATN;
|
||||
}
|
||||
|
||||
const atn::ATN& SysYLexer::getATN() const {
|
||||
return *sysylexerLexerStaticData->atn;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void SysYLexer::initialize() {
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
sysylexerLexerInitialize();
|
||||
#else
|
||||
::antlr4::internal::call_once(sysylexerLexerOnceFlag, sysylexerLexerInitialize);
|
||||
#endif
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "SysYListener.h"
|
||||
|
||||
|
||||
@ -0,0 +1,112 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "antlr4-runtime.h"
|
||||
#include "SysYParser.h"
|
||||
|
||||
|
||||
/**
|
||||
* This interface defines an abstract listener for a parse tree produced by SysYParser.
|
||||
*/
|
||||
class SysYListener : public antlr4::tree::ParseTreeListener {
|
||||
public:
|
||||
|
||||
virtual void enterCompUnit(SysYParser::CompUnitContext *ctx) = 0;
|
||||
virtual void exitCompUnit(SysYParser::CompUnitContext *ctx) = 0;
|
||||
|
||||
virtual void enterFuncDef(SysYParser::FuncDefContext *ctx) = 0;
|
||||
virtual void exitFuncDef(SysYParser::FuncDefContext *ctx) = 0;
|
||||
|
||||
virtual void enterFuncType(SysYParser::FuncTypeContext *ctx) = 0;
|
||||
virtual void exitFuncType(SysYParser::FuncTypeContext *ctx) = 0;
|
||||
|
||||
virtual void enterFuncFParams(SysYParser::FuncFParamsContext *ctx) = 0;
|
||||
virtual void exitFuncFParams(SysYParser::FuncFParamsContext *ctx) = 0;
|
||||
|
||||
virtual void enterFuncFParam(SysYParser::FuncFParamContext *ctx) = 0;
|
||||
virtual void exitFuncFParam(SysYParser::FuncFParamContext *ctx) = 0;
|
||||
|
||||
virtual void enterBlock(SysYParser::BlockContext *ctx) = 0;
|
||||
virtual void exitBlock(SysYParser::BlockContext *ctx) = 0;
|
||||
|
||||
virtual void enterBlockItem(SysYParser::BlockItemContext *ctx) = 0;
|
||||
virtual void exitBlockItem(SysYParser::BlockItemContext *ctx) = 0;
|
||||
|
||||
virtual void enterDecl(SysYParser::DeclContext *ctx) = 0;
|
||||
virtual void exitDecl(SysYParser::DeclContext *ctx) = 0;
|
||||
|
||||
virtual void enterConstDecl(SysYParser::ConstDeclContext *ctx) = 0;
|
||||
virtual void exitConstDecl(SysYParser::ConstDeclContext *ctx) = 0;
|
||||
|
||||
virtual void enterBType(SysYParser::BTypeContext *ctx) = 0;
|
||||
virtual void exitBType(SysYParser::BTypeContext *ctx) = 0;
|
||||
|
||||
virtual void enterConstDef(SysYParser::ConstDefContext *ctx) = 0;
|
||||
virtual void exitConstDef(SysYParser::ConstDefContext *ctx) = 0;
|
||||
|
||||
virtual void enterConstInitVal(SysYParser::ConstInitValContext *ctx) = 0;
|
||||
virtual void exitConstInitVal(SysYParser::ConstInitValContext *ctx) = 0;
|
||||
|
||||
virtual void enterStmt(SysYParser::StmtContext *ctx) = 0;
|
||||
virtual void exitStmt(SysYParser::StmtContext *ctx) = 0;
|
||||
|
||||
virtual void enterCond(SysYParser::CondContext *ctx) = 0;
|
||||
virtual void exitCond(SysYParser::CondContext *ctx) = 0;
|
||||
|
||||
virtual void enterLVal(SysYParser::LValContext *ctx) = 0;
|
||||
virtual void exitLVal(SysYParser::LValContext *ctx) = 0;
|
||||
|
||||
virtual void enterPrimaryExp(SysYParser::PrimaryExpContext *ctx) = 0;
|
||||
virtual void exitPrimaryExp(SysYParser::PrimaryExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterNumber(SysYParser::NumberContext *ctx) = 0;
|
||||
virtual void exitNumber(SysYParser::NumberContext *ctx) = 0;
|
||||
|
||||
virtual void enterUnaryExp(SysYParser::UnaryExpContext *ctx) = 0;
|
||||
virtual void exitUnaryExp(SysYParser::UnaryExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterUnaryOp(SysYParser::UnaryOpContext *ctx) = 0;
|
||||
virtual void exitUnaryOp(SysYParser::UnaryOpContext *ctx) = 0;
|
||||
|
||||
virtual void enterFuncRParams(SysYParser::FuncRParamsContext *ctx) = 0;
|
||||
virtual void exitFuncRParams(SysYParser::FuncRParamsContext *ctx) = 0;
|
||||
|
||||
virtual void enterMulExp(SysYParser::MulExpContext *ctx) = 0;
|
||||
virtual void exitMulExp(SysYParser::MulExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterAddExp(SysYParser::AddExpContext *ctx) = 0;
|
||||
virtual void exitAddExp(SysYParser::AddExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterRelExp(SysYParser::RelExpContext *ctx) = 0;
|
||||
virtual void exitRelExp(SysYParser::RelExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterEqExp(SysYParser::EqExpContext *ctx) = 0;
|
||||
virtual void exitEqExp(SysYParser::EqExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterLAndExp(SysYParser::LAndExpContext *ctx) = 0;
|
||||
virtual void exitLAndExp(SysYParser::LAndExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterLOrExp(SysYParser::LOrExpContext *ctx) = 0;
|
||||
virtual void exitLOrExp(SysYParser::LOrExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterConstExp(SysYParser::ConstExpContext *ctx) = 0;
|
||||
virtual void exitConstExp(SysYParser::ConstExpContext *ctx) = 0;
|
||||
|
||||
virtual void enterVarDecl(SysYParser::VarDeclContext *ctx) = 0;
|
||||
virtual void exitVarDecl(SysYParser::VarDeclContext *ctx) = 0;
|
||||
|
||||
virtual void enterVarDef(SysYParser::VarDefContext *ctx) = 0;
|
||||
virtual void exitVarDef(SysYParser::VarDefContext *ctx) = 0;
|
||||
|
||||
virtual void enterInitVal(SysYParser::InitValContext *ctx) = 0;
|
||||
virtual void exitInitVal(SysYParser::InitValContext *ctx) = 0;
|
||||
|
||||
virtual void enterExp(SysYParser::ExpContext *ctx) = 0;
|
||||
virtual void exitExp(SysYParser::ExpContext *ctx) = 0;
|
||||
|
||||
|
||||
};
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,688 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "antlr4-runtime.h"
|
||||
|
||||
|
||||
|
||||
|
||||
class SysYParser : public antlr4::Parser {
|
||||
public:
|
||||
enum {
|
||||
Void = 1, Int = 2, Float = 3, Const = 4, If = 5, Else = 6, While = 7,
|
||||
Break = 8, Continue = 9, Return = 10, AddOp = 11, SubOp = 12, Assign = 13,
|
||||
MulOp = 14, DivOp = 15, ModOp = 16, NotOp = 17, AndOp = 18, OrOp = 19,
|
||||
EqOp = 20, NeOp = 21, LtOp = 22, GtOp = 23, LeOp = 24, GeOp = 25, Semi = 26,
|
||||
Comma = 27, L_PAREN = 28, R_PAREN = 29, L_BRACE = 30, R_BRACE = 31,
|
||||
L_BRACKET = 32, R_BRACKET = 33, Ident = 34, IntConst = 35, FloatConst = 36,
|
||||
WS = 37, COMMENT = 38, BLOCK_COMMENT = 39
|
||||
};
|
||||
|
||||
enum {
|
||||
RuleCompUnit = 0, RuleFuncDef = 1, RuleFuncType = 2, RuleFuncFParams = 3,
|
||||
RuleFuncFParam = 4, RuleBlock = 5, RuleBlockItem = 6, RuleDecl = 7,
|
||||
RuleConstDecl = 8, RuleBType = 9, RuleConstDef = 10, RuleConstInitVal = 11,
|
||||
RuleStmt = 12, RuleCond = 13, RuleLVal = 14, RulePrimaryExp = 15, RuleNumber = 16,
|
||||
RuleUnaryExp = 17, RuleUnaryOp = 18, RuleFuncRParams = 19, RuleMulExp = 20,
|
||||
RuleAddExp = 21, RuleRelExp = 22, RuleEqExp = 23, RuleLAndExp = 24,
|
||||
RuleLOrExp = 25, RuleConstExp = 26, RuleVarDecl = 27, RuleVarDef = 28,
|
||||
RuleInitVal = 29, RuleExp = 30
|
||||
};
|
||||
|
||||
explicit SysYParser(antlr4::TokenStream *input);
|
||||
|
||||
SysYParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
|
||||
|
||||
~SysYParser() override;
|
||||
|
||||
std::string getGrammarFileName() const override;
|
||||
|
||||
const antlr4::atn::ATN& getATN() const override;
|
||||
|
||||
const std::vector<std::string>& getRuleNames() const override;
|
||||
|
||||
const antlr4::dfa::Vocabulary& getVocabulary() const override;
|
||||
|
||||
antlr4::atn::SerializedATNView getSerializedATN() const override;
|
||||
|
||||
|
||||
class CompUnitContext;
|
||||
class FuncDefContext;
|
||||
class FuncTypeContext;
|
||||
class FuncFParamsContext;
|
||||
class FuncFParamContext;
|
||||
class BlockContext;
|
||||
class BlockItemContext;
|
||||
class DeclContext;
|
||||
class ConstDeclContext;
|
||||
class BTypeContext;
|
||||
class ConstDefContext;
|
||||
class ConstInitValContext;
|
||||
class StmtContext;
|
||||
class CondContext;
|
||||
class LValContext;
|
||||
class PrimaryExpContext;
|
||||
class NumberContext;
|
||||
class UnaryExpContext;
|
||||
class UnaryOpContext;
|
||||
class FuncRParamsContext;
|
||||
class MulExpContext;
|
||||
class AddExpContext;
|
||||
class RelExpContext;
|
||||
class EqExpContext;
|
||||
class LAndExpContext;
|
||||
class LOrExpContext;
|
||||
class ConstExpContext;
|
||||
class VarDeclContext;
|
||||
class VarDefContext;
|
||||
class InitValContext;
|
||||
class ExpContext;
|
||||
|
||||
class CompUnitContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
CompUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *EOF();
|
||||
std::vector<FuncDefContext *> funcDef();
|
||||
FuncDefContext* funcDef(size_t i);
|
||||
std::vector<DeclContext *> decl();
|
||||
DeclContext* decl(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
CompUnitContext* compUnit();
|
||||
|
||||
class FuncDefContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
FuncDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
FuncTypeContext *funcType();
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
antlr4::tree::TerminalNode *L_PAREN();
|
||||
antlr4::tree::TerminalNode *R_PAREN();
|
||||
BlockContext *block();
|
||||
FuncFParamsContext *funcFParams();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
FuncDefContext* funcDef();
|
||||
|
||||
class FuncTypeContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
FuncTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Void();
|
||||
antlr4::tree::TerminalNode *Int();
|
||||
antlr4::tree::TerminalNode *Float();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
FuncTypeContext* funcType();
|
||||
|
||||
class FuncFParamsContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
FuncFParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
std::vector<FuncFParamContext *> funcFParam();
|
||||
FuncFParamContext* funcFParam(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
FuncFParamsContext* funcFParams();
|
||||
|
||||
class FuncFParamContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
FuncFParamContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
BTypeContext *bType();
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
std::vector<antlr4::tree::TerminalNode *> L_BRACKET();
|
||||
antlr4::tree::TerminalNode* L_BRACKET(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> R_BRACKET();
|
||||
antlr4::tree::TerminalNode* R_BRACKET(size_t i);
|
||||
std::vector<ExpContext *> exp();
|
||||
ExpContext* exp(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
FuncFParamContext* funcFParam();
|
||||
|
||||
class BlockContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *L_BRACE();
|
||||
antlr4::tree::TerminalNode *R_BRACE();
|
||||
std::vector<BlockItemContext *> blockItem();
|
||||
BlockItemContext* blockItem(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
BlockContext* block();
|
||||
|
||||
class BlockItemContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
BlockItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
DeclContext *decl();
|
||||
StmtContext *stmt();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
BlockItemContext* blockItem();
|
||||
|
||||
class DeclContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
DeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
VarDeclContext *varDecl();
|
||||
ConstDeclContext *constDecl();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
DeclContext* decl();
|
||||
|
||||
class ConstDeclContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
ConstDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Const();
|
||||
BTypeContext *bType();
|
||||
std::vector<ConstDefContext *> constDef();
|
||||
ConstDefContext* constDef(size_t i);
|
||||
antlr4::tree::TerminalNode *Semi();
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
ConstDeclContext* constDecl();
|
||||
|
||||
class BTypeContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
BTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Int();
|
||||
antlr4::tree::TerminalNode *Float();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
BTypeContext* bType();
|
||||
|
||||
class ConstDefContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
ConstDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
antlr4::tree::TerminalNode *Assign();
|
||||
ConstInitValContext *constInitVal();
|
||||
std::vector<antlr4::tree::TerminalNode *> L_BRACKET();
|
||||
antlr4::tree::TerminalNode* L_BRACKET(size_t i);
|
||||
std::vector<ConstExpContext *> constExp();
|
||||
ConstExpContext* constExp(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> R_BRACKET();
|
||||
antlr4::tree::TerminalNode* R_BRACKET(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
ConstDefContext* constDef();
|
||||
|
||||
class ConstInitValContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
ConstInitValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
ConstExpContext *constExp();
|
||||
antlr4::tree::TerminalNode *L_BRACE();
|
||||
antlr4::tree::TerminalNode *R_BRACE();
|
||||
std::vector<ConstInitValContext *> constInitVal();
|
||||
ConstInitValContext* constInitVal(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
ConstInitValContext* constInitVal();
|
||||
|
||||
class StmtContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
StmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
LValContext *lVal();
|
||||
antlr4::tree::TerminalNode *Assign();
|
||||
ExpContext *exp();
|
||||
antlr4::tree::TerminalNode *Semi();
|
||||
BlockContext *block();
|
||||
antlr4::tree::TerminalNode *If();
|
||||
antlr4::tree::TerminalNode *L_PAREN();
|
||||
CondContext *cond();
|
||||
antlr4::tree::TerminalNode *R_PAREN();
|
||||
std::vector<StmtContext *> stmt();
|
||||
StmtContext* stmt(size_t i);
|
||||
antlr4::tree::TerminalNode *Else();
|
||||
antlr4::tree::TerminalNode *While();
|
||||
antlr4::tree::TerminalNode *Break();
|
||||
antlr4::tree::TerminalNode *Continue();
|
||||
antlr4::tree::TerminalNode *Return();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
StmtContext* stmt();
|
||||
|
||||
class CondContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
CondContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
LOrExpContext *lOrExp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
CondContext* cond();
|
||||
|
||||
class LValContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
LValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
std::vector<antlr4::tree::TerminalNode *> L_BRACKET();
|
||||
antlr4::tree::TerminalNode* L_BRACKET(size_t i);
|
||||
std::vector<ExpContext *> exp();
|
||||
ExpContext* exp(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> R_BRACKET();
|
||||
antlr4::tree::TerminalNode* R_BRACKET(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
LValContext* lVal();
|
||||
|
||||
class PrimaryExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
PrimaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *L_PAREN();
|
||||
ExpContext *exp();
|
||||
antlr4::tree::TerminalNode *R_PAREN();
|
||||
LValContext *lVal();
|
||||
NumberContext *number();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
PrimaryExpContext* primaryExp();
|
||||
|
||||
class NumberContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
NumberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *IntConst();
|
||||
antlr4::tree::TerminalNode *FloatConst();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
NumberContext* number();
|
||||
|
||||
class UnaryExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
UnaryExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
PrimaryExpContext *primaryExp();
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
antlr4::tree::TerminalNode *L_PAREN();
|
||||
antlr4::tree::TerminalNode *R_PAREN();
|
||||
FuncRParamsContext *funcRParams();
|
||||
UnaryOpContext *unaryOp();
|
||||
UnaryExpContext *unaryExp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
UnaryExpContext* unaryExp();
|
||||
|
||||
class UnaryOpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
UnaryOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *AddOp();
|
||||
antlr4::tree::TerminalNode *SubOp();
|
||||
antlr4::tree::TerminalNode *NotOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
UnaryOpContext* unaryOp();
|
||||
|
||||
class FuncRParamsContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
FuncRParamsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
std::vector<ExpContext *> exp();
|
||||
ExpContext* exp(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
FuncRParamsContext* funcRParams();
|
||||
|
||||
class MulExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
MulExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
UnaryExpContext *unaryExp();
|
||||
MulExpContext *mulExp();
|
||||
antlr4::tree::TerminalNode *MulOp();
|
||||
antlr4::tree::TerminalNode *DivOp();
|
||||
antlr4::tree::TerminalNode *ModOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
MulExpContext* mulExp();
|
||||
MulExpContext* mulExp(int precedence);
|
||||
class AddExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
AddExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
MulExpContext *mulExp();
|
||||
AddExpContext *addExp();
|
||||
antlr4::tree::TerminalNode *AddOp();
|
||||
antlr4::tree::TerminalNode *SubOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
AddExpContext* addExp();
|
||||
AddExpContext* addExp(int precedence);
|
||||
class RelExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
RelExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
AddExpContext *addExp();
|
||||
RelExpContext *relExp();
|
||||
antlr4::tree::TerminalNode *LtOp();
|
||||
antlr4::tree::TerminalNode *GtOp();
|
||||
antlr4::tree::TerminalNode *LeOp();
|
||||
antlr4::tree::TerminalNode *GeOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
RelExpContext* relExp();
|
||||
RelExpContext* relExp(int precedence);
|
||||
class EqExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
EqExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
RelExpContext *relExp();
|
||||
EqExpContext *eqExp();
|
||||
antlr4::tree::TerminalNode *EqOp();
|
||||
antlr4::tree::TerminalNode *NeOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
EqExpContext* eqExp();
|
||||
EqExpContext* eqExp(int precedence);
|
||||
class LAndExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
LAndExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
EqExpContext *eqExp();
|
||||
LAndExpContext *lAndExp();
|
||||
antlr4::tree::TerminalNode *AndOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
LAndExpContext* lAndExp();
|
||||
LAndExpContext* lAndExp(int precedence);
|
||||
class LOrExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
LOrExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
LAndExpContext *lAndExp();
|
||||
LOrExpContext *lOrExp();
|
||||
antlr4::tree::TerminalNode *OrOp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
LOrExpContext* lOrExp();
|
||||
LOrExpContext* lOrExp(int precedence);
|
||||
class ConstExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
ConstExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
AddExpContext *addExp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
ConstExpContext* constExp();
|
||||
|
||||
class VarDeclContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
BTypeContext *bType();
|
||||
std::vector<VarDefContext *> varDef();
|
||||
VarDefContext* varDef(size_t i);
|
||||
antlr4::tree::TerminalNode *Semi();
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
VarDeclContext* varDecl();
|
||||
|
||||
class VarDefContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
VarDefContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *Ident();
|
||||
std::vector<antlr4::tree::TerminalNode *> L_BRACKET();
|
||||
antlr4::tree::TerminalNode* L_BRACKET(size_t i);
|
||||
std::vector<ConstExpContext *> constExp();
|
||||
ConstExpContext* constExp(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> R_BRACKET();
|
||||
antlr4::tree::TerminalNode* R_BRACKET(size_t i);
|
||||
antlr4::tree::TerminalNode *Assign();
|
||||
InitValContext *initVal();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
VarDefContext* varDef();
|
||||
|
||||
class InitValContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
InitValContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
ExpContext *exp();
|
||||
antlr4::tree::TerminalNode *L_BRACE();
|
||||
antlr4::tree::TerminalNode *R_BRACE();
|
||||
std::vector<InitValContext *> initVal();
|
||||
InitValContext* initVal(size_t i);
|
||||
std::vector<antlr4::tree::TerminalNode *> Comma();
|
||||
antlr4::tree::TerminalNode* Comma(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
InitValContext* initVal();
|
||||
|
||||
class ExpContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
ExpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
AddExpContext *addExp();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
|
||||
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
||||
|
||||
};
|
||||
|
||||
ExpContext* exp();
|
||||
|
||||
|
||||
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
|
||||
|
||||
bool mulExpSempred(MulExpContext *_localctx, size_t predicateIndex);
|
||||
bool addExpSempred(AddExpContext *_localctx, size_t predicateIndex);
|
||||
bool relExpSempred(RelExpContext *_localctx, size_t predicateIndex);
|
||||
bool eqExpSempred(EqExpContext *_localctx, size_t predicateIndex);
|
||||
bool lAndExpSempred(LAndExpContext *_localctx, size_t predicateIndex);
|
||||
bool lOrExpSempred(LOrExpContext *_localctx, size_t predicateIndex);
|
||||
|
||||
// By default the static state used to implement the parser is lazily initialized during the first
|
||||
// call to the constructor. You can call this function if you wish to initialize the static state
|
||||
// ahead of time.
|
||||
static void initialize();
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "SysYVisitor.h"
|
||||
|
||||
|
||||
@ -0,0 +1,86 @@
|
||||
|
||||
// Generated from src/antlr4/SysY.g4 by ANTLR 4.13.2
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "antlr4-runtime.h"
|
||||
#include "SysYParser.h"
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* This class defines an abstract visitor for a parse tree
|
||||
* produced by SysYParser.
|
||||
*/
|
||||
class SysYVisitor : public antlr4::tree::AbstractParseTreeVisitor {
|
||||
public:
|
||||
|
||||
/**
|
||||
* Visit parse trees produced by SysYParser.
|
||||
*/
|
||||
virtual std::any visitCompUnit(SysYParser::CompUnitContext *context) = 0;
|
||||
|
||||
virtual std::any visitFuncDef(SysYParser::FuncDefContext *context) = 0;
|
||||
|
||||
virtual std::any visitFuncType(SysYParser::FuncTypeContext *context) = 0;
|
||||
|
||||
virtual std::any visitFuncFParams(SysYParser::FuncFParamsContext *context) = 0;
|
||||
|
||||
virtual std::any visitFuncFParam(SysYParser::FuncFParamContext *context) = 0;
|
||||
|
||||
virtual std::any visitBlock(SysYParser::BlockContext *context) = 0;
|
||||
|
||||
virtual std::any visitBlockItem(SysYParser::BlockItemContext *context) = 0;
|
||||
|
||||
virtual std::any visitDecl(SysYParser::DeclContext *context) = 0;
|
||||
|
||||
virtual std::any visitConstDecl(SysYParser::ConstDeclContext *context) = 0;
|
||||
|
||||
virtual std::any visitBType(SysYParser::BTypeContext *context) = 0;
|
||||
|
||||
virtual std::any visitConstDef(SysYParser::ConstDefContext *context) = 0;
|
||||
|
||||
virtual std::any visitConstInitVal(SysYParser::ConstInitValContext *context) = 0;
|
||||
|
||||
virtual std::any visitStmt(SysYParser::StmtContext *context) = 0;
|
||||
|
||||
virtual std::any visitCond(SysYParser::CondContext *context) = 0;
|
||||
|
||||
virtual std::any visitLVal(SysYParser::LValContext *context) = 0;
|
||||
|
||||
virtual std::any visitPrimaryExp(SysYParser::PrimaryExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitNumber(SysYParser::NumberContext *context) = 0;
|
||||
|
||||
virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitUnaryOp(SysYParser::UnaryOpContext *context) = 0;
|
||||
|
||||
virtual std::any visitFuncRParams(SysYParser::FuncRParamsContext *context) = 0;
|
||||
|
||||
virtual std::any visitMulExp(SysYParser::MulExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitAddExp(SysYParser::AddExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitRelExp(SysYParser::RelExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitEqExp(SysYParser::EqExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitLAndExp(SysYParser::LAndExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitLOrExp(SysYParser::LOrExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitConstExp(SysYParser::ConstExpContext *context) = 0;
|
||||
|
||||
virtual std::any visitVarDecl(SysYParser::VarDeclContext *context) = 0;
|
||||
|
||||
virtual std::any visitVarDef(SysYParser::VarDefContext *context) = 0;
|
||||
|
||||
virtual std::any visitInitVal(SysYParser::InitValContext *context) = 0;
|
||||
|
||||
virtual std::any visitExp(SysYParser::ExpContext *context) = 0;
|
||||
|
||||
|
||||
};
|
||||
|
||||
@ -0,0 +1,98 @@
|
||||
// SysY 运行库实现：
|
||||
// - 按实验/评测规范提供 I/O 等函数实现
|
||||
// - 与编译器生成的目标代码链接，支撑运行时行为
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
// 输入函数
|
||||
int getint() {
|
||||
int value;
|
||||
scanf("%d", &value);
|
||||
return value;
|
||||
}
|
||||
|
||||
int getch() {
|
||||
char ch;
|
||||
scanf("%c", &ch);
|
||||
return (int)ch;
|
||||
}
|
||||
|
||||
float getfloat() {
|
||||
float value;
|
||||
scanf("%f", &value);
|
||||
return value;
|
||||
}
|
||||
|
||||
int getarray(int arr[]) {
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
scanf("%d", &arr[i]);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
int getfarray(float arr[]) {
|
||||
int n;
|
||||
scanf("%d", &n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
scanf("%f", &arr[i]);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
// 输出函数
|
||||
void putint(int value) {
|
||||
printf("%d", value);
|
||||
}
|
||||
|
||||
void putch(int ch) {
|
||||
printf("%c", (char)ch);
|
||||
}
|
||||
|
||||
void putfloat(float value) {
|
||||
printf("%a", value);
|
||||
}
|
||||
|
||||
void putarray(int n, int arr[]) {
|
||||
printf("%d:", n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
printf(" %d", arr[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void putfarray(int n, float arr[]) {
|
||||
printf("%d:", n);
|
||||
for (int i = 0; i < n; i++) {
|
||||
printf(" %a", arr[i]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
// putstr 在测试用例中定义
|
||||
|
||||
// 计时函数
|
||||
static clock_t start_time = 0;
|
||||
|
||||
void starttime() {
|
||||
start_time = clock();
|
||||
}
|
||||
|
||||
void stoptime() {
|
||||
clock_t end_time = clock();
|
||||
double elapsed = (double)(end_time - start_time) / CLOCKS_PER_SEC;
|
||||
fprintf(stderr, "Total time: %.6f seconds\n", elapsed);
|
||||
}
|
||||
|
||||
// 内存管理函数（如果需要）
|
||||
void* _sysy_allocate(int size) {
|
||||
return malloc(size);
|
||||
}
|
||||
|
||||
void _sysy_deallocate(void* ptr) {
|
||||
free(ptr);
|
||||
}
|
||||
@ -0,0 +1,4 @@
|
||||
// SysY 运行库头文件：
|
||||
// - 声明运行库函数原型（供编译器生成 call 或链接阶段引用）
|
||||
// - 与 sylib.c 配套，按规范逐步补齐声明
|
||||
|
||||
@ -1,10 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#include "ANTLRErrorListener.h"
|
||||
|
||||
antlr4::ANTLRErrorListener::~ANTLRErrorListener()
|
||||
{
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#include "ANTLRErrorStrategy.h"
|
||||
|
||||
antlr4::ANTLRErrorStrategy::~ANTLRErrorStrategy()
|
||||
{
|
||||
}
|
||||
@ -1,121 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "Token.h"
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
/// <summary>
|
||||
/// The interface for defining strategies to deal with syntax errors encountered
|
||||
/// during a parse by ANTLR-generated parsers. We distinguish between three
|
||||
/// different kinds of errors:
|
||||
///
|
||||
/// <ul>
|
||||
/// <li>The parser could not figure out which path to take in the ATN (none of
|
||||
/// the available alternatives could possibly match)</li>
|
||||
/// <li>The current input does not match what we were looking for</li>
|
||||
/// <li>A predicate evaluated to false</li>
|
||||
/// </ul>
|
||||
///
|
||||
/// Implementations of this interface report syntax errors by calling
|
||||
/// <seealso cref="Parser#notifyErrorListeners"/>.
|
||||
/// <p/>
|
||||
/// TODO: what to do about lexers
|
||||
/// </summary>
|
||||
class ANTLR4CPP_PUBLIC ANTLRErrorStrategy {
|
||||
public:
|
||||
|
||||
/// <summary>
|
||||
/// Reset the error handler state for the specified {@code recognizer}. </summary>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
virtual ~ANTLRErrorStrategy();
|
||||
|
||||
virtual void reset(Parser *recognizer) = 0;
|
||||
|
||||
/**
|
||||
* This method is called when an unexpected symbol is encountered during an
|
||||
* inline match operation, such as {@link Parser#match}. If the error
|
||||
* strategy successfully recovers from the match failure, this method
|
||||
* returns the {@link Token} instance which should be treated as the
|
||||
* successful result of the match.
|
||||
*
|
||||
* <p>This method handles the consumption of any tokens - the caller should
|
||||
* <b>not</b> call {@link Parser#consume} after a successful recovery.</p>
|
||||
*
|
||||
* <p>Note that the calling code will not report an error if this method
|
||||
* returns successfully. The error strategy implementation is responsible
|
||||
* for calling {@link Parser#notifyErrorListeners} as appropriate.</p>
|
||||
*
|
||||
* @param recognizer the parser instance
|
||||
* @throws RecognitionException if the error strategy was not able to
|
||||
* recover from the unexpected input symbol
|
||||
*/
|
||||
virtual Token* recoverInline(Parser *recognizer) = 0;
|
||||
|
||||
/// <summary>
|
||||
/// This method is called to recover from exception {@code e}. This method is
|
||||
/// called after <seealso cref="#reportError"/> by the default exception handler
|
||||
/// generated for a rule method.
|
||||
/// </summary>
|
||||
/// <seealso cref= #reportError
|
||||
/// </seealso>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
/// <param name="e"> the recognition exception to recover from </param>
|
||||
/// <exception cref="RecognitionException"> if the error strategy could not recover from
|
||||
/// the recognition exception </exception>
|
||||
virtual void recover(Parser *recognizer, std::exception_ptr e) = 0;
|
||||
|
||||
/// <summary>
|
||||
/// This method provides the error handler with an opportunity to handle
|
||||
/// syntactic or semantic errors in the input stream before they result in a
|
||||
/// <seealso cref="RecognitionException"/>.
|
||||
/// <p/>
|
||||
/// The generated code currently contains calls to <seealso cref="#sync"/> after
|
||||
/// entering the decision state of a closure block ({@code (...)*} or
|
||||
/// {@code (...)+}).
|
||||
/// <p/>
|
||||
/// For an implementation based on Jim Idle's "magic sync" mechanism, see
|
||||
/// <seealso cref="DefaultErrorStrategy#sync"/>.
|
||||
/// </summary>
|
||||
/// <seealso cref= DefaultErrorStrategy#sync
|
||||
/// </seealso>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
/// <exception cref="RecognitionException"> if an error is detected by the error
|
||||
/// strategy but cannot be automatically recovered at the current state in
|
||||
/// the parsing process </exception>
|
||||
virtual void sync(Parser *recognizer) = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Tests whether or not {@code recognizer} is in the process of recovering
|
||||
/// from an error. In error recovery mode, <seealso cref="Parser#consume"/> adds
|
||||
/// symbols to the parse tree by calling
|
||||
/// {@link Parser#createErrorNode(ParserRuleContext, Token)} then
|
||||
/// {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of
|
||||
/// {@link Parser#createTerminalNode(ParserRuleContext, Token)}.
|
||||
/// </summary>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
/// <returns> {@code true} if the parser is currently recovering from a parse
|
||||
/// error, otherwise {@code false} </returns>
|
||||
virtual bool inErrorRecoveryMode(Parser *recognizer) = 0;
|
||||
|
||||
/// <summary>
|
||||
/// This method is called by when the parser successfully matches an input
|
||||
/// symbol.
|
||||
/// </summary>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
virtual void reportMatch(Parser *recognizer) = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Report any kind of <seealso cref="RecognitionException"/>. This method is called by
|
||||
/// the default exception handler generated for a rule method.
|
||||
/// </summary>
|
||||
/// <param name="recognizer"> the parser instance </param>
|
||||
/// <param name="e"> the recognition exception to report </param>
|
||||
virtual void reportError(Parser *recognizer, const RecognitionException &e) = 0;
|
||||
};
|
||||
|
||||
} // namespace antlr4
|
||||
@ -1,23 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#include "ANTLRFileStream.h"
|
||||
|
||||
using namespace antlr4;
|
||||
|
||||
void ANTLRFileStream::loadFromFile(const std::string &fileName) {
|
||||
_fileName = fileName;
|
||||
if (_fileName.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
std::ifstream stream(fileName, std::ios::binary);
|
||||
|
||||
ANTLRInputStream::load(stream);
|
||||
}
|
||||
|
||||
std::string ANTLRFileStream::getSourceName() const {
|
||||
return _fileName;
|
||||
}
|
||||
@ -1,30 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "ANTLRInputStream.h"
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
/// This is an ANTLRInputStream that is loaded from a file all at once
|
||||
/// when you construct the object (or call load()).
|
||||
// TODO: this class needs testing.
|
||||
class ANTLR4CPP_PUBLIC ANTLRFileStream : public ANTLRInputStream {
|
||||
public:
|
||||
ANTLRFileStream() = default;
|
||||
ANTLRFileStream(const std::string &) = delete;
|
||||
ANTLRFileStream(const char *data, size_t length) = delete;
|
||||
ANTLRFileStream(std::istream &stream) = delete;
|
||||
|
||||
// Assumes a file name encoded in UTF-8 and file content in the same encoding (with or w/o BOM).
|
||||
virtual void loadFromFile(const std::string &fileName);
|
||||
virtual std::string getSourceName() const override;
|
||||
|
||||
private:
|
||||
std::string _fileName; // UTF-8 encoded file name.
|
||||
};
|
||||
|
||||
} // namespace antlr4
|
||||
@ -1,180 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "Exceptions.h"
|
||||
#include "misc/Interval.h"
|
||||
#include "IntStream.h"
|
||||
|
||||
#include "support/Utf8.h"
|
||||
#include "support/CPPUtils.h"
|
||||
|
||||
#include "ANTLRInputStream.h"
|
||||
|
||||
using namespace antlr4;
|
||||
using namespace antlrcpp;
|
||||
|
||||
using misc::Interval;
|
||||
|
||||
ANTLRInputStream::ANTLRInputStream() {
|
||||
InitializeInstanceFields();
|
||||
}
|
||||
|
||||
ANTLRInputStream::ANTLRInputStream(std::string_view input): ANTLRInputStream() {
|
||||
load(input.data(), input.length());
|
||||
}
|
||||
|
||||
ANTLRInputStream::ANTLRInputStream(const char *data, size_t length) {
|
||||
load(data, length);
|
||||
}
|
||||
|
||||
ANTLRInputStream::ANTLRInputStream(std::istream &stream): ANTLRInputStream() {
|
||||
load(stream);
|
||||
}
|
||||
|
||||
void ANTLRInputStream::load(const std::string &input, bool lenient) {
|
||||
load(input.data(), input.size(), lenient);
|
||||
}
|
||||
|
||||
void ANTLRInputStream::load(const char *data, size_t length, bool lenient) {
|
||||
// Remove the UTF-8 BOM if present.
|
||||
const char *bom = "\xef\xbb\xbf";
|
||||
if (length >= 3 && strncmp(data, bom, 3) == 0) {
|
||||
data += 3;
|
||||
length -= 3;
|
||||
}
|
||||
if (lenient) {
|
||||
_data = Utf8::lenientDecode(std::string_view(data, length));
|
||||
} else {
|
||||
auto maybe_utf32 = Utf8::strictDecode(std::string_view(data, length));
|
||||
if (!maybe_utf32.has_value()) {
|
||||
throw IllegalArgumentException("UTF-8 string contains an illegal byte sequence");
|
||||
}
|
||||
_data = std::move(maybe_utf32).value();
|
||||
}
|
||||
p = 0;
|
||||
}
|
||||
|
||||
void ANTLRInputStream::load(std::istream &stream, bool lenient) {
|
||||
if (!stream.good() || stream.eof()) // No fail, bad or EOF.
|
||||
return;
|
||||
|
||||
_data.clear();
|
||||
|
||||
std::string s((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
|
||||
load(s.data(), s.length(), lenient);
|
||||
}
|
||||
|
||||
void ANTLRInputStream::reset() {
|
||||
p = 0;
|
||||
}
|
||||
|
||||
void ANTLRInputStream::consume() {
|
||||
if (p >= _data.size()) {
|
||||
assert(LA(1) == IntStream::EOF);
|
||||
throw IllegalStateException("cannot consume EOF");
|
||||
}
|
||||
|
||||
if (p < _data.size()) {
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
size_t ANTLRInputStream::LA(ssize_t i) {
|
||||
if (i == 0) {
|
||||
return 0; // undefined
|
||||
}
|
||||
|
||||
ssize_t position = static_cast<ssize_t>(p);
|
||||
if (i < 0) {
|
||||
i++; // e.g., translate LA(-1) to use offset i=0; then _data[p+0-1]
|
||||
if ((position + i - 1) < 0) {
|
||||
return IntStream::EOF; // invalid; no char before first char
|
||||
}
|
||||
}
|
||||
|
||||
if ((position + i - 1) >= static_cast<ssize_t>(_data.size())) {
|
||||
return IntStream::EOF;
|
||||
}
|
||||
|
||||
return _data[static_cast<size_t>((position + i - 1))];
|
||||
}
|
||||
|
||||
size_t ANTLRInputStream::LT(ssize_t i) {
|
||||
return LA(i);
|
||||
}
|
||||
|
||||
size_t ANTLRInputStream::index() {
|
||||
return p;
|
||||
}
|
||||
|
||||
size_t ANTLRInputStream::size() {
|
||||
return _data.size();
|
||||
}
|
||||
|
||||
// Mark/release do nothing. We have entire buffer.
|
||||
ssize_t ANTLRInputStream::mark() {
|
||||
return -1;
|
||||
}
|
||||
|
||||
void ANTLRInputStream::release(ssize_t /* marker */) {
|
||||
}
|
||||
|
||||
void ANTLRInputStream::seek(size_t index) {
|
||||
if (index <= p) {
|
||||
p = index; // just jump; don't update stream state (line, ...)
|
||||
return;
|
||||
}
|
||||
// seek forward, consume until p hits index or n (whichever comes first)
|
||||
index = std::min(index, _data.size());
|
||||
while (p < index) {
|
||||
consume();
|
||||
}
|
||||
}
|
||||
|
||||
std::string ANTLRInputStream::getText(const Interval &interval) {
|
||||
if (interval.a < 0 || interval.b < 0) {
|
||||
return "";
|
||||
}
|
||||
|
||||
size_t start = static_cast<size_t>(interval.a);
|
||||
size_t stop = static_cast<size_t>(interval.b);
|
||||
|
||||
|
||||
if (stop >= _data.size()) {
|
||||
stop = _data.size() - 1;
|
||||
}
|
||||
|
||||
size_t count = stop - start + 1;
|
||||
if (start >= _data.size()) {
|
||||
return "";
|
||||
}
|
||||
|
||||
auto maybeUtf8 = Utf8::strictEncode(std::u32string_view(_data).substr(start, count));
|
||||
if (!maybeUtf8.has_value()) {
|
||||
throw IllegalArgumentException("Input stream contains invalid Unicode code points");
|
||||
}
|
||||
return std::move(maybeUtf8).value();
|
||||
}
|
||||
|
||||
std::string ANTLRInputStream::getSourceName() const {
|
||||
if (name.empty()) {
|
||||
return IntStream::UNKNOWN_SOURCE_NAME;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
std::string ANTLRInputStream::toString() const {
|
||||
auto maybeUtf8 = Utf8::strictEncode(_data);
|
||||
if (!maybeUtf8.has_value()) {
|
||||
throw IllegalArgumentException("Input stream contains invalid Unicode code points");
|
||||
}
|
||||
return std::move(maybeUtf8).value();
|
||||
}
|
||||
|
||||
void ANTLRInputStream::InitializeInstanceFields() {
|
||||
p = 0;
|
||||
}
|
||||
@ -1,79 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <string_view>
|
||||
|
||||
#include "CharStream.h"
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
// Vacuum all input from a stream and then treat it
|
||||
// like a string. Can also pass in a string or char[] to use.
|
||||
// Input is expected to be encoded in UTF-8 and converted to UTF-32 internally.
|
||||
class ANTLR4CPP_PUBLIC ANTLRInputStream : public CharStream {
|
||||
protected:
|
||||
/// The data being scanned.
|
||||
// UTF-32
|
||||
std::u32string _data;
|
||||
|
||||
/// 0..n-1 index into string of next char </summary>
|
||||
size_t p;
|
||||
|
||||
public:
|
||||
/// What is name or source of this char stream?
|
||||
std::string name;
|
||||
|
||||
ANTLRInputStream();
|
||||
|
||||
ANTLRInputStream(std::string_view input);
|
||||
|
||||
ANTLRInputStream(const char *data, size_t length);
|
||||
ANTLRInputStream(std::istream &stream);
|
||||
|
||||
virtual void load(const std::string &input, bool lenient);
|
||||
virtual void load(const char *data, size_t length, bool lenient);
|
||||
virtual void load(std::istream &stream, bool lenient);
|
||||
|
||||
virtual void load(const std::string &input) { load(input, false); }
|
||||
virtual void load(const char *data, size_t length) { load(data, length, false); }
|
||||
virtual void load(std::istream &stream) { load(stream, false); }
|
||||
|
||||
/// Reset the stream so that it's in the same state it was
|
||||
/// when the object was created *except* the data array is not
|
||||
/// touched.
|
||||
virtual void reset();
|
||||
virtual void consume() override;
|
||||
virtual size_t LA(ssize_t i) override;
|
||||
virtual size_t LT(ssize_t i);
|
||||
|
||||
/// <summary>
|
||||
/// Return the current input symbol index 0..n where n indicates the
|
||||
/// last symbol has been read. The index is the index of char to
|
||||
/// be returned from LA(1).
|
||||
/// </summary>
|
||||
virtual size_t index() override;
|
||||
virtual size_t size() override;
|
||||
|
||||
/// <summary>
|
||||
/// mark/release do nothing; we have entire buffer </summary>
|
||||
virtual ssize_t mark() override;
|
||||
virtual void release(ssize_t marker) override;
|
||||
|
||||
/// <summary>
|
||||
/// consume() ahead until p==index; can't just set p=index as we must
|
||||
/// update line and charPositionInLine. If we seek backwards, just set p
|
||||
/// </summary>
|
||||
virtual void seek(size_t index) override;
|
||||
virtual std::string getText(const misc::Interval &interval) override;
|
||||
virtual std::string getSourceName() const override;
|
||||
virtual std::string toString() const override;
|
||||
|
||||
private:
|
||||
void InitializeInstanceFields();
|
||||
};
|
||||
|
||||
} // namespace antlr4
|
||||
@ -1,64 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#include "Exceptions.h"
|
||||
|
||||
using namespace antlr4;
|
||||
|
||||
RuntimeException::RuntimeException(const std::string &msg) : std::exception(), _message(msg) {
|
||||
}
|
||||
|
||||
const char* RuntimeException::what() const noexcept {
|
||||
return _message.c_str();
|
||||
}
|
||||
|
||||
//------------------ IOException ---------------------------------------------------------------------------------------
|
||||
|
||||
IOException::IOException(const std::string &msg) : std::exception(), _message(msg) {
|
||||
}
|
||||
|
||||
const char* IOException::what() const noexcept {
|
||||
return _message.c_str();
|
||||
}
|
||||
|
||||
//------------------ IllegalStateException -----------------------------------------------------------------------------
|
||||
|
||||
IllegalStateException::~IllegalStateException() {
|
||||
}
|
||||
|
||||
//------------------ IllegalArgumentException --------------------------------------------------------------------------
|
||||
|
||||
IllegalArgumentException::~IllegalArgumentException() {
|
||||
}
|
||||
|
||||
//------------------ NullPointerException ------------------------------------------------------------------------------
|
||||
|
||||
NullPointerException::~NullPointerException() {
|
||||
}
|
||||
|
||||
//------------------ IndexOutOfBoundsException -------------------------------------------------------------------------
|
||||
|
||||
IndexOutOfBoundsException::~IndexOutOfBoundsException() {
|
||||
}
|
||||
|
||||
//------------------ UnsupportedOperationException ---------------------------------------------------------------------
|
||||
|
||||
UnsupportedOperationException::~UnsupportedOperationException() {
|
||||
}
|
||||
|
||||
//------------------ EmptyStackException -------------------------------------------------------------------------------
|
||||
|
||||
EmptyStackException::~EmptyStackException() {
|
||||
}
|
||||
|
||||
//------------------ CancellationException -----------------------------------------------------------------------------
|
||||
|
||||
CancellationException::~CancellationException() {
|
||||
}
|
||||
|
||||
//------------------ ParseCancellationException ------------------------------------------------------------------------
|
||||
|
||||
ParseCancellationException::~ParseCancellationException() {
|
||||
}
|
||||
@ -1,99 +0,0 @@
|
||||
/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
||||
* Use of this file is governed by the BSD 3-clause license that
|
||||
* can be found in the LICENSE.txt file in the project root.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "antlr4-common.h"
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
// An exception hierarchy modelled loosely after java.lang.* exceptions.
|
||||
class ANTLR4CPP_PUBLIC RuntimeException : public std::exception {
|
||||
private:
|
||||
std::string _message;
|
||||
public:
|
||||
RuntimeException(const std::string &msg = "");
|
||||
|
||||
virtual const char* what() const noexcept override;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {
|
||||
public:
|
||||
IllegalStateException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
IllegalStateException(IllegalStateException const&) = default;
|
||||
~IllegalStateException();
|
||||
IllegalStateException& operator=(IllegalStateException const&) = default;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC IllegalArgumentException : public RuntimeException {
|
||||
public:
|
||||
IllegalArgumentException(IllegalArgumentException const&) = default;
|
||||
IllegalArgumentException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
~IllegalArgumentException();
|
||||
IllegalArgumentException& operator=(IllegalArgumentException const&) = default;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC NullPointerException : public RuntimeException {
|
||||
public:
|
||||
NullPointerException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
NullPointerException(NullPointerException const&) = default;
|
||||
~NullPointerException();
|
||||
NullPointerException& operator=(NullPointerException const&) = default;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC IndexOutOfBoundsException : public RuntimeException {
|
||||
public:
|
||||
IndexOutOfBoundsException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
IndexOutOfBoundsException(IndexOutOfBoundsException const&) = default;
|
||||
~IndexOutOfBoundsException();
|
||||
IndexOutOfBoundsException& operator=(IndexOutOfBoundsException const&) = default;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC UnsupportedOperationException : public RuntimeException {
|
||||
public:
|
||||
UnsupportedOperationException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
UnsupportedOperationException(UnsupportedOperationException const&) = default;
|
||||
~UnsupportedOperationException();
|
||||
UnsupportedOperationException& operator=(UnsupportedOperationException const&) = default;
|
||||
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC EmptyStackException : public RuntimeException {
|
||||
public:
|
||||
EmptyStackException(const std::string &msg = "") : RuntimeException(msg) {}
|
||||
EmptyStackException(EmptyStackException const&) = default;
|
||||
~EmptyStackException();
|
||||
EmptyStackException& operator=(EmptyStackException const&) = default;
|
||||
};
|
||||
|
||||
// IOException is not a runtime exception (in the java hierarchy).
|
||||
// Hence we have to duplicate the RuntimeException implementation.
|
||||
class ANTLR4CPP_PUBLIC IOException : public std::exception {
|
||||
private:
|
||||
std::string _message;
|
||||
|
||||
public:
|
||||
IOException(const std::string &msg = "");
|
||||
|
||||
virtual const char* what() const noexcept override;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {
|
||||
public:
|
||||
CancellationException(const std::string &msg = "") : IllegalStateException(msg) {}
|
||||
CancellationException(CancellationException const&) = default;
|
||||
~CancellationException();
|
||||
CancellationException& operator=(CancellationException const&) = default;
|
||||
};
|
||||
|
||||
class ANTLR4CPP_PUBLIC ParseCancellationException : public CancellationException {
|
||||
public:
|
||||
ParseCancellationException(const std::string &msg = "") : CancellationException(msg) {}
|
||||
ParseCancellationException(ParseCancellationException const&) = default;
|
||||
~ParseCancellationException();
|
||||
ParseCancellationException& operator=(ParseCancellationException const&) = default;
|
||||
};
|
||||
|
||||
} // namespace antlr4
|
||||
@ -1,57 +0,0 @@
|
||||
// Copyright 2012-2022 The ANTLR Project
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification, are permitted
|
||||
// provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
|
||||
// and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
|
||||
// conditions and the following disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
|
||||
// endorse or promote products derived from this software without specific prior written
|
||||
// permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
|
||||
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
|
||||
// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "antlr4-common.h"
|
||||
|
||||
#if ANTLR4CPP_USING_ABSEIL
|
||||
#include "absl/container/flat_hash_map.h"
|
||||
#else
|
||||
#include <unordered_map>
|
||||
#endif
|
||||
|
||||
// By default ANTLRv4 uses containers provided by the C++ standard library. In most deployments this
|
||||
// is fine, however in some using custom containers may be preferred. This header allows that by
|
||||
// optionally supporting some alternative implementations and allowing for more easier patching of
|
||||
// other alternatives.
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
#if ANTLR4CPP_USING_ABSEIL
|
||||
template <typename Key, typename Value,
|
||||
typename Hash = typename absl::flat_hash_map<Key, Value>::hasher,
|
||||
typename Equal = typename absl::flat_hash_map<Key, Value>::key_equal,
|
||||
typename Allocator = typename absl::flat_hash_map<Key, Value>::allocator_type>
|
||||
using FlatHashMap = absl::flat_hash_map<Key, Value, Hash, Equal, Allocator>;
|
||||
#else
|
||||
template <typename Key, typename Value,
|
||||
typename Hash = std::hash<Key>,
|
||||
typename Equal = std::equal_to<Key>,
|
||||
typename Allocator = std::allocator<std::pair<const Key, Value>>>
|
||||
using FlatHashMap = std::unordered_map<Key, Value, Hash, Equal, Allocator>;
|
||||
#endif
|
||||
|
||||
} // namespace antlr4
|
||||
@ -1,57 +0,0 @@
|
||||
// Copyright 2012-2022 The ANTLR Project
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification, are permitted
|
||||
// provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
|
||||
// and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
|
||||
// conditions and the following disclaimer in the documentation and/or other materials provided
|
||||
// with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
|
||||
// endorse or promote products derived from this software without specific prior written
|
||||
// permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
|
||||
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
|
||||
// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "antlr4-common.h"
|
||||
|
||||
#if ANTLR4CPP_USING_ABSEIL
|
||||
#include "absl/container/flat_hash_set.h"
|
||||
#else
|
||||
#include <unordered_set>
|
||||
#endif
|
||||
|
||||
// By default ANTLRv4 uses containers provided by the C++ standard library. In most deployments this
|
||||
// is fine, however in some using custom containers may be preferred. This header allows that by
|
||||
// optionally supporting some alternative implementations and allowing for more easier patching of
|
||||
// other alternatives.
|
||||
|
||||
namespace antlr4 {
|
||||
|
||||
#if ANTLR4CPP_USING_ABSEIL
|
||||
template <typename Key,
|
||||
typename Hash = typename absl::flat_hash_set<Key>::hasher,
|
||||
typename Equal = typename absl::flat_hash_set<Key>::key_equal,
|
||||
typename Allocator = typename absl::flat_hash_set<Key>::allocator_type>
|
||||
using FlatHashSet = absl::flat_hash_set<Key, Hash, Equal, Allocator>;
|
||||
#else
|
||||
template <typename Key,
|
||||
typename Hash = std::hash<Key>,
|
||||
typename Equal = std::equal_to<Key>,
|
||||
typename Allocator = std::allocator<Key>>
|
||||
using FlatHashSet = std::unordered_set<Key, Hash, Equal, Allocator>;
|
||||
#endif
|
||||
|
||||
} // namespace antlr4
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue