FilesExpand file tree

master

/

preproc_ripper.rb

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

112 lines (102 loc) · 2.31 KB

master

/

preproc_ripper.rb

Copy path

Top

File metadata and controls

• Code
• Blame

112 lines (102 loc) · 2.31 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

# frozen_string_literal: true

# $Id$

# This is from tools/preproc.rb in ripper/tools but is modified because we

# do not want:

# 1. #ifdef 0. We need to remove that code.

# 2. Translate Cisms to Java

require 'optparse'

def main

output = nil

parser = OptionParser.new

parser.banner = "Usage: #{File.basename($0)} [--output=PATH] <parse.y>"

parser.on('--output=PATH', 'An output file.') {|path|

output = path

}

parser.on('--help', 'Prints this message and quit.') {

puts parser.help

exit true

}

begin

parser.parse!

rescue OptionParser::ParseError => err

$stderr.puts err.message

$stderr.puts parser.help

exit false

end

unless ARGV.size == 1

abort "wrong number of arguments (#{ARGV.size} for 1)"

end

out = "".dup

file = ARGV[0]

File.open(file) {|f|

prelude f, out

grammar f, out

usercode f, out

}

if output

File.open(output, 'w') {|f|

f.write out

}

else

print out

end

end

def prelude(f, out)

@exprs = {}

lex_state_def = false

while line = f.gets

case line

when /\A%%/

out << "%%\n"

return

when /^enum lex_state_(?:bits|e) \{/

lex_state_def = true

out << line

when /^\}/

lex_state_def = false

out << line

else

out << line

end

if lex_state_def

case line

when /^\s*(EXPR_\w+),\s+\/\*(.+)\*\//

@exprs[$1.chomp("_bit")] = $2.strip

when /^\s*(EXPR_\w+)\s+=\s+(.+)$/

name = $1

val = $2.chomp(",")

@exprs[name] = "equals to " + (val.start_with?("(") ? "<tt>#{val}</tt>" : "+#{val}+")

end

end

end

end

require_relative "dsl_ripper"

def grammar(f, out)

parser_code_region = false

while line = f.gets

case line

when %r</\*% *ripper(?:\[(.*?)\])?: *(.*?) *%\*/>

out << DSL.new($2, ($1 || "").split(",")).generate << "\n"

when %r</\*%%%\*/>

parser_code_region = true

when %r</\*%>

parser_code_region = false

when %r<%\*/>

out << "\n"

when /\A%%/

out << "%%\n"

return

else

out << line if !parser_code_region

end

end

end

def usercode(f, out)

require 'erb'

compiler = ERB::Compiler.new('%-')

compiler.put_cmd = compiler.insert_cmd = "out.<<"

lineno = f.lineno

src, = compiler.compile(f.read)

eval(src, binding, f.path, lineno)

end

main