cafe-grader-judge-scripts

Commit r165:6f663119800b public

parent | child
Description:
add php
Commit status:
[Not Reviewed]
References:
algo
Diff options:
Raw Diff | Patch Diff | Download Diff | Ignore 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

r165:6f663119800b - - 4 files changed: 20 inserted, 3 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,166 +1,180
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 + PHP_INTERPRETER = "/usr/bin/php"
33 34
34 35 C_OPTIONS = "-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
35 36 CPLUSPLUS_OPTIONS = "-O2 -s -std=c++11 -static -DCONTEST -lm -Wall"
36 37 PASCAL_OPTIONS = "-O1 -XS -dCONTEST"
37 38 JAVA_OPTIONS = ""
38 39 PYTHON_OPTIONS = ""
40 + PHP_OPTIONS = "-l"
39 41
40 42 # Check for the correct number of arguments. Otherwise, print usage.
41 43 if ARGV.length == 0 or ARGV.length > 4
42 44 puts "Usage: compile <language> [<source-file>] [<output-file>] [<message-file>]"
43 45 puts
44 46 puts "<source-file> is defaulted to \"source\"."
45 47 puts "<output-file> is defaulted to \"a.out\"."
46 48 puts "<message-file> is defaulted to \"compiler_message\"."
47 49 puts
48 50 exit(127)
49 51 end
50 52
51 53 PARAMS = {
52 54 :source_file => [1,'source'],
53 55 :output_file => [2,'a.out'],
54 56 :message_file => [3,'compiler_message']
55 57 }
56 58
57 59 params = {}
58 60 params[:prog_lang] = ARGV[0]
59 61 PARAMS.each_key do |param_name|
60 62 index, default = PARAMS[param_name]
61 63 if ARGV.length > index
62 64 params[param_name] = ARGV[index]
63 65 else
64 66 params[param_name] = default
65 67 end
66 68 talk "#{param_name}: #{params[param_name]}"
67 69 end
68 70
69 71 # Remove any remaining output files or message files.
70 72 if FileTest.exists? params[:output_file]
71 73 FileUtils.rm(params[:output_file])
72 74 end
73 75 if FileTest.exists? params[:message_file]
74 76 FileUtils.rm(params[:message_file])
75 77 end
76 78
77 79 # Check if the source file exists before attempt compiling.
78 80 if !FileTest.exists? params[:source_file]
79 81 talk("ERROR: The source file does not exist!")
80 82 open(params[:message_file],"w") do |f|
81 83 f.puts "ERROR: The source file did not exist."
82 84 end
83 85 exit(127)
84 86 end
85 87
86 88 if params[:prog_lang]=='cpp'
87 89 params[:prog_lang] = 'c++'
88 90 end
89 91
90 92 # Compile.
91 93 case params[:prog_lang]
92 94
93 95 when "c"
94 96 command = "#{C_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{C_OPTIONS} 2> #{params[:message_file]}"
95 97 system(command)
96 98
97 99 when "c++"
98 100 command = "#{CPLUSPLUS_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{CPLUSPLUS_OPTIONS} 2> #{params[:message_file]}"
99 101 system(command)
100 102
101 103 when "pas"
102 104 command = "#{PASCAL_COMPILER} #{params[:source_file]} -ooutpas #{PASCAL_OPTIONS} > #{params[:message_file]}"
103 105 system(command)
104 106 FileUtils.mv("output", params[:output_file])
105 107
106 108 when "java"
107 109 #rename the file to the public class name
108 110
109 111 #get the class name
110 112 classname = 'DUMMY'
111 113 File.foreach(params[:source_file]) do |line|
112 114 md = /\s*public\s*class\s*(\w*)/.match(line)
113 115 classname=md[1] if md
114 116 end
115 117 system("cp #{params[:source_file]} #{classname}.java")
116 118 command = "#{JAVA_COMPILER} #{classname}.java 2> #{params[:message_file]}"
117 119 system(command)
118 120 if File.exists?(classname + ".class")
119 121 File.open(params[:output_file],"w") {|file| file.write("#{classname}")}
120 122 end
121 123 if classname == 'DUMMY'
122 124 File.open(params[:message_file],"w") {|file| file.write("Cannot find any public class in the source code\n")}
123 125 end
124 126
125 127 when "ruby"
126 128 command = "#{RUBY_INTERPRETER} -c #{params[:source_file]} 2> #{params[:message_file]}"
127 129 if system(command)
128 130 File.open(params[:output_file],"w") do |out_file|
129 131 out_file.puts "#!#{RUBY_INTERPRETER}"
130 132 File.open(params[:source_file],"r").each do |line|
131 133 out_file.print line
132 134 end
133 135 end
134 136 File.chmod(0755, params[:output_file])
135 137 end
136 138
137 139 when "python"
138 140 command = "#{PYTHON_CHECKER} #{params[:source_file]} > #{params[:message_file]}"
139 141 if system(command)
140 142 #compile to python bytecode
141 143 command = "#{PYTHON_INTERPRETER} -m py_compile #{params[:source_file]}"
142 144 puts "compile: #{command}"
143 145 system(command)
144 146 puts "pwd: " + Dir.pwd
145 147 Dir.new('.').each {|file| puts file}
146 148 File.open(params[:output_file],"w") do |out_file|
147 149 out_file.puts "#!#{PYTHON_INTERPRETER} #{params[:source_file]}c"
148 150 end
149 151 File.chmod(0755, params[:output_file])
150 152 FileUtils.cp("#{params[:source_file]}c",params[:output_file])
151 153 end
152 -
154 +
155 + when "php"
156 + command = "#{PHP_INTERPRETER} #{PHP_OPTIONS} #{params[:source_file]} 2> #{params[:message_file]}"
157 + if system(command)
158 + File.open(params[:output_file],"w") do |out_file|
159 + out_file.puts "#!#{PHP_INTERPRETER}"
160 + File.open(params[:source_file],"r").each do |line|
161 + out_file.print line
162 + end
163 + end
164 + File.chmod(0755, params[:output_file])
165 + end
166 +
153 167 else
154 168 talk("ERROR: Invalid language specified!")
155 169 open(params[:message_file],"w") do |f|
156 170 f.puts "ERROR: Invalid language specified!"
157 171 end
158 172 exit(127)
159 173 end
160 174
161 175 # Report success or failure.
162 176 if FileTest.exists? params[:output_file]
163 177 talk "Compilation was successful!"
164 178 else
165 179 talk "ERROR: Something was wrong during the compilation!"
166 180 end
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,131 +1,131
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 - puts "TIME: #{t}"
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
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,152 +1,152
1 1 #!/usr/bin/env ruby
2 2
3 3 require 'fileutils'
4 4
5 5 def log(str='')
6 6 if ENV['TALKATIVE']!=nil
7 7 puts str
8 8 end
9 9 if ENV['GRADER_LOGGING']!=nil
10 10 log_fname = ENV['GRADER_LOGGING']
11 11 fp = File.open(log_fname,"a")
12 12 fp.puts("judge: #{Time.new.strftime("%H:%M")} #{str}")
13 13 fp.close
14 14 end
15 15 end
16 16
17 17 problem_home = ENV['PROBLEM_HOME']
18 18
19 19 def execute(command, error_message="")
20 20 if not system(command)
21 21 msg = "ERROR: #{error_message}"
22 22 log msg
23 23 raise(msg)
24 24 end
25 25 end
26 26
27 27 def call_and_log(error_message)
28 28 begin
29 29 yield
30 30 rescue
31 31 msg = "ERROR: #{error_message}"
32 32 log msg
33 33 raise msg
34 34 end
35 35 end
36 36
37 37 def clear_and_create_empty_dir(dir)
38 38 FileUtils.rm_rf(dir, :secure => true)
39 39 call_and_log("Cannot make directory #{dir}.") { FileUtils.mkdir(dir) }
40 40 end
41 41
42 42 # ARGV[0] --- language
43 43 # ARGV[1] --- program source file
44 44 # ARGV[2] --- test result directory
45 45 # ARGV[3] --- sandbox directory
46 46
47 47 if ARGV.length < 2 || ARGV.length > 4
48 48 puts "Usage: judge <language> <program-source> [<test-result-directory>] [<sandbox-directory>]"
49 49 puts " <sandbox-directory> is defaulted to ./sandbox"
50 50 puts " <test-result-directory> is defaulted to ./test-result"
51 51 puts "WARNING: The judge script will forcefully create the (implicitly and explicitly) specified directories and remove anything inside it."
52 52 exit(127)
53 53 end
54 54
55 55 language = ARGV[0]
56 - if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python"
56 + if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python" && language != "php"
57 57 log "You specified a language that is not supported: #{language}."
58 58 exit(127)
59 59 end
60 60
61 61 source_file = ARGV[1]
62 62 ENV['SOURCE_NAME'] = source_file
63 63 if File.exist?(source_file) == false
64 64 log "The source file does not exist."
65 65 exit(127)
66 66 end
67 67
68 68 log "Making test result and sandbox directories..."
69 69
70 70 current_dir = FileUtils.pwd
71 71 current_dir.strip!
72 72
73 73 if ARGV.length >= 3
74 74 test_result_dir = ARGV[2]
75 75 else
76 76 test_result_dir = "#{current_dir}/test-result"
77 77 end
78 78
79 79 log "Test result directory: #{test_result_dir}"
80 80 clear_and_create_empty_dir(test_result_dir)
81 81
82 82 if ARGV.length >= 4
83 83 sandbox_dir = ARGV[3]
84 84 else
85 85 sandbox_dir = "#{current_dir}/sandbox"
86 86 end
87 87 log "Sandbox directory: #{sandbox_dir}"
88 88 clear_and_create_empty_dir(sandbox_dir)
89 89
90 90 # Compile
91 91 log
92 92 log "Compiling..."
93 93 call_and_log("Cannot copy the source file to #{sandbox_dir}") {
94 94 FileUtils.cp(source_file, sandbox_dir)
95 95 }
96 96 begin
97 97 Dir.chdir sandbox_dir
98 98 rescue
99 99 log "ERROR: Cannot change directory to #{sandbox_dir}."
100 100 exit(127)
101 101 end
102 102 execute("#{problem_home}/script/compile #{language} #{source_file}", "Compilation error!")
103 103 compile_message = open("compiler_message").read
104 104 compile_message.strip!
105 105 call_and_log("Cannot move the compiler message to #{test_result_dir}.") {
106 106 FileUtils.mv("compiler_message", test_result_dir)
107 107 }
108 108 if !FileTest.exist?("a.out")
109 109 log "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
110 110 exit(127)
111 111 else
112 112 call_and_log("Cannot move the compiled program to #{test_result_dir}") {
113 113 FileUtils.mv("a.out",test_result_dir)
114 114 if language == "java" then Dir["*.class"].each { |file| FileUtils.mv(file,test_result_dir)} end
115 115 if language == "python" then Dir["*.pyc"].each { |file| FileUtils.mv(file,test_result_dir)} end
116 116 }
117 117 FileUtils.rm_rf("#{sandbox_dir}/.")
118 118 end
119 119
120 120 require "#{problem_home}/script/test_dsl.rb"
121 121 load "#{problem_home}/test_cases/all_tests.cfg"
122 122 problem = Problem.get_instance
123 123
124 124 if problem.well_formed? == false
125 125 log "The problem specification is not well formed."
126 126 exit(127)
127 127 end
128 128
129 129 # Doing the testing.
130 130 (1..(problem.num_tests)).each do |test_num|
131 131
132 132 $stdout.print "[#{test_num}]"
133 133 $stdout.flush
134 134
135 135 log "Test number: #{test_num}"
136 136
137 137 call_and_log("Cannot copy the compiled program into #{sandbox_dir}") {
138 138 FileUtils.cp("#{test_result_dir}/a.out", sandbox_dir, :preserve => true)
139 139 if language == "java" then Dir["#{test_result_dir}/*.class"].each { |file| FileUtils.cp(file,sandbox_dir)} end
140 140 if language == "python" then Dir["#{test_result_dir}/*.pyc"].each { |file| FileUtils.cp(file,sandbox_dir)} end
141 141 }
142 142
143 143 begin
144 144 execute("#{problem_home}/script/run #{language} #{test_num} ", "Error occured during execution of the run script")
145 145 rescue
146 146 # do nothing
147 147 end
148 148
149 149 call_and_log("Cannot create directory #{test_result_dir}/#{test_num}") {
150 150 FileUtils.mkdir "#{test_result_dir}/#{test_num}"
151 151 }
152 152 call_and_log("Cannot copy the result file into #{test_result_dir}/#{test_num}") {
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,186 +1,189
1 1 #!/usr/bin/env ruby
2 2
3 3 require 'fileutils'
4 4
5 5 def log(str='')
6 6 if ENV['TALKATIVE']!=nil
7 7 puts str
8 8 end
9 9 if ENV['GRADER_LOGGING']!=nil
10 10 log_fname = ENV['GRADER_LOGGING']
11 11 fp = File.open(log_fname,"a")
12 12 fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
13 13 fp.close
14 14 end
15 15 end
16 16
17 17 def extract_time(t)
18 18 # puts "TIME: #{t}"
19 19 if (result=/^(.*)r(.*)u(.*)s/.match(t))
20 20 {:real => result[1], :user => result[2], :sys => result[3]}
21 21 else
22 22 #{:real => 0, :user => 0, :sys => 0}
23 23 #puts "ERROR READING RUNNING TIME: #{t}"
24 24 raise "Error reading running time: #{t}"
25 25 end
26 26 end
27 27
28 28 def compile_box(source,bin)
29 29 system("g++ #{source} -o #{bin}")
30 30 end
31 31
32 32 if ARGV.length < 2 || ARGV.length > 3
33 33 puts "Usage: run <language> <test-num> [<program-name>]"
34 34 exit(127)
35 35 end
36 36
37 37 language = ARGV[0]
38 38 test_num = ARGV[1].to_i
39 39 if ARGV.length > 2
40 40 program_name = ARGV[2]
41 41 else
42 42 program_name = "a.out"
43 43 end
44 44
45 45 problem_home = ENV['PROBLEM_HOME']
46 46 source_name = ENV['SOURCE_NAME']
47 47 require "#{problem_home}/script/test_dsl.rb"
48 48 load "#{problem_home}/test_cases/all_tests.cfg"
49 49 problem = Problem.get_instance
50 50
51 51 sandbox_dir = Dir.getwd
52 52
53 53 if problem.well_formed? == false
54 54 log "The problem specification is not well formed."
55 55 exit(127)
56 56 end
57 57
58 58 # Check if the test number is okay.
59 59 if test_num <= 0 || test_num > problem.num_tests
60 60 log "You have specified a wrong test number."
61 61 exit(127)
62 62 end
63 63
64 64 #####################################
65 65 # Set the relavant file names here. #
66 66 #####################################
67 67
68 68 input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
69 69
70 70 #####################################
71 71
72 72 time_limit = problem.get_time_limit test_num
73 73 mem_limit = problem.get_mem_limit(test_num) * 1024
74 74
75 75 # Copy the input file.
76 76 #`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
77 77
78 78 # check if box is there, if not, compile it!
79 79 if !File.exists?("#{problem_home}/script/box")
80 80 log "WARNING: Compiling box: to increase efficiency, it should be compile manually"
81 81 compile_box("#{problem_home}/script/box.cc",
82 82 "#{problem_home}/script/box")
83 83 end
84 84
85 85 # Hide PROBLEM_HOME
86 86 ENV['PROBLEM_HOME'] = nil
87 87 ENV['SOURCE_NAME'] = nil
88 88
89 89 # Run the program.
90 90 #run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
91 91 #
92 92
93 93 JAVA_OPTION = "-s set_robust_list -s futex -s clone -s getppid -s clone -s wait4 -p /usr/bin/ -p ./"
94 94 RUBY_OPTION = "-p /usr/lib64/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat"
95 95 PYTHON_OPTION = "-p /usr/lib64/ -p /lib64/ -p /usr/bin/ -p /usr/local/lib64/ -p /usr/local/lib/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -s set_robust_list -s openat -s recvmsg -s connect -s socket -s sendto -E PYTHONNOUSERSITE=yes"
96 + PHP_OPTION = "-p /usr/lib64/ -p/lib64/ -p /usr/bin/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p /usr/share/ -s setfsuid -s setfsgid -s openat -s set_robust_list -s futex "
96 97
97 98 case language
98 99 when "java"
99 100 # for java, extract the classname
100 101 # wne have to add additional systemcall and we don't check the mem limit (dunno how to fix...)
101 102 classname = 'DUMMY'
102 103 File.open(program_name,"r").each do |line|
103 104 classname = line
104 105 end
105 106 #for java, we cannot really check the memory limit...
106 107 run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java #{classname} 2>run_result"
107 108 when "ruby"
108 109 run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} #{RUBY_OPTION} -i #{input_file_name} -o output.txt /usr/bin/ruby #{program_name} 2>run_result"
109 110 when "python"
110 111 run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python #{program_name} 2>run_result"
112 + when "php"
113 + run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php #{program_name} 2>run_result"
111 114 else # for c++, pascal, we do the normal checking
112 115 run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} 2>run_result"
113 116 end
114 117
115 118
116 119 log "Running test #{test_num}..."
117 120 log run_command
118 121 log
119 122 system(run_command)
120 123
121 124 # Restore PROBLEM_HOME
122 125 ENV['PROBLEM_HOME'] = problem_home
123 126
124 127 # Create the result file.
125 128 result_file = File.new("result", "w")
126 129 comment_file = File.new("comment", "w")
127 130
128 131 # Check if the program actually produced any output.
129 132 run_result_file = File.new("run_result", "r")
130 133 run_result = run_result_file.readlines
131 134 run_result_file.close
132 135
133 136 run_stat = run_result[run_result.length-1]
134 137 running_time = extract_time(run_stat)
135 138
136 139 report = lambda{ |status, points, comment|
137 140 result_file.write status.strip
138 141 result_file.write "\n"
139 142 result_file.write points.to_s.strip
140 143 result_file.write "\n"
141 144 result_file.write run_stat.strip
142 145 result_file.write "\n"
143 146 result_file.close
144 147 FileUtils.rm "run_result"
145 148 # `rm output.txt` --- keep the output
146 149
147 150 comment_file.write comment
148 151
149 152 # added for debuggin --- jittat
150 153 comment_file.write "--run-result--\n"
151 154 run_result.each do |l|
152 155 comment_file.write l
153 156 end
154 157
155 158 comment_file.close
156 159
157 160 log "Done!"
158 161 exit(0)
159 162 }
160 163
161 164
162 165 if run_result[0][0,2] != "OK"
163 166 log "There was a runtime error."
164 167 report.call(run_result[0], 0, "No comment.\n")
165 168 end
166 169
167 170 if running_time[:user].to_f > time_limit
168 171 log "Time limit exceeded."
169 172 report.call("Time limit exceeded", 0, "No comment.\n")
170 173 end
171 174
172 175 # Run 'check' to evaluate the output.
173 176 #puts "There was no runtime error. Proceed to checking the output."
174 177 check_command = "#{problem_home}/script/check #{language} #{test_num}"
175 178 log "Checking the output..."
176 179 log check_command
177 180 if not system(check_command)
178 181 log "Problem with check script"
179 182 report.call("Incorrect",0,"Check script error.\n")
180 183 exit(127)
181 184 end
182 185
183 186 check_file = File.new("check_result", "r")
184 187 check_file_lines = check_file.readlines
185 188
186 189 report.call(check_file_lines[0], check_file_lines[1], "No comment.\n")
You need to be logged in to leave comments. Login now