cafe-grader-judge-scripts

Commit r188:4805f3ab73c4 public

parent | child
Description:
merge fix utf8
Commit status:
[Not Reviewed]
References:
merge algo
Diff options:
Raw Diff | Patch Diff | Download Diff | Show whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r188:4805f3ab73c4 - - 2 files changed: 4 inserted, 2 deleted

Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -1,187 +1,188
1 1 #!/usr/bin/env ruby
2 2
3 3 require 'fileutils'
4 4
5 5 ##############################
6 6 #
7 7 # Standard Compile Script
8 8 #
9 9 # Supported compilers:
10 10 # gcc, g++, and fpc.
11 11 #
12 12 ##############################
13 13
14 14 def talk(str='')
15 15 if ENV['TALKATIVE']!=nil
16 16 puts str
17 17 end
18 18 if ENV['GRADER_LOGGING']!=nil
19 19 log_fname = ENV['GRADER_LOGGING']
20 20 fp = File.open(log_fname,"a")
21 21 fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
22 22 fp.close
23 23 end
24 24 end
25 25
26 26 C_COMPILER = "/usr/bin/gcc"
27 27 CPLUSPLUS_COMPILER = "/usr/bin/g++"
28 28 PASCAL_COMPILER = "/usr/bin/fpc"
29 29 JAVA_COMPILER = "/usr/bin/javac"
30 30 RUBY_INTERPRETER = "/usr/bin/ruby"
31 31 PYTHON_INTERPRETER = "/usr/bin/python"
32 32 PYTHON_CHECKER = "/usr/bin/pyflakes"
33 33 PHP_INTERPRETER = "/usr/bin/php"
34 34
35 35 C_OPTIONS = "-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
36 36 CPLUSPLUS_OPTIONS = "-O2 -s -std=c++11 -static -DCONTEST -lm -Wall"
37 37 PASCAL_OPTIONS = "-O1 -XS -dCONTEST"
38 38 JAVA_OPTIONS = ""
39 39 PYTHON_OPTIONS = ""
40 40 PHP_OPTIONS = "-l"
41 41
42 42 # Check for the correct number of arguments. Otherwise, print usage.
43 43 if ARGV.length == 0 or ARGV.length > 4
44 44 puts "Usage: compile <language> [<source-file>] [<output-file>] [<message-file>]"
45 45 puts
46 46 puts "<source-file> is defaulted to \"source\"."
47 47 puts "<output-file> is defaulted to \"a.out\"."
48 48 puts "<message-file> is defaulted to \"compiler_message\"."
49 49 puts
50 50 exit(127)
51 51 end
52 52
53 53 PARAMS = {
54 54 :source_file => [1,'source'],
55 55 :output_file => [2,'a.out'],
56 56 :message_file => [3,'compiler_message']
57 57 }
58 58
59 59 params = {}
60 60 params[:prog_lang] = ARGV[0]
61 61 PARAMS.each_key do |param_name|
62 62 index, default = PARAMS[param_name]
63 63 if ARGV.length > index
64 64 params[param_name] = ARGV[index]
65 65 else
66 66 params[param_name] = default
67 67 end
68 68 talk "#{param_name}: #{params[param_name]}"
69 69 end
70 70
71 71 # Remove any remaining output files or message files.
72 72 if FileTest.exists? params[:output_file]
73 73 FileUtils.rm(params[:output_file])
74 74 end
75 75 if FileTest.exists? params[:message_file]
76 76 FileUtils.rm(params[:message_file])
77 77 end
78 78
79 79 # Check if the source file exists before attempt compiling.
80 80 if !FileTest.exists? params[:source_file]
81 81 talk("ERROR: The source file does not exist!")
82 82 open(params[:message_file],"w") do |f|
83 83 f.puts "ERROR: The source file did not exist."
84 84 end
85 85 exit(127)
86 86 end
87 87
88 88 if params[:prog_lang]=='cpp'
89 89 params[:prog_lang] = 'c++'
90 90 end
91 91
92 92 # Compile.
93 93 case params[:prog_lang]
94 94
95 95 when "c"
96 96 command = "#{C_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{C_OPTIONS}"
97 97 system(command, err: params[:message_file])
98 98
99 99 when "c++"
100 100 command = "#{CPLUSPLUS_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{CPLUSPLUS_OPTIONS}"
101 101 system(command, err: params[:message_file])
102 102
103 103 when "pas"
104 104 command = "#{PASCAL_COMPILER} #{params[:source_file]} -ooutpas #{PASCAL_OPTIONS}"
105 105 system(command,out: params[:message_file])
106 106 FileUtils.mv("output", params[:output_file])
107 107
108 108 when "java"
109 109 #rename the file to the public class name
110 110
111 111 #get the class name
112 112 classname = 'DUMMY'
113 113 source = Array.new
114 - File.foreach(params[:source_file]) do |line|
114 + File.foreach(params[:source_file],'r:UTF-8') do |line|
115 + line.encode!('UTF-8','UTF-8',invalid: :replace, replace: '')
115 116 md = /\s*public\s*class\s*(\w*)/.match(line)
116 117 classname=md[1] if md
117 118 source << line unless line =~ /\s*package\s*\w+\s*\;/
118 119 end
119 120 File.open("#{classname}.java","w") do |file|
120 121 source.each do |s|
121 122 file.puts s
122 123 end
123 124 end
124 125 #system("cp #{params[:source_file]} #{classname}.java")
125 - command = "#{JAVA_COMPILER} #{classname}.java"
126 + command = "#{JAVA_COMPILER} -encoding utf8 #{classname}.java"
126 127 system(command, err: params[:message_file])
127 128 if File.exists?(classname + ".class")
128 129 File.open(params[:output_file],"w") {|file| file.write("#{classname}")}
129 130 end
130 131 if classname == 'DUMMY'
131 132 File.open(params[:message_file],"w") {|file| file.write("Cannot find any public class in the source code\n")}
132 133 end
133 134
134 135 when "ruby"
135 136 command = "#{RUBY_INTERPRETER} -c #{params[:source_file]}"
136 137 if system(command, err: params[:message_file])
137 138 File.open(params[:output_file],"w") do |out_file|
138 139 out_file.puts "#!#{RUBY_INTERPRETER}"
139 140 File.open(params[:source_file],"r").each do |line|
140 141 out_file.print line
141 142 end
142 143 end
143 144 File.chmod(0755, params[:output_file])
144 145 end
145 146
146 147 when "python"
147 148 command = "#{PYTHON_CHECKER} #{params[:source_file]}"
148 149 if system(command, out: params[:message_file])
149 150 #compile to python bytecode
150 151 command = "#{PYTHON_INTERPRETER} -m py_compile #{params[:source_file]}"
151 152 puts "compile: #{command}"
152 153 system(command)
153 154 puts "pwd: " + Dir.pwd
154 155 Dir.new('.').each {|file| puts file}
155 156 File.open(params[:output_file],"w") do |out_file|
156 157 out_file.puts "#!#{PYTHON_INTERPRETER} #{params[:source_file]}c"
157 158 end
158 159 File.chmod(0755, params[:output_file])
159 160 FileUtils.cp("#{params[:source_file]}c",params[:output_file])
160 161 end
161 162
162 163 when "php"
163 164 command = "#{PHP_INTERPRETER} #{PHP_OPTIONS} #{params[:source_file]}"
164 165 if system(command, err: params[:message_file])
165 166 File.open(params[:output_file],"w") do |out_file|
166 167 out_file.puts "#!#{PHP_INTERPRETER}"
167 168 File.open(params[:source_file],"r").each do |line|
168 169 out_file.print line
169 170 end
170 171 end
171 172 File.chmod(0755, params[:output_file])
172 173 end
173 174
174 175 else
175 176 talk("ERROR: Invalid language specified!")
176 177 open(params[:message_file],"w") do |f|
177 178 f.puts "ERROR: Invalid language specified!"
178 179 end
179 180 exit(127)
180 181 end
181 182
182 183 # Report success or failure.
183 184 if FileTest.exists? params[:output_file]
184 185 talk "Compilation was successful!"
185 186 else
186 187 talk "ERROR: Something was wrong during the compilation!"
187 188 end
Show file before | Show file after | Raw diff | Download diff | Show whitespace Increase context Show commentsHide comments
@@ -1,133 +1,134
1 1 #!/usr/bin/env ruby
2 2
3 3 CORRECT_MARK = 'P'
4 4 INCORRECT_MARK = '-'
5 5 TIMEOUT_MARK = 'T'
6 6 RUN_ERROR_MARK = 'x'
7 7
8 8 def log(str='')
9 9 if ENV['TALKATIVE']!=nil
10 10 puts str
11 11 end
12 12 if ENV['GRADER_LOGGING']!=nil
13 13 log_fname = ENV['GRADER_LOGGING']
14 14 fp = File.open(log_fname,"a")
15 15 fp.puts("grade: #{Time.new.strftime("%H:%M")} #{str}")
16 16 fp.close
17 17 end
18 18 end
19 19
20 20 def char_comment(comment)
21 21 if comment =~ /[Ii]ncorrect/
22 22 INCORRECT_MARK
23 23 elsif comment =~ /[Cc]orrect/
24 24 CORRECT_MARK
25 25 elsif comment =~ /[Tt]ime/
26 26 TIMEOUT_MARK
27 27 elsif res = /^[Cc]omment:(.*)$/.match(comment)
28 28 res[1]
29 29 else
30 30 RUN_ERROR_MARK # these are run time errors
31 31 end
32 32 end
33 33
34 34 def extract_time(t)
35 35 #puts "TIME: #{t}"
36 36 if (result=/^(.*)r(.*)u(.*)s(.*)kbytes/.match(t))
37 37 {:real => result[1], :user => result[2], :sys => result[3], :mem => result[4]}
38 38 else
39 39 #{:real => 0, :user => 0, :sys => 0}
40 40 #puts "ERROR READING RUNNING TIME: #{t}"
41 41 raise "Error reading running time: #{t}"
42 42 end
43 43 end
44 44
45 45 problem_home = ENV['PROBLEM_HOME']
46 46 require "#{problem_home}/script/test_dsl.rb"
47 47 load "#{problem_home}/test_cases/all_tests.cfg"
48 48 problem = Problem.get_instance
49 49
50 50 if problem.well_formed? == false
51 51 log "The problem specification is not well formed."
52 52 exit(127)
53 53 end
54 54
55 55 all_score = 0
56 56 all_comment = ''
57 57 peak_memory = -1
58 58 max_runtime = -1
59 59 (1..(problem.runs.length-1)).each do |k|
60 60 log "grade run #{k}"
61 61 run = problem.runs[k]
62 62 run_score = nil
63 63 run_comment = ''
64 64 run_comment_short = ''
65 65 run.tests.each do |test_num|
66 66 result_file_name = "#{test_num}/result"
67 67 if not File.exists?(result_file_name)
68 68 run_comment += "result file for test #{test_num} not found\n"
69 69 run_comment_short += RUN_ERROR_MARK
70 70 log "Cannot find the file #{test_num}/result!"
71 71 else
72 72 result_file = File.new(result_file_name, "r")
73 73 result_file_lines = result_file.readlines
74 74 if result_file_lines.length>=3
75 75 current_run_score = result_file_lines[1].to_i
76 76 run_comment += result_file_lines[0]
77 77 run_comment_short += char_comment(result_file_lines[0].chomp)
78 78
79 79 #update max runtime & memory
80 80 run_stat = extract_time result_file_lines[2]
81 81 peak_memory = [peak_memory,run_stat[:mem].to_i].max
82 82 max_runtime = [max_runtime,run_stat[:user].to_f + run_stat[:sys].to_f].max
83 83 else
84 84 current_run_score = 0
85 85 run_comment += "result file for test #{test_num} error\n"
86 86 run_comment_short += RUN_ERROR_MARK
87 87 log "Error in #{test_num}/result!"
88 88 end
89 89
90 90 # the score of this run should be the minimum of the score for
91 91 # each test case
92 92 if (run_score==nil) or (run_score>current_run_score)
93 93 run_score = current_run_score
94 94 end
95 95 result_file.close
96 96 end
97 97 end
98 98
99 99 run_result_file = File.new("result-#{k}", "w")
100 100 run_result_file.write run_score
101 101 run_result_file.write "\n"
102 102 run_result_file.close
103 103
104 104 run_comment_file = File.new("comment-#{k}", "w")
105 105 run_comment_file.write "#{run_comment}\n"
106 106 run_comment_file.close
107 107
108 108 all_score = all_score + run_score
109 109
110 110 # append comment for test run with many test cases
111 111 if run.tests.length > 1
112 112 run_comment_short = '[' + run_comment_short + ']'
113 113 end
114 114 all_comment += run_comment_short
115 115 end
116 116
117 117 result_file = File.new("result", "w")
118 118 result_file.write all_score
119 119 result_file.write "\n"
120 120 result_file.close
121 121
122 122 comment_file = File.new("comment", "w")
123 123 comment_file.write "#{all_comment}\n"
124 124 comment_file.close
125 125
126 126
127 127 File.open("run_stat","w") do |file|
128 128 file.puts max_runtime
129 129 file.puts peak_memory
130 130 end
131 131
132 + puts "#{all_score} #{all_comment}"
132 133 log "score = #{all_score}\ncomment = #{all_comment}"
133 134 log "max_runtime = #{max_runtime}\npeak_memory = #{peak_memory}"
You need to be logged in to leave comments. Login now