message_sorter.sort(messages)
for m in messages do
- if "Warning".search_in(m.text, 0) == null then had_error = true
+ if m.text.search("Warning") == null then had_error = true
stderr.write("{m.to_color_string}\n")
end
end
self.discover_call_trace.add mpropdef
self.debug("Discovered {mpropdef}")
end
- if args.length < mpropdef.msignature.arity + 1 or args.length > mpropdef.msignature.arity + 1 then
- fatal("NOT YET IMPLEMENTED: Invalid arity for {mpropdef}. {args.length} arguments given.")
- end
- if args.length < mpropdef.msignature.arity + 1 then
- fatal("NOT YET IMPLEMENTED: default closures")
- end
+ assert args.length == mpropdef.msignature.arity + 1 else debug("Invalid arity for {mpropdef}. {args.length} arguments given.")
# Look for the AST node that implements the property
var mproperty = mpropdef.mproperty
if initprop != null then
self.send(initprop, [mobj])
end
- self.check_init_instance(mobj)
var mainprop = mmod.try_get_primitive_method("main", sys_type.mclass)
if mainprop != null then
self.rt_send(mainprop, [mobj])
# continue reading commands from the console input
fun process_debug_command(command:String): Bool
do
- # For lisibility
- print "\n"
-
- # Kills the current program
- if command == "kill" then
- abort
# Step-out command
- else if command == "finish"
+ if command == "finish"
then
return step_out
# Step-in command
# Continues execution until the end
else if command == "c" then
return continue_exec
+ else if command == "nit" then
+ printn "$~> "
+ command = gets
+ var nit_buf = new FlatBuffer
+ while not command == ":q" do
+ nit_buf.append(command)
+ nit_buf.append("\n")
+ printn "$~> "
+ command = gets
+ end
+ step_in
+ eval(nit_buf.to_s)
+ else if command == "quit" then
+ exit(0)
+ else if command == "abort" then
+ print stack_trace
+ exit(0)
else
var parts_of_command = command.split_with(' ')
# Shows the value of a variable in the current frame
# Untraces the modifications on a variable
else if parts_of_command.length == 2 and parts_of_command[0] == "untrace" then
process_untrace_command(parts_of_command)
- # Lists all the commands available
else
- list_commands
+ print "Unknown command \"{command}\""
end
end
return true
print "\nEnd of current instruction \n"
else if parts_of_command[1] == "stack" then
print self.stack_trace
- else if parts_of_command[1].has('[') and parts_of_command[1].has(']') then
+ else if parts_of_command[1].chars.has('[') and parts_of_command[1].chars.has(']') then
process_array_command(parts_of_command)
else
var instance = seek_variable(get_real_variable_name(parts_of_command[1]), frame)
var bp = get_breakpoint_from_command(parts_of_command)
if bp != null then
place_breakpoint(bp)
- else
- list_commands
end
end
remove_breakpoint(self.curr_file, parts_of_command[1].to_i)
else if parts_of_command.length >= 3 and parts_of_command[2].is_numeric then
remove_breakpoint(parts_of_command[1], parts_of_command[2].to_i)
- else
- list_commands
end
end
# Processes an array print command
fun process_array_command(parts_of_command: Array[String])
do
- var index_of_first_brace = parts_of_command[1].index_of('[')
+ var index_of_first_brace = parts_of_command[1].chars.index_of('[')
var variable_name = get_real_variable_name(parts_of_command[1].substring(0,index_of_first_brace))
var braces = parts_of_command[1].substring_from(index_of_first_brace)
# Gets all the identifiers of an instruction (uses the rules of Nit as of Mar 05 2013)
#
- fun get_identifiers_in_current_instruction(instruction: AbstractString): Array[String]
+ fun get_identifiers_in_current_instruction(instruction: Text): Array[String]
do
var result_array = new Array[String]
- var instruction_buffer = new Buffer
+ var instruction_buffer = new FlatBuffer
var trigger_char_escape = false
var trigger_string_escape = false
var trigger_concat_in_string = false
- for i in instruction do
+ for i in instruction.chars do
if trigger_char_escape then
if i == '\'' then trigger_char_escape = false
else if trigger_string_escape then
if i.is_alphanumeric or i == '_' then
instruction_buffer.add(i)
else if i == '.' then
- if instruction_buffer.is_numeric or (instruction_buffer[0] >= 'A' and instruction_buffer[0] <= 'Z') then
+ if instruction_buffer.is_numeric or (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then
instruction_buffer.clear
else
result_array.push(instruction_buffer.to_s)
trigger_concat_in_string = false
trigger_string_escape = true
else
- if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer[0] >= 'A' and instruction_buffer[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
+ if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
instruction_buffer.clear
end
end
end
- if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer[0] >= 'A' and instruction_buffer[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
+ if instruction_buffer.length > 0 and not instruction_buffer.is_numeric and not (instruction_buffer.chars[0] >= 'A' and instruction_buffer.chars[0] <= 'Z') then result_array.push(instruction_buffer.to_s)
return result_array
end
# Takes a function call or declaration and strips all but the arguments
#
- fun get_function_arguments(function: AbstractString): String
+ fun get_function_arguments(function: Text): String
do
- var buf = new Buffer
+ var buf = new FlatBuffer
var trigger_copy = false
- for i in function do
+ for i in function.chars do
if i == ')' then break
if trigger_copy then buf.add(i)
if i == '(' then trigger_copy = true
fun get_real_variable_name(name: String): String
do
var explode_string = name.split_with(".")
- var final_string = new Buffer
+ var final_string = new FlatBuffer
for i in explode_string do
var alias_resolved = get_variable_name_by_alias(i)
if alias_resolved != null then
# Returns an array containing all the indexes demanded
fun process_index(index_string: String): nullable Array[Int]
do
- var from_end_index = index_string.index_of('.')
- var to_start_index = index_string.last_index_of('.')
+ var from_end_index = index_string.chars.index_of('.')
+ var to_start_index = index_string.chars.last_index_of('.')
if from_end_index != -1 and to_start_index != -1 then
var index_from_string = index_string.substring(0,from_end_index)
# Returns an array containing their content
fun remove_braces(braces: String): nullable Array[String]
do
- var buffer = new Buffer
+ var buffer = new FlatBuffer
var result_array = new Array[String]
var last_was_opening_bracket = false
- for i in braces do
+ for i in braces.chars do
if i == '[' then
if last_was_opening_bracket then
return null
then
bp.set_max_breaks(1)
place_breakpoint(bp)
- else
- list_commands
end
end
fun get_char(value: String): nullable Instance
do
if value.length >= 1 then
- return char_instance(value[0])
+ return char_instance(value.chars[0])
else
return null
end
end
end
- #######################################################################
- ## Command listing function ##
- #######################################################################
-
- # Lists the commands available when using the debugger
- fun list_commands
- do
- print "\nCommand not recognized\n"
- print "Commands accepted : \n"
- print "[break/b] line : Adds a breakpoint on line *line_nb* of the current file\n"
- print "[break/b] file_name line_nb : Adds a breakpoint on line *line_nb* of file *file_name* \n"
- print "[p/print] variable : [p/print] * shows the status of all the variables\n"
- print "[p/print] variable[i] : Prints the value of the variable contained at position *i* in SequenceRead collection *variable*\n"
- print "[p/print] variable[i..j]: Prints the value of all the variables contained between positions *i* and *j* in SequenceRead collection *variable*\n"
- print "[p/print] stack: Prints a stack trace at current instruction\n"
- print "Note : The arrays can be multi-dimensional (Ex : variable[i..j][k] will print all the values at position *k* of all the SequenceRead collections contained between positions *i* and *j* in SequenceRead collection *variable*)\n"
- print "s : steps in on the current function\n"
- print "n : steps-over the current instruction\n"
- print "finish : steps out of the current function\n"
- print "variable as alias : Adds an alias called *alias* for the variable *variable*"
- print "An alias can reference another alias\n"
- print "variable = value : Sets the value of *variable* to *value*\n"
- print "[d/delete] line_nb : Removes a breakpoint on line *line_nb* of the current file \n"
- print "[d/delete] file_name line_nb : Removes a breakpoint on line *line_nb* of file *file_name* \n"
- print "trace variable_name [break/print] : Traces the uses of the variable you chose to trace by printing the statement it appears in or by breaking on each use."
- print "untrace variable_name : Removes the trace on the variable you chose to trace earlier in the program"
- print "kill : kills the current program (Exits with an error and stack trace)\n"
- end
end
redef class AConcreteMethPropdef