Пример #1
0
        static void Main(string[] args)
        {
            StreamReader      r      = new StreamReader(args[0]);
            AntlrInputStream  ar     = new AntlrInputStream(r);
            CSVLexer          lexer  = new CSVLexer(ar);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            CSVParser         parser = new CSVParser(tokens);
            IParseTree        tree   = parser.compileUnit();

            Console.WriteLine(tree.ToStringTree());
        }
Пример #2
0
        string[]  parse(string text)
        {
            AntlrInputStream  inputStream       = new AntlrInputStream(text);
            CSVLexer          lexer             = new CSVLexer(inputStream);
            CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
            CSVParser         parser            = new CSVParser(commonTokenStream);

            CSVParser.CsvFileContext csvCtx = parser.csvFile();
            CsvFileVisitor           v      = new CsvFileVisitor();

            return(v.getValues(csvCtx));
        }
        public DataItem FromFile(Stream dataFile)
        {
            ICharStream         chars             = CharStreams.fromStream(dataFile);
            CSVLexer            csvLexer          = new CSVLexer(chars);
            CommonTokenStream   commonTokenStream = new CommonTokenStream(csvLexer);
            CSVParser           csvParser         = new CSVParser(commonTokenStream);
            CSVConverterVisitor visitor           = new CSVConverterVisitor();

            try {
                return(visitor.VisitCsv(csvParser.csv()));
            }
            catch {
                return(new DataItem());
            }
        }
 public static void Run()  //This one is overkill, but in a real application it would be far more useful, because it can be expanded more easily, and gives useful tokens which you can work with
 {
     for (string input = Console.ReadLine(); input != "#"; input = Console.ReadLine())
     {
         var   lexer  = new CSVLexer(input);
         Token t      = lexer.GetNextToken();
         var   tokens = new List <Token>();
         while (t.type != TokenType.EOF)
         {
             tokens.Add(t);
             Console.WriteLine(t);
             t = lexer.GetNextToken();
         }
         Console.WriteLine(string.Join(';', tokens));
     }
 }
Пример #5
0
    static void Main(string[] args)
    {
        var input = File.ReadAllText(args[0]);

        var charStream = CharStreams.fromstring(input);
        var lexer      = new CSVLexer(charStream);
        var tokens     = new CommonTokenStream(lexer);

        var parser   = new CSVParser(tokens);
        var walker   = new ParseTreeWalker();
        var listener = new CsvListener();

        walker.Walk(listener, parser.csvFile());

        foreach (var rec in listener.Records)
        {
            foreach (var header in listener.Header)
            {
                Console.WriteLine($"{header}: {rec[header]}");
            }
            Console.WriteLine();
        }
    }
Пример #6
0
        public string Clean(string Parametri)
        {
            var result     = string.Empty;
            var parameters = Parametri.Split('§');

            if (parameters.Length == 0)
            {
                return("-ER - È necessario specificare il path del file csv");
            }

            //la funzione si aspetta in input il path del file seguito dal carattere § e il separatore del file CSV (di default è ;)
            string filename = Parametri.Split('§')[0];

            if (parameters.Length == 2)
            {
                //not implemented - per il momento utilizza solo il punto e virgola
                string separator = Parametri.Split('§')[1];
                result = @"-WG - La funzionalità di scelta del carattere separatore non è implementata. 
    Il separatore di Default è il punto e virgola";
            }

            try
            {
                var file = File.ReadAllText(filename);

                AntlrInputStream  inputStream = new AntlrInputStream(file);
                CSVLexer          lex         = new CSVLexer(inputStream);
                CommonTokenStream TokenStream = new CommonTokenStream(lex);
                CSVParser         par         = new CSVParser(TokenStream);

                CSVErrorListener el = new CSVErrorListener();
                par.RemoveErrorListeners();
                par.AddErrorListener(el);

                var csvContext = par.csvFile();

                if (el.SyntaxErrorsList.Count > 0)
                {
                    result += @"-ER - Nel file csv sono presenti righe con più colonne rispetto all'intestazione:
Righe Errate  ";
                    foreach (var se in el.SyntaxErrorsList)
                    {
                        result += se.Line + ", ";
                    }
                    result  = result.Remove(result.Length - 2);
                    result += "\n";
                    return(result);
                }

                CSVCleanerListener listener = new CSVCleanerListener(TokenStream);
                ParseTreeWalker    walker   = new ParseTreeWalker();
                walker.Walk(listener, csvContext);

                if (listener.shortRows)
                {
                    result += @"-ER - Nel file csv sono presenti righe con meno colonne rispetto all'intestazione\n";
                }

                if (listener.LogRows.Count != 0)
                {
                    result += @"-WG - Il file contiene righe vuote in fondo e/o separatori in eccesso a fine riga";
                    foreach (var row in listener.LogRows)
                    {
                        result += "\nRiga " + row.Key + " - " + row.Value;
                    }
                }

                //se non ci sono errori bloccanti sovrascrivo il file "pulito"
                if (!listener.shortRows && el.SyntaxErrorsList.Count == 0)
                {
                    File.WriteAllText(filename, listener.r.GetText());
                }
            }
            catch (IOException exIO)
            {
                return(" - ER - Errore in lettura o scrittura del file csv\n    " + exIO.Message);
            }
            catch (Exception e)
            {
                return("-ER - Errore non gestito: " + e.Message);
            }

            if (result.Equals(string.Empty))
            {
                result = "+OK";
            }

            return(result);
        }