Подсчитать кол-во функций, параметров и операторов в исходном коде

import java.io.*;
import java.util.*;
 
public class InfoClass {
    private boolean isParse;
    private String path;
    private List<String> listFile;
    private List<String> operators;
    private List<Function> functions;
 
    public List<String> getOperators() {
        return operators;
    }
 
    public void setPath(String path) {
        if (path != null && !path.equals(this.path)) {
            this.path = path;
            this.isParse = false;
        }
    }
 
    InfoClass(String path) {
        this.path = path;
    }
 
 
    public void parseFile() {
        if (!this.isParse) {
            this.listFile = readFile(path);
            this.operators = countOperators();
            this.functions = getListFunctions();
            this.isParse = true;
        }
    }
 
    private List<String> readFile(String path) {
        File file = new File(path);
        List<String> list = new ArrayList<>();
        if (file.isFile()) {
            try (BufferedReader br = new BufferedReader(new FileReader(file))) {
                String line;
                while ((line = br.readLine()) != null) {
                    list.add(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
 
 
    private List<String> countOperators() {
        StringBuilder sb = new StringBuilder();
        List<String> operators = new ArrayList<>();
        for (String line : this.listFile) {
            line = line.replaceAll("[^-+/*=&!<>|]", " ").trim();
            if (line.length() > 0) {
                sb.append(line).append(" ");
            }
        }
        for (String operator : sb.toString().split("\\s+")) {
            if (operator.length() == 2 && (operator.equals("+=") || operator.equals("-="))) {
                operators.add(operator.substring(0, 1));
                operators.add(operator.substring(1, 2));
            } else {
                operators.add(operator);
            }
        }
        return operators;
    }
 
    private int getParameters() {
        int result = 0;
        for (Function function : this.functions) {
            result += function.getAttributes().size();
        }
        return result;
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (isParse) {
            sb.append("File [").append(this.path).append("]:").append("\n");
            sb.append("Operators: ").append(this.operators.size()).append("\n");
            sb.append("Functions: ").append(this.functions.size()).append("\n");
            sb.append("Parameters: ").append(getParameters()).append("\n");
            sb.append("Info:").append("\n");
            for (Function function : this.functions) {
                sb.append(function).append("\n");
            }
        } else {
            sb.append("The file is not parse. Use method parseFile().");
        }
        return sb.toString();
    }
 
    private List<String> getFunctions() {
        List<String> functions = new ArrayList<>();
        for (String line : this.listFile) {
            if (line.length() > 0 && line.matches(".+\\(.*\\)\\s*\\{")) {
                functions.add(line);
            }
        }
        return functions;
    }
 
    private List<Function> getListFunctions() {
        List<Function> list = new ArrayList<>();
        for (String line : getFunctions()) {
            Function function = parseStringToFunction(line);
            if (function != null) {
                list.add(function);
            }
        }
        return list;
    }
 
    private Function parseStringToFunction(String line) {
        Function function = null;
        if (line != null) {
            String parameters = line.replaceAll(".+\\((.*)\\)\\s*\\{", "$1");
            Map<String, String> attr = new HashMap<>();
            for (String str : parameters.split(",")) {
                str = str.trim();
                String[] p = str.split("\\s+");
                if (p.length == 2) {
                    attr.put(p[1], p[0]);
                }
            }
            String func = line.replaceAll("(.+)\\(.+", "$1").trim();
            String[] sign = func.split("\\s+");
            String name = null;
            String out = null;
            if (sign.length >= 2) {
                name = sign[sign.length - 1];
                out = sign[sign.length - 2];
                sign = Arrays.copyOf(sign, sign.length - 2);
            }
            function = new Function(sign, out, attr, name);
        }
        return function;
    }
 
    class Function {
        private String[] signature = new String[0];
        private String outputParameter;
        private Map<String, String> attributes;
        private String nameFunctions;
 
        public String[] getSignature() {
            return signature;
        }
 
        public String getOutputParameter() {
            return outputParameter;
        }
 
        public Map<String, String> getAttributes() {
            return attributes;
        }
 
        public String getNameFunctions() {
            return nameFunctions;
        }
 
        public Function(String[] signature, String outputParameter, Map<String, String> attributes, String nameFunctions) {
            this.signature = signature;
            this.outputParameter = outputParameter;
            this.attributes = attributes;
            this.nameFunctions = nameFunctions;
        }
 
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("Name: ").append(this.nameFunctions).append("\n");
            sb.append("Signature: ").append(Arrays.toString(this.signature)).append("\n");
            sb.append("Output: ").append(this.outputParameter).append("\n");
            sb.append("Input:").append("\n");
            for (Map.Entry<String, String> entry : this.attributes.entrySet()) {
                sb.append("   ");
                sb.append("NameVar: ").append(entry.getKey()).append("; Type: ").append(entry.getValue()).append(";\n");
            }
            return sb.toString();
        }
    }
}
 
class TestProgram {
    public static void main(String[] args) {
        InfoClass info = new InfoClass("Program.c");
        info.parseFile();
        System.out.println(info);
    }
}

File [Program.c]:
Operators: 21
Functions: 3
Parameters: 4
Info:
Name: DiziYazdir
Signature: []
Output: void
Input:
   NameVar: *p; Type: int;
   NameVar: uzunluk; Type: int;
 
Name: DiziTopla
Signature: []
Output: int
Input:
   NameVar: *p; Type: int;
   NameVar: uzunluk; Type: int;
 
Name: main
Signature: []
Output: int
Input:
 
 
 
Process finished with exit code 0

File [Program.c]:
Operators: 21
Functions: 1
Parameters: 2
Info:
Name: DiziTopla
Signature: []
Output: int
Input:
   NameVar: *p; Type: int;
   NameVar: uzunluk; Type: int;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class InformationClass {
    /**
     * Переменная, где хранится объект связи с файлом.
     */
    private File file;
 
    /**
     * Переменая хранит ссылку на объект ClassC.
     */
    private ClassC classC;
 
    /**
     * Переменная служит для того, чтоб если добавлен один и тот же файл для парсинга
     * класс не стал по новой его парсить. Или если файл не найден.
     */
    private boolean isParse;
 
    /**
     * Грубо говоря сеттер для переменной File.
     * Метод смотрит, является ли path - файлом
     * и не равен ли он прошлому файлу и если всё хорошо,
     * то присваиваем переменной File новый путь, а если файлне найден,
     * то выводим об этом в консоль сообщение.
     *
     * @param path - путь до файла;
     */
    public void setFile(String path) {
        File file = new File(path);
        if (fileIsExist(file)) {
            if (!file.equals(this.file)) {
                this.file = file;
                this.isParse = true;
            }
        } else {
            System.out.println("Неккоректный путь до файла...");
        }
    }
 
    /**
     * Конструктор для нашего класса.
     * Так же конструктор использует метод-сеттер setFile (см. выше).
     *
     * @param path - путь к файлу;
     */
    InformationClass(String path) {
        setFile(path);
    }
 
    /**
     * Метод преобразовывает файл в данные о классе.
     * Этот метод является гланым для запуска...
     * А после него можно и выводить информацию.
     */
    public void parseClass() {
        if (this.isParse) {
            this.classC = new ClassC(readFile(this.file));
            this.classC.parseClass();
            this.isParse = false;
        }
    }
 
    /**
     * Метод проверяет, что file не null, является файлом и существует.
     *
     * @param file - файл для проверки;
     * @return true или false;
     */
    private boolean fileIsExist(File file) {
        return file != null && file.isFile() && file.exists();
    }
 
    /**
     * Метод читает построчно файл и записывает его в List.
     *
     * @param file - файл длячтения;
     * @return list данных с файла;
     */
    private List<String> readFile(File file) {
        List<String> list = new ArrayList<>();
        if (file != null) {
            try (Scanner reader = new Scanner(file)) {
                while (reader.hasNextLine()) {
                    list.add(reader.nextLine());
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return list;
    }
 
    /**
     * Метод возвращает информацию о программе С++.
     *
     * @return информацию в виде строки;
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (this.file != null) {
            sb.append("#########################################################################################\n");
            sb.append("NameProgram: ").append(this.file.getName()).append("; [path = ")
                    .append(this.file.getAbsolutePath()).append("]:\n\n");
            if (this.classC != null) {
                sb.append(this.classC);
            }
            sb.append("#########################################################################################\n");
        }
        return sb.toString();
    }
 
    /**
     * Внутреннй класс ClassC - используется для хранния всех данных программы на С++.
     */
    class ClassC {
        /**
         * Массив, для хранения директив в классе С++.
         */
        private List<String> directive;
 
        /**
         * Лист всех функций в классе С++.
         */
        List<Function> functions;
 
        /**
         * Лист, который содержит весь код программы С++.
         */
        private final List<String> listProgram;
 
        /**
         * Стандартный конструктор для класса ClassC.
         */
        private ClassC(List<String> listProgram) {
            this.listProgram = listProgram;
            this.directive = new ArrayList<>();
            this.functions = new ArrayList<>();
        }
 
        /**
         * Метод проверяет, является ли строка объявлением директив в программе С++.
         *
         * @param line - строка для проверки;
         * @return true - является или если не является - false;
         */
        private boolean isInclude(String line) {
            return line != null && line.matches(".*#include.+");
        }
 
        /**
         * Метод парсит (удаляет лишнее и выбирает нужное) строку и добавляет директиву в лист директив.
         *
         * @param include - строка для парсинга;
         */
        private void addInclude(String include) {
            include = include != null ? include.replaceAll(".*#include\\s+<(.+)>.*", "$1") : "";
            if (!include.equals("")) {
                this.directive.add(include);
            }
        }
 
        /**
         * Метод проверяет, является ли строка объявлением функции.
         *
         * @param line - строка дляпроверки;
         * @return true или false;
         */
        private boolean isFunction(String line) {
            boolean result;
            if (result = line != null) {
                result = line.matches(".*\\(.*\\).*");
                if (result) {
                    result = line.trim().replaceAll("(.+)\\(.*\\).*", "$1")
                            .split("\\s+").length >= 2;
                }
            }
            return result;
        }
 
        /**
         * Метод парсит строку в объект Function.
         * он разбивает строку на параметры, типы и название.
         *
         * @param line - строка для преобразования в объект;
         * @return объект Function;
         */
        private Function addFunction(String line) {
            Function function = null;
            if (line != null) {
                String[] data = line.replaceAll("(.+)\\(.*\\).*", "$1").trim().split("\\s+");
                if (data.length >= 2) {
                    function = new Function(data[data.length - 1], data[data.length - 2]);
                    line = line.replaceAll(".+\\((.*)\\).*", "$1").trim();
                    if (line.length() > 0) {
                        String[] vars = line.split(",");
                        for (String str : vars) {
                            String[] var = str.trim().split("\\s+");
                            if (var.length == 2) {
                                function.addVariable(var[1], var[0]);
                            }
                        }
                    }
                    this.functions.add(function);
                }
            }
            return function;
        }
 
        /**
         * Метод парсит весь код на свойства программы (функции, директивы и т.д.).
         */
        private void parseClass() {
            int bracket = 0;
            Function function = null;
            List<String> codeFunction = new ArrayList<>();
            String temp = null;
            for (String line : this.listProgram) {
                if (line != null) {
                    if (!removeSpacesAndBrackets(line).equals("") && bracket == 0) {
                        if (isInclude(line)) {
                            addInclude(line);
                        } else {
                            temp = line;
                        }
                    }
                    bracket += getAmountOpenBracket(line);
                    if (bracket != 0 && temp != null) {
                        if (isFunction(temp)) {
                            function = addFunction(temp);
                        }
                        temp = null;
                    } else if (bracket != 0) {
                        codeFunction.add(line);
                    }
                    bracket -= getAmountCloseBracket(line);
                    if (bracket == 0 && codeFunction.size() > 0 && function != null) {
                        function.addTextFunction(codeFunction);
                        function = null;
                        codeFunction.clear();
                    }
                }
            }
        }
 
        /**
         * Метод удаляет из строки все пробелы и фигурные скобки.
         *
         * @param line - строка для работы метода;
         * @return строку без пробелов и скобок фигурных;
         */
        private String removeSpacesAndBrackets(String line) {
            return line != null ? line.trim().replaceAll("[{}]", "") : "";
        }
 
        /**
         * Метод возвращает кол-во открытых фигурных скобок в строке.
         *
         * @param line строка для поиска;
         * @return кол-во открытых фигурных скобок;
         */
        private int getAmountOpenBracket(String line) {
            return line != null ? line.length() - line.replaceAll("\\{", "").length() : 0;
        }
 
        /**
         * Метод возвращает кол-во закрытых фигурных скобок в строке.
         *
         * @param line строка для поиска;
         * @return кол-во закрытых фигурных скобок;
         */
        private int getAmountCloseBracket(String line) {
            return line != null ? line.length() - line.replaceAll("}", "").length() : 0;
        }
 
        /**
         * Метод возращает число, равное общему кол-ву параметров во всей программе.
         *
         * @return - общее кол-во параметров;
         */
        private int getShareParameters() {
            int result = 0;
            if (this.functions.size() != 0) {
                for (Function function : this.functions) {
                    result += function.getAmountVariables();
                }
            }
            return result;
        }
 
        /**
         * Метод возращает число, равное общему кол-ву операторов во всей программе.
         *
         * @return - общее кол-во операторов;
         */
        private int getShareOperators() {
            int result = 0;
            if (this.functions.size() != 0) {
                for (Function function : this.functions) {
                    result += function.getAmountOperators();
                }
            }
            return result;
        }
 
        /**
         * Метод возращает информацию о классе в виде строки.
         *
         * @return информация в виде строки;
         */
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            if (this.directive.size() != 0) {
                sb.append("Includes:   = ").append(this.directive.size()).append(";\n");
                for (String include : this.directive) {
                    sb.append("   ").append(include).append(";\n");
                }
            }
            if (this.functions.size() > 0) {
                sb.append("\nOperators:  ").append(getShareOperators()).append(";\n");
                sb.append("Parameters: ").append(getShareParameters()).append(";\n");
                sb.append("Functions: ").append(this.functions.size()).append(";\n\n");
 
                for (Function function : this.functions) {
                    sb.append(function).append("\n");
                }
            }
            return sb.toString();
        }
    }
 
    /**
     * Класс Function - применяется для хранения данных о функциях.
     */
    class Function {
        /**
         * Массив двойных операторов. Можно добавлять другие!
         */
        private final String[] TWO_OPERATORS = {"-=", "+=", "*=", "/="};
 
        /**
         * Переменная хранит имя функции.
         */
        private String name;
 
        /**
         * Лист всех переменных, передаваемых в функцию.
         */
        private List<Variable> variables;
 
        /**
         * Переменаая хранит возвращаемый тип из функции.
         */
        private String outputType;
 
        /**
         * Лист хранит весь код функции.
         */
        private List<String> text;
 
        /**
         * Конструктор для класса Function.
         *
         * @param name       - имя функции;
         * @param outputType - возвращаемый тип из функции (название);
         */
        Function(String name, String outputType) {
            this.name = name;
            this.outputType = outputType;
            this.variables = new ArrayList<>();
            this.text = new ArrayList<>();
        }
 
        /**
         * Метод добавляет переменную, переданную в функцию.
         *
         * @param name - имя переменной;
         * @param type - тип переменной;
         */
        private void addVariable(String name, String type) {
            if (name != null && type != null) {
                this.variables.add(new Variable(name, type));
            }
        }
 
        /**
         * Метод возвращает кол-во переменных, переданных в функцию.
         *
         * @return кол-во переменных;
         */
        private int getAmountVariables() {
            return this.variables.size();
        }
 
        /**
         * Метод добавляет код (текст) этой функции.
         *
         * @param list - лист кода функции;
         */
        private void addTextFunction(List<String> list) {
            if (list != null) {
                this.text = removeComments(list);
            }
        }
 
        /**
         * Метод удаляет из кода функции все комментарии.
         *
         * @param text - код функции;
         * @return лист (код) без комментариев;
         */
        private List<String> removeComments(List<String> text) {
            List<String> withoutComments = new ArrayList<>();
            if (text != null && text.size() > 0) {
                boolean fullComment = false;
                for (String line : text) {
                    if (!fullComment) {
                        int index = line.indexOf("/*");
                        if (index != -1) {
                            int last = line.indexOf("*/");
                            if (last != -1) {
                                line = line.substring(0, index) + line.substring(last, line.length()).trim();
                                if (line.length() > 0) {
                                    withoutComments.add(line);
                                }
                            } else {
                                fullComment = true;
                            }
                        } else {
                            index = line.indexOf("//");
                            if (index != -1) {
                                line = line.substring(0, index).trim();
                                if (line.length() > 0) {
                                    withoutComments.add(line);
                                }
                            } else {
                                withoutComments.add(line);
                            }
                        }
                    } else {
                        fullComment = !line.contains("*/");
                    }
                }
            }
            return withoutComments;
        }
 
        /**
         * Метод возращает массив всех операторов.
         *
         * @return массив операторов;
         */
        private String[] getArrayOperators() {
            StringBuilder sb = new StringBuilder();
            for (String line : this.text) {
                sb.append(line).append(" ");
            }
            String line = sb.toString().replaceAll("[^+-/*!<>=&|]", " ");
            line = line.replaceAll("[,.]", " ").trim();
            return line.split("\\s+");
        }
 
        /**
         * Методпроверяет, является ли оператор двойным или нет.
         *
         * @param operator - оператор для проверки;
         * @return является или нет (true, false);
         */
        private boolean isTwoOperator(String operator) {
            for (String two : TWO_OPERATORS) {
                if (two.equals(operator)) {
                    return true;
                }
            }
            return false;
        }
 
        /**
         * Метод возращает лист корректных операторов в коде функции.
         *
         * @param operators - массив всех операторов;
         * @return лист операторов;
         */
        private List<String> getCorrectOperators(String[] operators) {
            List<String> list = new ArrayList<>();
            for (String operator : operators) {
                if (operator.length() == 2) {
                    if (!operator.equals("<<") && !operator.equals(">>")) {
                        if (isTwoOperator(operator)) {
                            list.add(Character.toString(operator.charAt(0)));
                            list.add(Character.toString(operator.charAt(1)));
                        } else {
                            list.add(operator);
                        }
                    }
                } else if (operator.length() == 1) {
                    list.add(operator);
                }
            }
            return list;
        }
 
        /**
         * Метод возвращает кол-во операторов в функции.
         *
         * @return кол-во операторов;
         */
        private int getAmountOperators() {
            return getCorrectOperators(getArrayOperators()).size();
        }
 
        /**
         * Метод возвращает информацию по функции.
         *
         * @return информацию типа String;
         */
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("Name function: ").append(this.name).append(";\n");
            sb.append("Output type: ").append(this.outputType).append(";\n");
            if (this.variables.size() > 0) {
                sb.append("Input parameters: ").append(getAmountVariables()).append(";\n");
                for (Variable var : this.variables) {
                    sb.append("   ").append(var).append("\n");
                }
            }
            if (this.text.size() > 0) {
                sb.append("Operators: ").append(getAmountOperators()).append(";\n").append("   ");
                sb.append(Arrays.toString(getCorrectOperators(getArrayOperators()).toArray())).append("\n");
            }
            return sb.toString();
        }
 
        /**
         * Внутренний класс Variable - используется для переменных, которые
         * имеют имя и тип.
         */
        class Variable {
            /**
             * Переменная для хранения имени переменной.
             */
            private String name;
 
            /**
             * Переменная для хранения типа переенной.
             */
            private String type;
 
            /**
             * Конструктор для класса Variable.
             *
             * @param name - имя переменной;
             * @param type - тип переменной;
             */
            Variable(String name, String type) {
                this.name = name;
                this.type = type;
            }
 
            /**
             * Метод возвращает строку в виде name: a; type: int;.
             *
             * @return строку;
             */
            @Override
            public String toString() {
                return String.format("name: %s; type: %s;", this.name, this.type);
            }
        }
    }
}
 
class TestInformationClass {
    public static void main(String[] args) {
        InformationClass info = new InformationClass("Program.c");
        info.parseClass();
        System.out.println(info);
    }
}

#include "stdio.h"
#include "stdlib.h"
 
 
void DiziYazdir(int *p,int uzunluk){
   int i=0;  for(;i<uzunluk;i++)
   printf("%d ",p[i]); }
int DiziTopla(int *p,int uzunluk){
   int i=0;
   int toplam=0;
   for(;i<uzunluk;i++) toplam += p[i];
   return toplam;
   }
int main(){
   int x,y;
   printf("x:");
   scanf("%d",&x);
   printf("y:");
   scanf("%d",&y);
   int sonuc = x+y;
   printf("Sonuc:%d\n\n",sonuc);
   int *dizi = malloc(3*sizeof(int));
   dizi[0]=x;  dizi[1]=y;
   dizi[2]=sonuc;
   DiziYazdir(dizi,3);
   printf("\n\nToplam Deger:%d",DiziTopla(dizi,3));
   free(dizi);
   return 0;
   }

#########################################################################################
NameProgram: Program.c; [path = C:\project\lesson\Program.c]:
 
Includes:   = 2;
   #include "stdio.h";
   #include "stdlib.h";
 
Operators:  19;
Parameters: 4;
Functions: 3;
 
Name function: DiziYazdir;
Output type: void;
Input parameters: 2;
   name: *p; type: int;
   name: uzunluk; type: int;
Operators: 3;
   [=, <, ++]
 
Name function: DiziTopla;
Output type: int;
Input parameters: 2;
   name: *p; type: int;
   name: uzunluk; type: int;
Operators: 6;
   [=, =, <, ++, +, =]
 
Name function: main;
Output type: int;
Operators: 10;
   [&, &, =, +, *, =, *, =, =, =]
 
#########################################################################################
 
 
Process finished with exit code 0

#include <stdio.h> /* Стандартный заголовочный файл ввода-вывода */
#include <iostream> /* Библиотека (стандарт) */
#include <locale.h> /* Русификатор */
#include <windows.h> /* Русификатор */
using namespace std;
 
int main(int argc, char* argv[])
{
    setlocale(LC_CTYPE,"Russian");
    cout << "8  % 4  = " << 8 % 4  << endl; // выполнение операции "остаток от деления"
    cout << "7  % 4  = " << 7 % 4  << endl;
    cout << "2  % 4  = " << 2 % 4  << endl;
    cout << "43 % 10 = " << 43 % 10 << endl;
    system("pause");
    return 0;
}

#########################################################################################
NameProgram: Program2.c; [path = C:\project\lesson\Program2.c]:
 
Includes:   = 4;
   stdio.h;
   iostream;
   locale.h;
   windows.h;
 
Operators:  4;
Parameters: 2;
Functions: 1;
 
Name function: main;
Output type: int;
Input parameters: 2;
   name: argc; type: int;
   name: argv[]; type: char*;
Operators: 4;
   [=, =, =, =]
 
#########################################################################################
 
 
Process finished with exit code 0

#include <stdio.h> /* Стандартный заголовочный файл ввода-вывода */
#include <iostream> /* Библиотека (стандарт) */
#include <locale.h> /* Русификатор */
#include <windows.h> /* Русификатор */
using namespace std;
 
int main(int argc, char* argv[])
{
    setlocale(LC_CTYPE,"Russian");
    double plus, minus, pow, div; // объявление переменных через запятую
    double a1; // отдельное объявление переменной a1
    double a2; // отдельное объявление переменной a2
    cout << "Введите первое число: ";
    cin >> a1;
    cout << "Введите второе число: ";
    cin >> a2;
    plus  = a1 + a2;  // операция сложения
    minus = a1 - a2;  // операция вычитания
    pow  = a1 * a2;  // операция умножения
    div  = a1 / a2;  // операция деления
    /*
    sdfsf
    */
    cout << a1 << "+" << a2 << "=" << plus  << endl;
    cout << a1 << "-" << a2 << "=" << minus << endl;
    cout << a1 << "*" << a2 << "=" << pow  << endl;
    cout << a1 << "/" << a2 << "=" << div  << endl;
    system("pause");
    return 0;
}

#########################################################################################
NameProgram: Program3.c; [path = C:\project\lesson\Program3.c]:
 
Includes:   = 4;
   stdio.h;
   iostream;
   locale.h;
   windows.h;
 
Operators:  16;
Parameters: 2;
Functions: 1;
 
Name function: main;
Output type: int;
Input parameters: 2;
   name: argc; type: int;
   name: argv[]; type: char*;
Operators: 16;
   [=, +, =, -, =, *, =, /, +, =, -, =, *, =, /, =]
 
#########################################################################################
 
 
Process finished with exit code 0

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.antlr.v4.runtime.tree.TerminalNode;
 
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
 
public class Main {
    public static void main(String[] args) throws IOException {
        final CharStream charStream = CharStreams.fromFileName("program.c");
        final CLexer lexer = new CLexer(charStream);
        final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
 
        final CParser parser = new CParser(tokenStream);
        final ParseTree parseTree = parser.compilationUnit();
 
        final ParseTreeWalker walker = new ParseTreeWalker();
        final CListener listener = new CBaseListener() {
            private final Set<String> OPERATORS = new HashSet<String>(Arrays.asList("<", "<=", ">", ">=", "<<", ">>",
                    "+", "++", "-", "--", "*", "/", "%",
                    "&", "|", "&&", "||", "^", "!", "~",
                    "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
                    "==", "!="));
 
            private int operators;
            private int parameters;
            private int functions;
 
            @Override
            public void enterFunctionDefinition(final CParser.FunctionDefinitionContext ctx) {
                final CParser.ParameterTypeListContext parameterTypeList = ctx.declarator().directDeclarator().parameterTypeList();
                if (parameterTypeList != null) {
                    parameters += parameterTypeList.parameterList().getText().split(",").length;
                }
                functions++;
            }
 
            @Override
            public void visitTerminal(final TerminalNode node) {
                final String text = node.getText();
                if (OPERATORS.contains(text)) {
                    operators += Math.min(2, text.length());
                }
            }
 
            @Override
            public String toString() {
                return "Operators = " + operators + "\n" +
                        "Parameters = " + parameters + "\n" +
                        "Functions = " + functions;
            }
        };
 
        walker.walk(listener, parseTree);
        System.out.println(listener);
    }
}

/*
 [The "BSD licence"]
 Copyright (c) 2013 Sam Harwell
 All rights reserved.
 
 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. The name of the author may not be used to endorse or promote products
    derived from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
/** C 2011 grammar built from the C11 Spec */
grammar C;
 
primaryExpression
    :   Identifier
    |   Constant
    |   StringLiteral+
    |   '(' expression ')'
    |   genericSelection
    |   '__extension__'? '(' compoundStatement ')' // Blocks (GCC extension)
    |   '__builtin_va_arg' '(' unaryExpression ',' typeName ')'
    |   '__builtin_offsetof' '(' typeName ',' unaryExpression ')'
    ;
 
genericSelection
    :   '_Generic' '(' assignmentExpression ',' genericAssocList ')'
    ;
 
genericAssocList
    :   genericAssociation
    |   genericAssocList ',' genericAssociation
    ;
 
genericAssociation
    :   typeName ':' assignmentExpression
    |   'default' ':' assignmentExpression
    ;
 
postfixExpression
    :   primaryExpression
    |   postfixExpression '[' expression ']'
    |   postfixExpression '(' argumentExpressionList? ')'
    |   postfixExpression '.' Identifier
    |   postfixExpression '->' Identifier
    |   postfixExpression '++'
    |   postfixExpression '--'
    |   '(' typeName ')' '{' initializerList '}'
    |   '(' typeName ')' '{' initializerList ',' '}'
    |   '__extension__' '(' typeName ')' '{' initializerList '}'
    |   '__extension__' '(' typeName ')' '{' initializerList ',' '}'
    ;
 
argumentExpressionList
    :   assignmentExpression
    |   argumentExpressionList ',' assignmentExpression
    ;
 
unaryExpression
    :   postfixExpression
    |   '++' unaryExpression
    |   '--' unaryExpression
    |   unaryOperator castExpression
    |   'sizeof' unaryExpression
    |   'sizeof' '(' typeName ')'
    |   '_Alignof' '(' typeName ')'
    |   '&&' Identifier // GCC extension address of label
    ;
 
unaryOperator
    :   '&' | '*' | '+' | '-' | '~' | '!'
    ;
 
castExpression
    :   '(' typeName ')' castExpression
    |   '__extension__' '(' typeName ')' castExpression
    |   unaryExpression
    |   DigitSequence // for
    ;
 
multiplicativeExpression
    :   castExpression
    |   multiplicativeExpression '*' castExpression
    |   multiplicativeExpression '/' castExpression
    |   multiplicativeExpression '%' castExpression
    ;
 
additiveExpression
    :   multiplicativeExpression
    |   additiveExpression '+' multiplicativeExpression
    |   additiveExpression '-' multiplicativeExpression
    ;
 
shiftExpression
    :   additiveExpression
    |   shiftExpression '<<' additiveExpression
    |   shiftExpression '>>' additiveExpression
    ;
 
relationalExpression
    :   shiftExpression
    |   relationalExpression '<' shiftExpression
    |   relationalExpression '>' shiftExpression
    |   relationalExpression '<=' shiftExpression
    |   relationalExpression '>=' shiftExpression
    ;
 
equalityExpression
    :   relationalExpression
    |   equalityExpression '==' relationalExpression
    |   equalityExpression '!=' relationalExpression
    ;
 
andExpression
    :   equalityExpression
    |   andExpression '&' equalityExpression
    ;
 
exclusiveOrExpression
    :   andExpression
    |   exclusiveOrExpression '^' andExpression
    ;
 
inclusiveOrExpression
    :   exclusiveOrExpression
    |   inclusiveOrExpression '|' exclusiveOrExpression
    ;
 
logicalAndExpression
    :   inclusiveOrExpression
    |   logicalAndExpression '&&' inclusiveOrExpression
    ;
 
logicalOrExpression
    :   logicalAndExpression
    |   logicalOrExpression '||' logicalAndExpression
    ;
 
conditionalExpression
    :   logicalOrExpression ('?' expression ':' conditionalExpression)?
    ;
 
assignmentExpression
    :   conditionalExpression
    |   unaryExpression assignmentOperator assignmentExpression
    |   DigitSequence // for
    ;
 
assignmentOperator
    :   '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|='
    ;
 
expression
    :   assignmentExpression
    |   expression ',' assignmentExpression
    ;
 
constantExpression
    :   conditionalExpression
    ;
 
declaration
    :   declarationSpecifiers initDeclaratorList ';'
    |   declarationSpecifiers ';'
    |   staticAssertDeclaration
    ;
 
declarationSpecifiers
    :   declarationSpecifier+
    ;
 
declarationSpecifiers2
    :   declarationSpecifier+
    ;
 
declarationSpecifier
    :   storageClassSpecifier
    |   typeSpecifier
    |   typeQualifier
    |   functionSpecifier
    |   alignmentSpecifier
    ;
 
initDeclaratorList
    :   initDeclarator
    |   initDeclaratorList ',' initDeclarator
    ;
 
initDeclarator
    :   declarator
    |   declarator '=' initializer
    ;
 
storageClassSpecifier
    :   'typedef'
    |   'extern'
    |   'static'
    |   '_Thread_local'
    |   'auto'
    |   'register'
    ;
 
typeSpecifier
    :   ('void'
    |   'char'
    |   'short'
    |   'int'
    |   'long'
    |   'float'
    |   'double'
    |   'signed'
    |   'unsigned'
    |   '_Bool'
    |   '_Complex'
    |   '__m128'
    |   '__m128d'
    |   '__m128i')
    |   '__extension__' '(' ('__m128' | '__m128d' | '__m128i') ')'
    |   atomicTypeSpecifier
    |   structOrUnionSpecifier
    |   enumSpecifier
    |   typedefName
    |   '__typeof__' '(' constantExpression ')' // GCC extension
    |   typeSpecifier pointer
    ;
 
structOrUnionSpecifier
    :   structOrUnion Identifier? '{' structDeclarationList '}'
    |   structOrUnion Identifier
    ;
 
structOrUnion
    :   'struct'
    |   'union'
    ;
 
structDeclarationList
    :   structDeclaration
    |   structDeclarationList structDeclaration
    ;
 
structDeclaration
    :   specifierQualifierList structDeclaratorList? ';'
    |   staticAssertDeclaration
    ;
 
specifierQualifierList
    :   typeSpecifier specifierQualifierList?
    |   typeQualifier specifierQualifierList?
    ;
 
structDeclaratorList
    :   structDeclarator
    |   structDeclaratorList ',' structDeclarator
    ;
 
structDeclarator
    :   declarator
    |   declarator? ':' constantExpression
    ;
 
enumSpecifier
    :   'enum' Identifier? '{' enumeratorList '}'
    |   'enum' Identifier? '{' enumeratorList ',' '}'
    |   'enum' Identifier
    ;
 
enumeratorList
    :   enumerator
    |   enumeratorList ',' enumerator
    ;
 
enumerator
    :   enumerationConstant
    |   enumerationConstant '=' constantExpression
    ;
 
enumerationConstant
    :   Identifier
    ;
 
atomicTypeSpecifier
    :   '_Atomic' '(' typeName ')'
    ;
 
typeQualifier
    :   'const'
    |   'restrict'
    |   'volatile'
    |   '_Atomic'
    ;
 
functionSpecifier
    :   ('inline'
    |   '_Noreturn'
    |   '__inline__' // GCC extension
    |   '__stdcall')
    |   gccAttributeSpecifier
    |   '__declspec' '(' Identifier ')'
    ;
 
alignmentSpecifier
    :   '_Alignas' '(' typeName ')'
    |   '_Alignas' '(' constantExpression ')'
    ;
 
declarator
    :   pointer? directDeclarator gccDeclaratorExtension*
    ;
 
directDeclarator
    :   Identifier
    |   '(' declarator ')'
    |   directDeclarator '[' typeQualifierList? assignmentExpression? ']'
    |   directDeclarator '[' 'static' typeQualifierList? assignmentExpression ']'
    |   directDeclarator '[' typeQualifierList 'static' assignmentExpression ']'
    |   directDeclarator '[' typeQualifierList? '*' ']'
    |   directDeclarator '(' parameterTypeList ')'
    |   directDeclarator '(' identifierList? ')'
    |   Identifier ':' DigitSequence  // bit field
    |   '(' typeSpecifier? pointer directDeclarator ')' // function pointer like: (__cdecl *f)
    ;
 
gccDeclaratorExtension
    :   '__asm' '(' StringLiteral+ ')'
    |   gccAttributeSpecifier
    ;
 
gccAttributeSpecifier
    :   '__attribute__' '(' '(' gccAttributeList ')' ')'
    ;
 
gccAttributeList
    :   gccAttribute (',' gccAttribute)*
    |   // empty
    ;
 
gccAttribute
    :   ~(',' | '(' | ')') // relaxed def for "identifier or reserved word"
        ('(' argumentExpressionList? ')')?
    |   // empty
    ;
 
nestedParenthesesBlock
    :   (   ~('(' | ')')
        |   '(' nestedParenthesesBlock ')'
        )*
    ;
 
pointer
    :   '*' typeQualifierList?
    |   '*' typeQualifierList? pointer
    |   '^' typeQualifierList? // Blocks language extension
    |   '^' typeQualifierList? pointer // Blocks language extension
    ;
 
typeQualifierList
    :   typeQualifier
    |   typeQualifierList typeQualifier
    ;
 
parameterTypeList
    :   parameterList
    |   parameterList ',' '...'
    ;
 
parameterList
    :   parameterDeclaration
    |   parameterList ',' parameterDeclaration
    ;
 
parameterDeclaration
    :   declarationSpecifiers declarator
    |   declarationSpecifiers2 abstractDeclarator?
    ;
 
identifierList
    :   Identifier
    |   identifierList ',' Identifier
    ;
 
typeName
    :   specifierQualifierList abstractDeclarator?
    ;
 
abstractDeclarator
    :   pointer
    |   pointer? directAbstractDeclarator gccDeclaratorExtension*
    ;
 
directAbstractDeclarator
    :   '(' abstractDeclarator ')' gccDeclaratorExtension*
    |   '[' typeQualifierList? assignmentExpression? ']'
    |   '[' 'static' typeQualifierList? assignmentExpression ']'
    |   '[' typeQualifierList 'static' assignmentExpression ']'
    |   '[' '*' ']'
    |   '(' parameterTypeList? ')' gccDeclaratorExtension*
    |   directAbstractDeclarator '[' typeQualifierList? assignmentExpression? ']'
    |   directAbstractDeclarator '[' 'static' typeQualifierList? assignmentExpression ']'
    |   directAbstractDeclarator '[' typeQualifierList 'static' assignmentExpression ']'
    |   directAbstractDeclarator '[' '*' ']'
    |   directAbstractDeclarator '(' parameterTypeList? ')' gccDeclaratorExtension*
    ;
 
typedefName
    :   Identifier
    ;
 
initializer
    :   assignmentExpression
    |   '{' initializerList '}'
    |   '{' initializerList ',' '}'
    ;
 
initializerList
    :   designation? initializer
    |   initializerList ',' designation? initializer
    ;
 
designation
    :   designatorList '='
    ;
 
designatorList
    :   designator
    |   designatorList designator
    ;
 
designator
    :   '[' constantExpression ']'
    |   '.' Identifier
    ;
 
staticAssertDeclaration
    :   '_Static_assert' '(' constantExpression ',' StringLiteral+ ')' ';'
    ;
 
statement
    :   labeledStatement
    |   compoundStatement
    |   expressionStatement
    |   selectionStatement
    |   iterationStatement
    |   jumpStatement
    |   ('__asm' | '__asm__') ('volatile' | '__volatile__') '(' (logicalOrExpression (',' logicalOrExpression)*)? (':' (logicalOrExpression (',' logicalOrExpression)*)?)* ')' ';'
    ;
 
labeledStatement
    :   Identifier ':' statement
    |   'case' constantExpression ':' statement
    |   'default' ':' statement
    ;
 
compoundStatement
    :   '{' blockItemList? '}'
    ;
 
blockItemList
    :   blockItem
    |   blockItemList blockItem
    ;
 
blockItem
    :   statement
    |   declaration
    ;
 
expressionStatement
    :   expression? ';'
    ;
 
selectionStatement
    :   'if' '(' expression ')' statement ('else' statement)?
    |   'switch' '(' expression ')' statement
    ;
 
iterationStatement
    :   While '(' expression ')' statement
    |   Do statement While '(' expression ')' ';'
    |   For '(' forCondition ')' statement
    ;
 
//    |   'for' '(' expression? ';' expression?  ';' forUpdate? ')' statement
//    |   For '(' declaration  expression? ';' expression? ')' statement
 
forCondition
    :   forDeclaration ';' forExpression? ';' forExpression?
    |   expression? ';' forExpression? ';' forExpression?
    ;
 
forDeclaration
    :   declarationSpecifiers initDeclaratorList
    |   declarationSpecifiers
    ;
 
forExpression
    :   assignmentExpression
    |   forExpression ',' assignmentExpression
    ;
 
jumpStatement
    :   'goto' Identifier ';'
    |   'continue' ';'
    |   'break' ';'
    |   'return' expression? ';'
    |   'goto' unaryExpression ';' // GCC extension
    ;
 
compilationUnit
    :   translationUnit? EOF
    ;
 
translationUnit
    :   externalDeclaration
    |   translationUnit externalDeclaration
    ;
 
externalDeclaration
    :   functionDefinition
    |   declaration
    |   ';' // stray ;
    ;
 
functionDefinition
    :   declarationSpecifiers? declarator declarationList? compoundStatement
    ;
 
declarationList
    :   declaration
    |   declarationList declaration
    ;
 
Auto : 'auto';
Break : 'break';
Case : 'case';
Char : 'char';
Const : 'const';
Continue : 'continue';
Default : 'default';
Do : 'do';
Double : 'double';
Else : 'else';
Enum : 'enum';
Extern : 'extern';
Float : 'float';
For : 'for';
Goto : 'goto';
If : 'if';
Inline : 'inline';
Int : 'int';
Long : 'long';
Register : 'register';
Restrict : 'restrict';
Return : 'return';
Short : 'short';
Signed : 'signed';
Sizeof : 'sizeof';
Static : 'static';
Struct : 'struct';
Switch : 'switch';
Typedef : 'typedef';
Union : 'union';
Unsigned : 'unsigned';
Void : 'void';
Volatile : 'volatile';
While : 'while';
 
Alignas : '_Alignas';
Alignof : '_Alignof';
Atomic : '_Atomic';
Bool : '_Bool';
Complex : '_Complex';
Generic : '_Generic';
Imaginary : '_Imaginary';
Noreturn : '_Noreturn';
StaticAssert : '_Static_assert';
ThreadLocal : '_Thread_local';
 
LeftParen : '(';
RightParen : ')';
LeftBracket : '[';
RightBracket : ']';
LeftBrace : '{';
RightBrace : '}';
 
Less : '<';
LessEqual : '<=';
Greater : '>';
GreaterEqual : '>=';
LeftShift : '<<';
RightShift : '>>';
 
Plus : '+';
PlusPlus : '++';
Minus : '-';
MinusMinus : '--';
Star : '*';
Div : '/';
Mod : '%';
 
And : '&';
Or : '|';
AndAnd : '&&';
OrOr : '||';
Caret : '^';
Not : '!';
Tilde : '~';
 
Question : '?';
Colon : ':';
Semi : ';';
Comma : ',';
 
Assign : '=';
// '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '&=' | '^=' | '|='
StarAssign : '*=';
DivAssign : '/=';
ModAssign : '%=';
PlusAssign : '+=';
MinusAssign : '-=';
LeftShiftAssign : '<<=';
RightShiftAssign : '>>=';
AndAssign : '&=';
XorAssign : '^=';
OrAssign : '|=';
 
Equal : '==';
NotEqual : '!=';
 
Arrow : '->';
Dot : '.';
Ellipsis : '...';
 
Identifier
    :   IdentifierNondigit
        (   IdentifierNondigit
        |   Digit
        )*
    ;
 
fragment
IdentifierNondigit
    :   Nondigit
    |   UniversalCharacterName
    //|   // other implementation-defined characters...
    ;
 
fragment
Nondigit
    :   [a-zA-Z_]
    ;
 
fragment
Digit
    :   [0-9]
    ;
 
fragment
UniversalCharacterName
    :   '\\u' HexQuad
    |   '\\U' HexQuad HexQuad
    ;
 
fragment
HexQuad
    :   HexadecimalDigit HexadecimalDigit HexadecimalDigit HexadecimalDigit
    ;
 
Constant
    :   IntegerConstant
    |   FloatingConstant
    //|   EnumerationConstant
    |   CharacterConstant
    ;
 
fragment
IntegerConstant
    :   DecimalConstant IntegerSuffix?
    |   OctalConstant IntegerSuffix?
    |   HexadecimalConstant IntegerSuffix?
    |   BinaryConstant
    ;
 
fragment
BinaryConstant
    :   '0' [bB] [0-1]+
    ;
 
fragment
DecimalConstant
    :   NonzeroDigit Digit*
    ;
 
fragment
OctalConstant
    :   '0' OctalDigit*
    ;
 
fragment
HexadecimalConstant
    :   HexadecimalPrefix HexadecimalDigit+
    ;
 
fragment
HexadecimalPrefix
    :   '0' [xX]
    ;
 
fragment
NonzeroDigit
    :   [1-9]
    ;
 
fragment
OctalDigit
    :   [0-7]
    ;
 
fragment
HexadecimalDigit
    :   [0-9a-fA-F]
    ;
 
fragment
IntegerSuffix
    :   UnsignedSuffix LongSuffix?
    |   UnsignedSuffix LongLongSuffix
    |   LongSuffix UnsignedSuffix?
    |   LongLongSuffix UnsignedSuffix?
    ;
 
fragment
UnsignedSuffix
    :   [uU]
    ;
 
fragment
LongSuffix
    :   [lL]
    ;
 
fragment
LongLongSuffix
    :   'll' | 'LL'
    ;
 
fragment
FloatingConstant
    :   DecimalFloatingConstant
    |   HexadecimalFloatingConstant
    ;
 
fragment
DecimalFloatingConstant
    :   FractionalConstant ExponentPart? FloatingSuffix?
    |   DigitSequence ExponentPart FloatingSuffix?
    ;
 
fragment
HexadecimalFloatingConstant
    :   HexadecimalPrefix HexadecimalFractionalConstant BinaryExponentPart FloatingSuffix?
    |   HexadecimalPrefix HexadecimalDigitSequence BinaryExponentPart FloatingSuffix?
    ;
 
fragment
FractionalConstant
    :   DigitSequence? '.' DigitSequence
    |   DigitSequence '.'
    ;
 
fragment
ExponentPart
    :   'e' Sign? DigitSequence
    |   'E' Sign? DigitSequence
    ;
 
fragment
Sign
    :   '+' | '-'
    ;
 
DigitSequence
    :   Digit+
    ;
 
fragment
HexadecimalFractionalConstant
    :   HexadecimalDigitSequence? '.' HexadecimalDigitSequence
    |   HexadecimalDigitSequence '.'
    ;
 
fragment
BinaryExponentPart
    :   'p' Sign? DigitSequence
    |   'P' Sign? DigitSequence
    ;
 
fragment
HexadecimalDigitSequence
    :   HexadecimalDigit+
    ;
 
fragment
FloatingSuffix
    :   'f' | 'l' | 'F' | 'L'
    ;
 
fragment
CharacterConstant
    :   '\'' CCharSequence '\''
    |   'L\'' CCharSequence '\''
    |   'u\'' CCharSequence '\''
    |   'U\'' CCharSequence '\''
    ;
 
fragment
CCharSequence
    :   CChar+
    ;
 
fragment
CChar
    :   ~['\\\r\n]
    |   EscapeSequence
    ;
 
fragment
EscapeSequence
    :   SimpleEscapeSequence
    |   OctalEscapeSequence
    |   HexadecimalEscapeSequence
    |   UniversalCharacterName
    ;
 
fragment
SimpleEscapeSequence
    :   '\\' ['"?abfnrtv\\]
    ;
 
fragment
OctalEscapeSequence
    :   '\\' OctalDigit
    |   '\\' OctalDigit OctalDigit
    |   '\\' OctalDigit OctalDigit OctalDigit
    ;
 
fragment
HexadecimalEscapeSequence
    :   '\\x' HexadecimalDigit+
    ;
 
StringLiteral
    :   EncodingPrefix? '"' SCharSequence? '"'
    ;
 
fragment
EncodingPrefix
    :   'u8'
    |   'u'
    |   'U'
    |   'L'
    ;
 
fragment
SCharSequence
    :   SChar+
    ;
 
fragment
SChar
    :   ~["\\\r\n]
    |   EscapeSequence
    |   '\\\n'   // Added line
    |   '\\\r\n' // Added line
    ;
 
ComplexDefine
    :   '#' Whitespace? 'define'  ~[#]*
        -> skip
    ;
         
// ignore the following asm blocks:
/*
    asm
    {
        mfspr x, 286;
    }
 */
AsmBlock
    :   'asm' ~'{'* '{' ~'}'* '}'
    -> skip
    ;
    
// ignore the lines generated by c preprocessor                                   
// sample line : '#line 1 "/home/dm/files/dk1.h" 1'                           
LineAfterPreprocessing
    :   '#line' Whitespace* ~[\r\n]*
        -> skip
    ;  
 
LineDirective
    :   '#' Whitespace? DecimalConstant Whitespace? StringLiteral ~[\r\n]*
        -> skip
    ;
 
PragmaDirective
    :   '#' Whitespace? 'pragma' Whitespace ~[\r\n]*
        -> skip
    ;
 
Whitespace
    :   [ \t]+
        -> skip
    ;
 
Newline
    :   (   '\r' '\n'?
        |   '\n'
        )
        -> skip
    ;
 
BlockComment
    :   '/*' .*? '*/'
        -> skip
    ;
 
LineComment
    :   '//' ~[\r\n]*
        -> skip
    ;

Operators = 23
Parameters = 4
Functions = 3

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.antlr.v4.runtime.tree.TerminalNode;
 
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
 
public class Main {
    public static void main(String[] args) throws IOException {
        final CharStream charStream = CharStreams.fromFileName("program.c");
        final CLexer lexer = new CLexer(charStream);
        final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
 
        final CParser parser = new CParser(tokenStream);
        final ParseTree parseTree = parser.compilationUnit();
 
        final ParseTreeWalker walker = new ParseTreeWalker();
        final CListener listener = new CBaseListener() {
            private final Set<String> OPERATORS = new HashSet<String>(Arrays.asList("<", "<=", ">", ">=", "<<", ">>",
                    "+", "++", "-", "--", "*", "/", "%",
                    "&", "|", "&&", "||", "^", "!", "~",
                    "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
                    "==", "!="));
            private final Set<String> DOUBLE_OPERATORS = new HashSet<String>(Arrays.asList("*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="));
 
            private int operators;
            private int parameters;
            private int functions;
 
            @Override
            public void enterFunctionDefinition(final CParser.FunctionDefinitionContext ctx) {
                final CParser.ParameterTypeListContext parameterTypeList = ctx.declarator().directDeclarator().parameterTypeList();
                if (parameterTypeList != null) {
                    parameters += parameterTypeList.parameterList().getText().split(",").length;
                }
                functions++;
            }
 
            @Override
            public void visitTerminal(final TerminalNode node) {
                final String text = node.getText();
                if (OPERATORS.contains(text)) {
                    operators += (DOUBLE_OPERATORS.contains(text) ? 2 : 1);
                }
            }
            
            @Override
            public String toString() {
                return "Operators = " + operators + "\n" +
                        "Parameters = " + parameters + "\n" +
                        "Functions = " + functions;
            }
        };
 
        walker.walk(listener, parseTree);
        System.out.println(listener);
    }
}

Operators = 21
Parameters = 4
Functions = 3

import org.antlr.v4.runtime.CharStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.antlr.v4.runtime.tree.TerminalNode;
 
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
 
public class Main {
    public static void main(String[] args) throws IOException {
        final CharStream charStream = CharStreams.fromFileName("program.c");
        final CLexer lexer = new CLexer(charStream);
        final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
 
        final CParser parser = new CParser(tokenStream);
        final ParseTree parseTree = parser.compilationUnit();
 
        final ParseTreeWalker walker = new ParseTreeWalker();
        final CListener listener = new CBaseListener() {
            private final Set<String> OPERATORS = new HashSet<String>(Arrays.asList("<", "<=", ">", ">=", "<<", ">>",
                    "+", "++", "-", "--", "*", "/", "%",
                    "&", "|", "&&", "||", "^", "!", "~",
                    "=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|=",
                    "==", "!="));
            private final Set<String> DOUBLE_OPERATORS = new HashSet<String>(Arrays.asList("*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="));
 
            private int operators;
            private int parameters;
            private int functions;
 
            @Override
            public void enterFunctionDefinition(final CParser.FunctionDefinitionContext ctx) {
                final CParser.ParameterTypeListContext parameterTypeList = ctx.declarator().directDeclarator().parameterTypeList();
                if (parameterTypeList != null) {
                    parameters += parameterTypeList.parameterList().getText().split(",").length;
                }
                functions++;
            }
 
            @Override
            public void visitTerminal(final TerminalNode node) {
                final String text = node.getText();
                if (OPERATORS.contains(text)) {
                    operators += (DOUBLE_OPERATORS.contains(text) ? 2 : 1);
                }
            }
 
            @Override
            public void enterPointer(CParser.PointerContext ctx) {
                operators--;
            }
 
            @Override
            public String toString() {
                return "Operators = " + operators + "\n" +
                        "Parameters = " + parameters + "\n" +
                        "Functions = " + functions;
            }
        };
 
        walker.walk(listener, parseTree);
        System.out.println(listener);
    }
}

Operators = 18
Parameters = 4
Functions = 3