Class: NCPP::CFileInterpreter

Inherits:

Interpreter

• Object
• Interpreter
• NCPP::CFileInterpreter

Defined in:

lib/ncpp/interpreter.rb

Overview

Scans C/C++ source files for commands and expands them in place

Instance Attribute Summary

• #incomplete_files ⇒ Object readonly

  Returns the value of attribute incomplete_files.

• #lines_parsed ⇒ Object readonly

  Returns the value of attribute lines_parsed.

Instance Method Summary

• #initialize(file_list, out_path, cmd_prefix = COMMAND_PREFIX, extra_cmds = {}, extra_vars = {}, template_args = [], safe: false, puritan: false, no_cache: false, cmd_cache: {}) ⇒ CFileInterpreter constructor

  A new instance of CFileInterpreter.

• #process_file(file_path, verbose: true, debug: false) ⇒ Object
• #run(verbose: true, debug: false) ⇒ Object

Methods inherited from Interpreter

#call, #commands, #def_command, #def_variable, #eval_expr, #eval_str, #get_binding, #get_cacheable_cache, #get_command, #get_new_commands, #get_new_variables, #get_variable, #node_impure?, #unknown_command_error, #unknown_variable_error, #variables

Constructor Details

#initialize(file_list, out_path, cmd_prefix = COMMAND_PREFIX, extra_cmds = {}, extra_vars = {}, template_args = [], safe: false, puritan: false, no_cache: false, cmd_cache: {}) ⇒ CFileInterpreter

Returns a new instance of CFileInterpreter.

# File 'lib/ncpp/interpreter.rb', line 481

def initialize(file_list, out_path, cmd_prefix = COMMAND_PREFIX, extra_cmds = {}, extra_vars = {}, template_args=[],
                safe: false, puritan: false, no_cache: false, cmd_cache: {})

  @EXTRA_CMDS, @EXTRA_VARS = extra_cmds, extra_vars
  super(cmd_prefix, extra_cmds, extra_vars, safe: safe, puritan: puritan, no_cache: no_cache, cmd_cache: cmd_cache)

  @file_list = file_list.is_a?(Array) ? file_list : [file_list]
  @current_file = nil
  @out_path = out_path

  @incomplete_files = []

  @lines_parsed = 0

  @template_args = template_args

  @recorded = ''
  @consume_mode = false
  @lick_mode = false

  @commands.merge!({
    embed: ->(filename, newline_steps=nil) {
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(filename, dir)
      raise "File not found: #{path}" unless File.exist? path
      File.binread(path).bytes.join(',')
    }.returns(String).impure
     .describe(
      'Reads all bytes from the specified file and joins them into a comma-separated String representation.'
    ),

    embed_hex: ->(filename, newline_steps=nil) {
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(filename, dir)
      raise "File not found: #{path}" unless File.exist? path
      bytes = File.binread(path).bytes
      bytes.map! {|b| b.to_i.to_hex }.join(',')
    }.returns(String).impure
     .describe(
      'Reads all bytes from the specified file and joins them as hex into a comma-separated String representation.'
    ),

    read: ->(filename) {
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(filename, dir)
      raise "File not found: #{path}" unless File.exist? path
      File.read(path)
    }.returns(String).impure
      .describe('Reads the file specified and returns its contents as a String.'),

    read_lines: ->(filename) {
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(filename, dir)
      raise "File not found: #{path}" unless File.exist? path
      File.readlines(path)
    }.returns(Array).impure
      .describe('Reads the file specified and returns an Array containing each line.'),

    read_bytes: ->(filename) {
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(filename, dir)
      raise "File not found: #{path}" unless File.exist? path
      File.binread(path).bytes
    }.returns(Array).impure
      .describe('Reads the file specified and returns an Array containing each byte.'),

    import: ->(template_file, *arg_vals) {
      t_interpreter = CFileInterpreter.new(nil,nil,@COMMAND_PREFIX,@EXTRA_CMDS,@EXTRA_VARS,[*arg_vals])
      dir = File.dirname(@current_file || Dir.pwd)
      path = File.expand_path(template_file, dir)
      ret, _, t_args = t_interpreter.process_file(path)
      @lines_parsed += t_interpreter.lines_parsed
      if t_args.length > 0
        puts "WARNING".underline_yellow + ': '.yellow + "#{t_args.length} template arg#{'s' if t_args.length != 1}"\
             " not used.".yellow
      end
      ret
    }.returns(String).impure
     .describe(
      "Takes a template file name and a value for each arg exported by the template. The template file is " \
      "processed by the interpreter, and the generated code is embedded into the current file."
    ),

    expect: ->(*arg_names) {
      argc, targc = @template_args.length, arg_names.length
      if targc != argc
        raise "#{argc} template arg#{'s' if argc != 1} given when #{targc} #{targc==1 ? 'is' : 'are'} required."
      end
      arg_names.each_with_index do |arg, i|
        Utils.valid_identifier_check(arg)
        @variables[arg.to_sym] = @template_args.first
        @template_args = @template_args.drop(1)
      end
    }.impure
      .describe(
      "Declares the variables that should be defined when importing the template. " \
      "This command is specific to CFileInterpreter."
    ),

    start_consume: -> { @consume_mode = true }.impure
      .describe(
        "Starts consume mode; the following parsed lines will stored in a variable held by the interpreter, which "\
        "can only be accessed by the 'spit' command. Consumed lines will not be put in the generated source file."
    ),

    end_consume: -> { @consume_mode = false }.impure
      .describe('Ends consume parse mode.'),

    start_lick: -> { @lick_mode = true }.impure
      .describe('Starts lick parse mode.'),

    end_lick: -> { @lick_mode = false }.impure
      .describe('Ends lick parse mode.'),

    spit: ->(retain = false) {
      ret = @recorded.clone
      @recorded.clear unless retain
      ret
    }.returns(String).impure
      .describe('Gets what was consumed or licked.'),

    clear_consumed: -> { @recorded.clear }.impure
      .describe('Clears the variable containing what was consumed or licked.'),
    
    clear_licked: -> { @recorded.clear }.impure
      .describe('Clears the variable containing what was licked or consumed.'),
  })
end

Instance Attribute Details

#incomplete_files ⇒ Object (readonly)

Returns the value of attribute incomplete_files.

# File 'lib/ncpp/interpreter.rb', line 479

def incomplete_files
  @incomplete_files
end

#lines_parsed ⇒ Object (readonly)

Returns the value of attribute lines_parsed.

# File 'lib/ncpp/interpreter.rb', line 479

def lines_parsed
  @lines_parsed
end

Instance Method Details

#process_file(file_path, verbose: true, debug: false) ⇒ Object

# File 'lib/ncpp/interpreter.rb', line 626

def process_file(file_path, verbose: true, debug: false)
  raise "#{file_path} does not exist." unless File.exist?(file_path)

  @current_file = file_path

  success = true

  # cursor state
  in_comment = false
  in_string  = false
  in_expr    = false # TODO: multi-line expression parsing

  output = ''

  File.readlines(file_path).each_with_index do |line, lineno|
    cursor   = 0
    new_line = ""

    while cursor < line.length
      # stop parsing rest of line on single-line comment
      if !in_comment && !in_string && line[cursor, 2] == "//"
        new_line << line[cursor..-1]
        break

      # enter multi-line comment
      elsif !in_comment && !in_string && line[cursor, 2] == "/*"
        in_comment = true
        new_line << "/*"
        cursor += 2
        next

      # leave comment
      elsif in_comment && line[cursor, 2] == "*/"
        in_comment = false
        new_line << "*/"
        cursor += 2
        next

      # enter string
      elsif !in_comment && line[cursor] == '"'
        in_string = !in_string
        new_line << '"'
        cursor += 1
        next
      end

      # enter command
      if !in_comment && !in_string && line[cursor, @COMMAND_PREFIX.length] == @COMMAND_PREFIX &&
          (cursor == 0 || !/[0-9A-Za-z_]/.match?(line[cursor-1]))
        expr_src = line[(cursor + @COMMAND_PREFIX.length)..]
        begin
          tree    = @parser.parse(expr_src)
          rtree_s = tree.to_s.reverse

          # finds the end of the expression (hacky)
          expr_end = /\d+/.match(rtree_s[..rtree_s.index('__last_char__: '.reverse)].reverse).to_s
          if expr_end.empty?
            raise 'Could not find an end to expression on line; multi-line expressions are not yet supported'
          end
          last_paren = Integer(expr_end) + 1

          ast = @transformer.apply(tree)
          value = eval_expr(ast)
          @out_stack << value.to_s unless value.nil?
          new_line << @out_stack.join("\n") unless @out_stack.empty?
          @out_stack.clear

          cursor += @COMMAND_PREFIX.length + last_paren # move cursor past expression
          next

        rescue Parslet::ParseFailed => e
          puts "#{file_path}:#{lineno+1}: parse failed at expression".yellow
          puts 'ERROR'.underline_red + ": #{e.parse_failure_cause.ascii_tree}".red
        rescue Exception => e
          puts "#{file_path}:#{lineno+1}: parse failed at expression".yellow
          puts 'ERROR'.underline_red + ": #{debug ? e.detailed_message : e.to_s}".red
          # fall through, copy raw text instead
        end

        success = false
      end

      new_line << line[cursor]
      cursor += 1
    end

    new_line = (line != new_line && new_line.strip.empty?) ? '' : new_line

    if @consume_mode
      @recorded << new_line
    else
      @recorded << new_line if @lick_mode
      output << new_line
    end
    @lines_parsed += 1
  end
  [output, success, @template_args]
end

#run(verbose: true, debug: false) ⇒ Object

# File 'lib/ncpp/interpreter.rb', line 610

def run(verbose: true, debug: false)
  @file_list.each do |file|
    if verbose
      puts "Processing #{file}".cyan
    end

    out, success, _ = process_file(file, verbose: verbose, debug: debug)

    @incomplete_files << file unless success

    new_file_path = @out_path + '/' + file
    FileUtils.mkdir_p(File.dirname(new_file_path))
    File.write(new_file_path, out)
  end
end