fun4jimmy.blog

This post will cover how to set the default text editor used by git or mercurial via the command line. The default text editor is used whenever the version control system requires us to enter a message, like a commit message.

Although we will set the editor from the command line on Linux and Windows bear in mind that for Linux the best way to set the preferred text editor is using environment variables. Both version control systems will check the $(VISUAL) and $(EDITOR) Linux environment variables (in that order of precedence) if no editor has been set. As they control the default text editor for the OS it makes sense to stick to just using those but we will still cover how to set via the command line as an example.

continue reading

This post covers the starting steps required to start developing c or c++ programs for Linux inside Windows 10 using Bash on Ubuntu on Windows.

Since the Windows 10 Anniversary Update (build 10.0.14393, version 1607) there is an Ubuntu bash shell available from within Windows without the need for a virtual machine or dual booting. Unlike Cygwin or MinGW it runs real Linux binaries directly from within Windows. This allows us to edit, compile and run Linux applications from Windows without the need for switching computers or operating systems.

continue reading

Due to a bug in the current build of Visual Studio 2015 C++ comments starting with three forward slashes are highlighted in a different colour to all other comments.

The colour difference is most visible when using the Dark colour theme but is present in the Light and Blue colour themes as well and has been observed in both the Community Edition and Professional Edition.

continue reading

This post assumes you're familiar with and using Python's logging module to log info from your script. If you don't care about how it works skip to the end to see the code for the full solution.

Goal

Our goal is to control the log level via the command line using an additional argument --log_level that takes a one of the logging module's log levels.

$> script.py --log_level DEBUG

And it would be nice if the parsed variable returned by argparse.ArgumentParser.parse_args() could be used directly as an argument to logging.Logger.setLevel.

parsed_args = parser.parse_args()

root_logger = logging.getLogger()
root_logger.setLevel(parsed_args.log_level)

continue reading

A collection of some useful snippets for batch files.

Controlling batch file output

To stop every line of the batch file being output to the command prompt put this at the top of the batch file, this makes for a less noisy output.

@echo off

Echo the output of a command, useful for logging what the batch file is actually doing.

for /f %%i in ('dir') do echo %%i

continue reading

ThoughtWorks Go is a continuous delivery system that has recently become open source and free to use. This guide will talk you through the steps necessary to get the Go Server up and running as a Mac OS X Launch Daemon so there is no need to log in to start the server.

So we don't tie our Go Server instance to an existing user account we should create another account just for running the server. This allows other users to help with server maintenance without us having to give out our credentials and it also prevents us from accidentally messing up our account if anything goes wrong. Let's create a new administrator account with the username build and log in.

As Go Continuous Delivery is written in Java we should install the latest version of Java if it's not already installed.

continue reading

For a good introduction in to using libclang and Python see here.

Assuming that you can or have built libclang with the Python bindings, below is a script that loops through all the #include statements in a single C/C++ file printing out the files they reference.

continue reading

If you close all open instances of Visual Studio 2012 add the following undocumented registry key to your registry:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\11.0\General]
"EnableVSIPLogging"=dword:00000001

When you next start Visual Studio you can find the command ID for menu items by holding Ctrl+Shift and hovering over the menu item. After hovering you are presented with a modal dialog containing debug information as seen in the image to the right. This information can, for example, be useful in .vsct files when extending Visual Studio functionality.

This will work for most menu items although Ctrl+Shift hovering over dynamic menu items like those found on DEBUG menu will for some reason not pop up the dialog.

This information is shamelessly stolen from this MSDN blog post which also contains more in depth information about the topic.

continue reading

This post will cover how to export functions from a windows dynamic-link library starting with the basics and then covering some more advanced examples. The first part of this explanation is very similar to this msdn article, so if you already know that you may want to skip ahead to the [Advanced Exporting]({{ page.url | prepend: site.baseurl }}#advanced-exporting) section.

Basic Exporting

So let's start with the basics, to export a function from a dll you need to inform the compiler which functions and classes you want to be accessible from the library. This can be done in multiple ways but the simplest is to use __declspec(dllexport) to markup the functions or classes when declaring and __declspec(dllimport) when using them.

// function declaration in library header
//
__declspec(dllexport) void function();

// function declaration in executable source
//
__declspec(dllimport) void function();

continue reading

This post will cover some less common syntax that is useful when dealing with templates. The class used to demonstrate the syntax is only as an example, it is not supposed to be a good example of a working smart pointer class.

Let's start with a simple SmartPointer class and how to write template function definitions outside of the class definition:

// define the class
//
template<typename PointerType>
class SmartPointer
{
public:
  SmartPointer(PointerType *pointer);
  ~SmartPointer();

private:
  PointerType *m_pointer;
};

// define the member functions
//
template<typename PointerType>
inline SmartPointer<PointerType>::SmartPointer(PointerType *pointer)
: m_pointer(pointer)
{
  // do some stuff
}

template<typename PointerType>
inline SmartPointer<PointerType>::~SmartPointer(PointerType *pointer)
{
  // do some stuff
}

continue reading