Skip to content
Snippets Groups Projects
Select Git revision
  • a6823ea7d9319509b17078aa14d97a6cbc3706cd
  • develop default protected
  • feature/gmsh-reader
  • origin/stage/bouguettaia
  • feature/kinetic-schemes
  • feature/reconstruction
  • feature/local-dt-fsi
  • feature/composite-scheme-sources
  • feature/composite-scheme-other-fluxes
  • feature/serraille
  • feature/variational-hydro
  • feature/composite-scheme
  • hyperplastic
  • feature/polynomials
  • feature/gks
  • feature/implicit-solver-o2
  • feature/coupling_module
  • feature/implicit-solver
  • feature/merge-local-dt-fsi
  • master protected
  • feature/escobar-smoother
  • v0.5.0 protected
  • v0.4.1 protected
  • v0.4.0 protected
  • v0.3.0 protected
  • v0.2.0 protected
  • v0.1.0 protected
  • Kidder
  • v0.0.4 protected
  • v0.0.3 protected
  • v0.0.2 protected
  • v0 protected
  • v0.0.1 protected
33 results

PugsParser.cpp

Blame
    • Stéphane Del Pino's avatar
      a6823ea7
      Fix function domains and arguments definition · a6823ea7
      Stéphane Del Pino authored
      Symbol table is now populated correctly.
      It remains the case of
      ``
      let g : R*N -> R, x -> x;
      ``
      where `x` is a complex type. It produces a clean error message and this
      development is postponed to a far(?) future since it will require compound types
      management (or at least heterogeneous arrays)
      a6823ea7
      History
      Fix function domains and arguments definition
      Stéphane Del Pino authored
      Symbol table is now populated correctly.
      It remains the case of
      ``
      let g : R*N -> R, x -> x;
      ``
      where `x` is a complex type. It produces a clean error message and this
      development is postponed to a far(?) future since it will require compound types
      management (or at least heterogeneous arrays)
    PugsParser.cpp 2.64 KiB
    #include <PugsParser.hpp>
    
    #include <PugsAssert.hpp>
    
    #include <fstream>
    #include <iostream>
    #include <unordered_map>
    #include <variant>
    
    #include <rang.hpp>
    
    #include <pegtl/analyze.hpp>
    #include <pegtl/contrib/parse_tree.hpp>
    #include <pegtl/contrib/parse_tree_to_dot.hpp>
    
    #include <ASTNode.hpp>
    
    #include <ASTBuilder.hpp>
    #include <PEGGrammar.hpp>
    #include <SymbolTable.hpp>
    
    #include <ASTNodeDataTypeBuilder.hpp>
    #include <ASTNodeDataTypeChecker.hpp>
    
    #include <ASTNodeJumpPlacementChecker.hpp>
    
    #include <ASTNodeExpressionBuilder.hpp>
    
    #include <ASTSymbolInitializationChecker.hpp>
    #include <ASTSymbolTableBuilder.hpp>
    
    #include <ASTNodeDeclarationCleaner.hpp>
    #include <ASTNodeDeclarationToAffectationConverter.hpp>
    
    #include <ASTDotPrinter.hpp>
    #include <ASTPrinter.hpp>
    
    #include <ASTNodeValueBuilder.hpp>
    
    void
    parser(const std::string& filename)
    {
      const size_t grammar_issues = analyze<language::grammar>();
    
      std::cout << rang::fgB::yellow << "grammar_issues=" << rang::fg::reset << grammar_issues << '\n';
    
      std::cout << rang::style::bold << "Parsing file " << rang::style::reset << rang::style::underline << filename
                << rang::style::reset << " ...\n";
    
      std::unique_ptr<ASTNode> root_node;
      read_input input(filename);
      try {
        root_node = ASTBuilder::build(input);
    
        ASTSymbolTableBuilder{*root_node};
    
        ASTSymbolInitializationChecker{*root_node};
    
        ASTNodeDataTypeBuilder{*root_node};
    
        {
          std::string dot_filename{"parse_tree.dot"};
          std::ofstream fout(dot_filename);
          ASTDotPrinter dot_printer{*root_node};
          fout << dot_printer;
          std::cout << "   AST dot file: " << dot_filename << '\n';
        }
    
        ASTNodeDataTypeChecker{*root_node};
    
        ASTNodeValueBuilder{*root_node};
    
        ASTNodeJumpPlacementChecker{*root_node};
    
        // optimizations
        ASTNodeDeclarationToAffectationConverter{*root_node};
        ASTNodeDeclarationCleaner{*root_node};
    
        ASTNodeExpressionBuilder{*root_node};
    
        std::cout << ASTPrinter{*root_node} << '\n';
    
        ExecUntilBreakOrContinue exec_all;
        root_node->execute(exec_all);
        std::cout << *(root_node->m_symbol_table) << '\n';
      }
      catch (const parse_error& e) {
        const auto p = e.positions.front();
        std::cerr << rang::style::bold << p.source << ':' << p.line << ':' << p.byte_in_line << ": " << rang::style::reset
                  << rang::fgB::red << "error: " << rang::fg::reset << rang::style::bold << e.what() << rang::style::reset
                  << '\n'
                  << input.line_at(p) << '\n'
                  << std::string(p.byte_in_line, ' ') << rang::fgB::yellow << '^' << rang::fg::reset << std::endl;
        std::exit(1);
      }
    
      std::cout << "Parsed: " << filename << '\n';
    }