Top Level Namespace

Defined Under Namespace

Modules: CTokenizer, CType, Caphir, DBC, OCL, ParseErrorHandler, Preprocessor Classes: Module, ParserSettings, SearchPath, String

Instance Method Summary collapse

Instance Method Details

#expand_function(conditions, context, body, start_line, line_info) ⇒ Object 



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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/dbc/expand_function.rb', line 8

def expand_function(conditions, context, body, start_line, line_info)
	raise 'should be a function' unless context.function?

	context_str = context.short_name
	f_cond = conditions[context_str]

	outstr = ''
	outstr << "\n"

	pre_text = ''			# preconditions
	post_text = ''		# postconditions
	inv_text = ''			# invariants
	final_text = ''		# stuff at the end

	if f_cond
		# get the conditions
		f_cond.conditions.each do |c|
			case c.type
				when "pre"
					pre_text
				when "post"
					post_text
				else
					raise ParseError, "unexpected condition type: #{c.type} for #{context_str}"
			end << c.to_cexp("\t")
		end
		# set up old values
		f_cond.old_values.each do |identifier, var_used|
			# figures out the type of identifiers such as a->b->c
			begin
				p_type = context.evaluate(identifier)
			rescue CType::EvaluationError
				raise CType::EvaluationError, "#{line_info}: in #{context_str}, #{$!} for #{identifier}"
			end
			# initializations
			outstr << "\t" << p_type.to_init_s(var_used)
			outstr << ' = ' << identifier << ";\n"
		end
	end

	context.parameters.each do |p|
		inv = conditions[p.short_name]
		if inv then inv.conditions.each do |c|
			raise ParseError, "expecting invariant got #{c.long_type} for #{p.to_s}" \
				unless c.type == "inv"
			exp_str = c.to_cexp("\t", context_str)
			# fix me - this could be better
			sub_str = '\1' + p.identifier + '\2'
			exp_str.gsub!(/(\W)self(\W+)/, sub_str)
			inv_text << exp_str
		end; end
	end
	
	if pre_text.empty? and post_text.empty? and inv_text.empty?
		# we're done early
		return body.collect! { |t| t.at(1) }.join
	end

	void_return_type = (context.base_type.to_s == 'void')

	unless void_return_type or (post_text.empty? and inv_text.empty?)
		outstr << "\t" << context.base_type.to_init_s('ocl__ret_val') << ";\n"
	end
	
	# output invariants and preconditions
	outstr << "\t/* Invariants: */\n" << inv_text unless inv_text.empty?
	outstr << "\t/* Preconditions: */\n" << pre_text unless pre_text.empty?

	outstr << "{\n"
	outstr << '#line ' << start_line.to_s << "\n" if line_info

	# output function body
	if post_text.empty? and inv_text.empty?
		outstr << body.collect! do |t|
			start_line += CTokenizer.line_count(t = t.at(1))
			t
		end.join
	else
		output_label = false
		if void_return_type
			outstr << body.collect do |t|
				start_line += CTokenizer.line_count( t = t.at(1) )
				if t == 'return'
					output_label = true
					'goto ocl__return_here'
				else
					t
				end
			end.join # do
		else
			until body.empty?
				start_line += CTokenizer.line_count( t = body.shift.at(1) )
				if t == 'return'
					output_label = true
					outstr << '{ ocl__ret_val = ( '
					until body.empty?
						start_line += CTokenizer.line_count( t = body.shift.at(1) )
						break if t == ';'
						outstr << t
					end
					outstr << ' ); goto ocl__return_here; }'
				else
					outstr << t
				end
			end # until
		end # if
		outstr << "\nocl__return_here:\n" if output_label
		# must explicitly return the return value unless return value is void
		final_text << "\treturn ocl__ret_val;\n" unless void_return_type
	end
	outstr << "\n"

	# output postconditions and invariants
	outstr << "\t/* Postconditions: */\n" << post_text unless post_text.empty?
	outstr << "\t/* Invariants: */\n" << inv_text unless inv_text.empty?

	outstr << final_text
	outstr << "}\n"
	outstr << '#line ' << start_line.to_s << "\n" if line_info
	outstr
end

#expand_version(pre, version) ⇒ Object

Removes dots and zero pads



5
6
7
8
9
 
# File 'lib/caphir/preprocessor_conf.rb', line 5

def expand_version(pre, version)
	version.delete!('.')
	(3 - version.length).times { version << '0' }
	"#{pre}#{version}"
end