Save the contents of a variable in Xcode Debugger - xcode

Running the debugger in Xcode when you set a breakpoint you get a view a variable and can see all of the fantastically interesting values associated with it.
Is there any way to save/export this data to a file?
I am of course having an issue where something is wrong but there is a ton of variables and I want to just compare one run of the program to the next easily.

You can use gdb for this. The following gdb commands are useful:
set log file <filename>
set logging on
... do interesting stuff ...
set logging off
This will log the section "do interesting stuff" to as a text file.
If you want to get really fancy and have a fixed set of commands/variables you want to dump, you can make a function and stick it in $HOME/.gdbinit. Then get to a breakpoint and just issue dumplog (if using the example below) at the gdb prompt.
# Example that just does some random stuff
define dumplog
set logging file foo.txt
b main
c
set logging on
po var1
po var2
set logging off
end
Another approach which I just learned is issuing the following from a terminal. It has the benefit of no manual intervention, but I just tried it and you get quite a bit of extra garbage in that file.
defaults write com.apple.Xcode PBXGDBDebuggerLogToFile YES
defaults write com.apple.Xcode PBXGDBDebuggerLogFileName <filename>

When you hover over a value, click on the double-headed arrows and you get a pop-up menu with a lot of options:
alt text http://idisk.mac.com/cdespinosa/Public/Print%20Description.png
Print Description will dump the information about the object to the gdb console, from which you can copy and paste it.

Related

Save Live Watch variable in IAR Workbench as LOG file

I don't know if it's possible as the IAR Workbench manual doesn't cite something like that but I would like to generate some sort of LOG from the LIVE Watch variables.
For istance, if I'm live watching var1 I would like to generate a formatted text file like:
16-05-2022 11:51:01 var1 120
16-05-2022 11:51:02 var1 122
16-05-2022 11:51:03 var1 116
16-05-2022 11:51:04 var1 102
Is there a way to do that? Or at least to read this kind of information somewhere so I can write some sort of code in python or something to read the values?
I'm using IAW Workbench 6.5
So it turned out there's no way to actually save the variables as LOG.
The only workaround is to use breakpoints and macros to dump the value but, unfortunately, this is not a solution on my end as the breakpoints need user intervention to start again the code

How to debug script-fu scripts for gimp in scheme?

I try to make some script for gimp, using script-fu, scheme.
Naturally, as a beginner, there are lots of errors and misunderstandings.
Now I'm looking for a way to debug those scripts.
I found (gimp-message), but the result does not show up. I'm not aware if there is a possibility to print debug messages to anywhere I could check them.
Generating new images filled with text would probably work ;-) but looks a bit like an overkill.
What ways to debug a script in gimp are there?
There may be a better way, but, the way I do it is to:
open the script fu console (Filters -> Script Fu -> Console)
edit a file (say for example: /Users/jamesanderson/code/scheme/gimp/learn1.scm
type: (load "/Users/jamesanderson/code/scheme/gimp/learn1.scm") into the console
hit enter
edit file for changes
keyboard arrow up (to get get the load function call again without typing)
hit enter
Note this is an extension of my answer based on the comment. When going beyond the simple proof of concept scripts like the above, its important to know that that console retains state between calls. So for instance, if we run this scheme script:
(define jea-test-img-id nil)
(define (jea-find-test-img)
(car (gimp-image-list)))
and then go to the console and type:
jea-test-img-id
we get as a result:
> jea-test-img-id
()
which is good, the script initiated the variable as needed and we see the result. So var set in script, console retains state change from script. Now lets change the state in the console:
(set! jea-test-img-id (jea-find-test-img))
we call a convenience function that grabs the first image ID in the active image list and store it in the variable we previously declared (which was then nil). Now lets examine the question again:
jea-test-img-id
then the result:
> jea-test-img-id
1
so high level: when you are working on a script, create working variables that hold the things you want to work on, like image, pxiels, widths etc then piece by piece get the functions working. In the end you may collapse it into one clean function once you have the short snippet pieces.
The output of gimp-message goes to the "Error console" (if you have this dockable dialog setup), otherwise in a warning dialog.
If you are in Linux or OSX, you can also start Gimp from a terminal and use (print ...) calls, they will show in the terminal.
You can make your life easier and write your scripts in Python (easier to learn, and more powerful...). See here for the doc, here for some examples, and here for some debug tricks for Windows.
If you run gimp from the command line with the -c flag, messages are printed in the terminal:
$ gimp -c myfile.xcf
# run my plugin from the GUI menu
My Plugin-Warning: this is a message
Tested with GIMP v2.10.18 see gimp --help for more command line options.

How to test that `clear` command is working correctly in BASH?

Now i try find the way to prove that a clear command is working correctly on my own REPL
Example
$ cd ~
$ pwd
/home/user
$ echo "hello"
hello
then type clear
$
but sometime some unexpected behavior is occurred after using a clear command
e.g.
[one blank line here]
$
A one blank line after using clear command is undesirable behavior and I hope this kind of bug can be detected automatically via a unit test. If you have any idea to prove that clear command is working correctly please purpose.
There is no easy way to do this. "clear" sends a sequence of bytes that tells the terminal to clear its screen. Different terminals use different sequences. There is a table called "termcap" (terminal capabilities) that lists the difference sequences for different types of terminals. The environment variable "TERM" should be set to the type of terminal you are using.
TERM is usually set to "xterm", "xterm-color", "vt100", or related value. On my Mac OS X Terminal it is set to "xterm-256color".
TERM should be set automatically for you. If your OS is set up properly you shouldn't have to set it yourself. However in the old days you had to set it manually. Therefore you'll find a lot of old .profile/.bashrc/.cshrc files that set it. Check to see if that is happening and remove that (comment it out) to see what is automatically set.
Your question boils down to "how can I tell if my TERM variable is set right?" and the answer is: You can't. You could do things like clear the screen then ask the user if they saw their screen clear. However, if programs did that on start-up, it would be very annoying.

Rstudio difference between run and source

I am using Rstudio and not sure how options "run" and "source" are different.
I tried googling these terms but 'source' is a very common word and wasn't able to get good search results :(
Run and source have subtly different meanings. According to the RStudio documentation,
The difference between running lines from a selection and invoking
Source is that when running a selection all lines are inserted
directly into the console whereas for Source the file is saved to a
temporary location and then sourced into the console from there
(thereby creating less clutter in the console).
Something to be aware of, is that sourcing functions in files makes them available for scripts to use. What does this mean? Imagine you are trying to troubleshoot a function that is called from a script. You need to source the file containing the function, to make the changes available in the function be used when that line in the script is then run.
A further aspect of this is that you can source functions from your scripts. I use this code to automatically source all of the functions in a directory, which makes it easy to run a long script with a single run:
# source our functions
code.dir <- "c:\temp"
code.files = dir(code.dir, pattern = "[.r]")
for (file in code.files){
source(file = file.path(code.dir,file))
}
Sometimes, for reasons I don't understand, you will get different behavior depending on whether you select all the lines of code and press the run the button or go to code menu and chose 'source.' For example, in one specific case, writing a gplot to a png file worked when I selected all my lines of code but the write failed to when I went to the code menu and chose 'source.' However, if I choose 'Source with Echo,' I'm able to print to a png file again.
I'm simply reporting a difference here that I've seen between the selecting and running all your lines and code and going to code menu and choosing 'source,' at least in the case when trying to print a gplot to a png file.
An important implication of #AndyClifton's answer is:
Rstudio breakpoints work in source (Ctrl-Shift-S) but not in run (Ctrl-Enter)
Presumably the reason is that with run, the code is getting passed straight into the console with no support for a partial submission.
You can still use browser() though with run though.
print() to console is supported in debugSource (Ctrl-Shift-S) as well as run.
The "run" button simply executes the selected line or lines. The "source" button will execute the entire active document. But why not just try them and see the difference?
I also just discovered that the encoding used to read the function sourced can also be different if you source the file or if you add the function of the source file to your environment with Ctrl+Enter!
In my case there was a regex with a special character (ยต) in my function. When I imported the function directly (Ctrl+Enter) everything would work, while I had an error when sourcing the file containing this function.
To solve this issue I specified the encoding of the sourced file in the source function (source("utils.R", encoding = "UTF-8")).
Run will run each line of code, which means that it hits enter at the beginning of each line, which prints the output to the console. Source won't print anything unless you source with echo, which means that ggplot won't print to pngs, as another posted mentioned.
A big practical difference between run and source is that if you get an unaccounted for error in source it'll break you out of the code without finishing, whereas run will just pass the next line to the console and keep going. This has been the main practical difference I've seen working on cleaning up other people's scripts.
When using RSTudio u can press the run button in the script section - it will run the selected line.
Next to it you have the re - run button, to run the line again. and the source button next to it will run entire chuncks of code.
I found a video about this topic:
http://www.youtube.com/watch?v=5YmcEYTSN7k
Source/Source with echo is used to execute the whole file whereas Run as far as my personal experience goes executes the line in which your cursor is present.
Thus, Run helps you to debug your code. Watch out for the environment. It will display what's happening in the stack.
To those saying plots do not show. They won't show in Plots console. But you can definitely save the plot to disc using Source in RStudio. Using this snippet:
png(filename)
print(p)
dev.off()
I can confirm plots are written to disc. Furthermore print statements are also outputted to the console

How to step through an R script from the beginning?

I want to step through an R script. I saw the "debug" command while searching for how to do this but that seems to only apply to functions. This script doesn't have any functions.
The "browser" command looked promising so I put "browser()" as the first line of my script but it didn't seem to do anything when I ran it.
How do I get the script to pause on the first line so I can step through it?
I was racking my brain trying to figure this out (stepping through a script without a specific function to call) in RStudio's IDE Version 0.98.1102.
Solution for a new script in RStudio:
Create a new R script (ctrl+shift+n)
Enter code in the file
Set a break point by
a) clicking left of the code line number where you want to set a break point (red dot) or
b) adding browser() to the code line where you want to set a break point
Save the file
Enter debugging mode and source the file by
a) checking the Source on Save box (above the Source window) and then saving the file,
b) clicking the Source button at the top-right of the Source window,
c) entering debugSource("<yourfilename>") + enter in the Console, or
d) entering ctrl+shift+s
Go through the debugging process
For more steps on debugging in RStudio, see this help file
(dated April 23, 2015 12:59).
I'm partial to RStudio, so I recommend the following:
Download RStudio
Open your R Script
put your cursor on the first line
click ctrl + enter (PC/Linux) or command + return (Mac)
repeat!
A nice feature of RStudio is that RStudio server can run great on a headless server. You then connect to the server via http in a web browser on your local machine. I use this configuration when running R on EC2 instances. RStudio maintains state so if I lose internet access on my train ride, when I get signal back RStudio picks up exactly where I left off and my remote machine has no idea that I disconnected and reconnected. Note that RStudio server is currently only supported on FC/CentOS and Debian/Ubuntu. Although it may compile under other variants of *nix.
One popular way is to do this from your 'IDE' or editor -- Emacs / ESS do it very well, others do it too.
The basic idea is that you send either the line under the cursors, or function, or block, ... to the associated R process. Several other editors support this, including RStudio. My preference is still with ESS, but I am sure you can find something suitable.
Lastly, browser() et al can do that from within the R process but it is a little less pointy-clickety. Read the documentation, or books like Chambers "Software for Data Analysis" (Springer, 2008).
For an R only solution, which evaluates complete expressions rather than individual lines, try this:
sourcep <- function(file){
coms <- parse(file)
for (i in seq_along(coms)){
print(coms[[i]])
eval(coms[[i]],envir=.GlobalEnv)
mess <- paste("Expression",i,"of",length(coms),"parsed. Press <return> to continue.")
cat(mess)
readLines(n=1)
}
}
You call this as you would call source (though this is much more basic and doesn't include any of its options). Basically, it uses parse to create a list of the parsed, but unevaluated expressions from your source file, then iterates through this list to print the expression, evaluate it in the global environment and then put a message to indicate the progess. The final line is the one that creates the pausing: a call to read a single line from stdin().
You mention in a comment that you run your code with Rscript, but to debug you need to run it interactively. In other words, to get browser to "work", start up a regular R console and source your script. Since the first line of the script is browser(), you'll immediately get back to the prompt, at which you can use "n" to single step through the code. But, since it's a full-blown R prompt, you can also check or change any variable value just by typing its name or assigning to it. (Or indeed, invoke arbitrary R functions.)
As suggested in another answer, inserting browser() at the beginning of your script, getting an interactive session by running R rather than Rscript, and then using source('myscript.Rscript') from R will do the trick if your script does not require commadline arguments (e.g. like those processed by argparse).
If you do need to run with commandline args, you can simply invoke R with the --args options (e.g. R --no-restore --no-save --args <your commandline args here>) and the sourced script will see the arguments as if it had been invoked using Rscript. There are other solutions to the question of how to pass commandline args to source, but they don't target this specific use case where source will be called only once.

Resources