Archive

Posts Tagged ‘command-line’

ogc 4.2 – Math Functions

August 22nd, 2010 subogero No comments

The introduction of the lex (flex) tokenizer into the ogc development allows an incredible amount of new bloatware to be implemented. The first menacing omen was floating-point support.

And now it’s math functions. Our friends from <math.h> sin, cos, atan, log, exp, sqrt are available as @s @c @a @l @e @r. The little bastards, besides looking very ugly, also perform a sneaky implicit floating-point conversion.

Check it out. But where will this all end?

ogc 4.1 – Floating But Not Sinking

August 3rd, 2010 subogero No comments

Erm… ogc 4.0 had some certain erm… bugs in its syntax.

But ogc 4.1 is now downloadable from the ogc page. Including native Linux and Windows binaries.

The mapis Page

September 12th, 2009 subogero No comments

Ever wondered how difficult it is to send email from a script, if the company you work for is locked into the prison guarded by Windows, Exchange and Outlook?

It’s all right to have a nice script for a software-release process, but what about notifying the interested parties about the release automatically?

Your first shot may be a Visual Basic script. It can create an Outlook email object and write its various fields. There is a small problem though. Outlook is a paranoid little bastard, and asks for your permission for the program to change the email’s fields. And asks it using a dialog-box.

But the casual observer may notice that some programs can pop-up pre-filled Outlook email windows like a breeze. 7-Zip springs to the lips. Right-click something, select `Compress to “foo.7z” and email’, and there pops up the email window with the attachment. No questions asked.

There is actually a very good reason why it’s 7-Zip that springs to the lips. Because it’s FOSS. Free and Open-Source Software. Step forward Igor Pavlov. I don’t want to go into details why, besides being FOSS, 7-Zip is the best archiving program ever, I’d just like to mention the facts that it has a command line interface, an mc-like two-pane GUI, Windows context menu-integration, and the best compression performance.

So I ended up downloading the source, and after a bit of searching I had the solution. Use the interface provided by “mapi.h”. Later I found out that there is a similar program called MAPIsend.exe in the MS BackOffice Resource Kit. A relaxed Hacker might wonder how Redmond invents these names. Anyway, `mapis’ ended up with having nearly identical calling parameters as MAPIsend.

The download package includes sources and the native Win32 binary. Compiled on Linux! Did I mention 7-Zip? It can unpack 7z archives.

Download mapis.7z

Installation:

Save downloaded archive in a new folder called mapis
Unpack archive `7z x  mapis.7z’
Open a cygwin bash window in this folder
Type `make install’
See `man mapis’ or `mapis -h’ for usage

If you don’t have cygwin, get cygwin immediately, but until then just copy the `bin/mapis.exe’  file into a folder which is in PATH, e.g. c:\WINDOWS

Send a simple email to Master Foo, but first check everything in an email window:

mapis -r "Master Foo" -s "The Foo Subject" -m "The Foo message body."

Send another email straight away to Master Foo, copy to the Master Programmer, attach “c:\foo.c” and take the slightly longer message body from file “foomessage.txt”. Oh, and the MCSE shall receive a secret copy, just to scare him with the capabilities of Linux/gcc/mingw32.

mapis -q -r "Master Foo" -c "Master Programmer" -b MCSE \
      -s "foo source" -f c:\foo.c -t foomessage.txt

Yo.

The go Page

August 7th, 2009 subogero No comments
Go’s goal

“go” is a general-purpose command-line launcher for Gnome/Linux, an extended “gnome-open” which can open URLs, files or even programs in a new window. A bit like Windows “start”, just better.

“go” will open a new terminal window.

“go <CLI program>” will open it in a new fully independent terminal window.

“go <GTK+ program>” will open it in a fully independent window.

“go <URL>” will open it with the preferred application.

By an “independent window” I mean two things:

The starting terminal is not blocked while the started app is running;

Closing the starting terminal does not kill the started app.

Bonus: start a Google search for “foo bar” in your preferred browser with

google foo bar
Installation:

Download go.tar.gz and extract files in a new directory, preferably “go”.
Type “sudo make” for installation.
Enjoy.

Lessons learned:

How to decide if an argument of a shell-script is a program?

which $1
#prints the location of the command, or nothing if not a command

How to check if a shell-script has no arguments at all?

if [ $# -eq 0 ]

How to check if the last command returned no error in its exit status?

if [ $? -eq 0 ]

The trickiest: how to tell if a command is a terminal- or a GTK+ application?

Search for “libgtk-x11″ in it if it’s a compiled program.
Search for the respective gtk dependency if it’s an interpreter-script:

import gtk # Python
use Gtk2   # Perl

“go” knows these two at the moment, but the list should be extended to all known interpreted languages and graphical toolkits. Actually it should work the other way around, detecting terminal-only applications. But for instance Gimp contains the strings “stdin”, “stdout”, “stderr” and “printf” so I gave up.

I’ve created my first ever very officially looking manual page for “go”, credit goes to Jens Schweikhardt’s very helpful LINUX MAN PAGE HOWTO.

Tao in go

There is more Tao in “go” than in Windows “start”:

Try to start a native Windows program from command line which DOES NOT become fully detached, but blocks your command-line until it closes and returns an exit-status. Hmmm? On Linux, just omit “go”.

On Windows, the commands are scattered around in thousand folders, not listed in the PATH variable. On Linux, on the other hand, all commands are on the PATH, as there are only a few standard places to store them: /bin:/usr/bin:/usr/local/bin. So “go” can access them all.

View the manual page?

man go

Finally, how do you edit the “go” script itself?

go gedit go

The ogc Page

July 30th, 2009 subogero No comments

ogc is the Lazy Man’s command line calculator, crunching the maximum number of numbers with the minimum number of keystrokes. The Lazy Man is called OG.

If you you’re lazy too;
If you’re fond of binary, octal and hex formats;
If you hate typing too much;
If you hate mouse-clicking even more;
If you hate calculators going floating-point after the first division;
If you still need floating-point occasionally;
If you typo a lot and prefer to undo them all;
If you like to comment your calculations (well, you don’t, but it’s possible):

Accept no substitute! Use ogc.

Features

  • 32-bit integer or floating-point arithmetic
  • decimal, binary, octal or hexadecimal format (commands d, b, o, x)
  • input of expressions, variable assignments and commands on stdin
  • output of calculations on stdout
  • error messages (syntax error, division by zero) or stderr
  • unlimited undo
  • a fair amount of memory registers (G .. Z)
  • operators ()~+- */% &| =
  • symbol _ means last result, like Perl/Python
  • math functions @s @c @a @l @e @r = sin cos atan log exp sqrt
  • missing identifier means _ (+5 means last result + 5) like Perl
  • optional unsigned arithmetic (commands n, s)
  • floating-point mode never upon division, only upon user request, like Python
  • combination if expressions/commands on same line
  • comments starting with #
  • interpreter mode when input file specified
  • manual page

Installation

It can be compiled and installed on Linux or Windows/cygwin.
On Windows, it runs both in cygwin and Windows command line windows.

Download and extract in a new directory (why not ogc?);
Open a cygwin/terminal window there;
Call “make”;
Call “make install” or “sudo make install” (Linux)

Since 4.1, the tarball contains native Linux and Windows binaries.

Download ogc.tar.gz
7-Zip cygwin.org

Examples

Desktop calculator workflow

d 5000    # one steak
5000
d +3*2000 # three whiskies neat
11000
d +1000   # tip
12000
d # This is an expensive restaurant...

Command/statement combination for hex/dec conversion, signed/unsigned modes. Watch the prompt!

d xFFFFd       # change to hex, enter FFFF, change back to dec
65535
d x FFFFFFFF d # change to hex, enter FFFFFFFF, change back to dec
-1
d n            # unsigned (natural number) mode
4294967295
D 240x         # stay in dec, enter 240, change to hex
F0
X d239x        # change to dec, enter 239, change to hex
EF
X

Undo, difference between subtraction and unary minus.

84
d ~42        # Let's subtract 42 ...
-42
d u-42       # Oops, I hit tilde instead of minus
42

Since version 3.0, ogc works as an interpreter as well, an input file can be specified on the command line. This also allows to create executable ogc interpreter scripts. For instance let’s create an executable file called LifeUniverseAndEverything:

#!/usr/bin/ogc
33*2 x

Since version 4.1, ogc supports floats and binary formats. You can even peek into the insides of floats.

d 1+2
3
d /2    # no implicit float-conversion upon division
1
d /2.0  # Pythonic float-conversion if float-format entered
0.5
f b     # let's peek inside
00111111 00000000 00000000 00000000
f

Background

This is my first shot at a unix-style program. It’s a filter, as in unix nearly everything should be. I tried to follow the Sacred Rules of the Art from esr’s book:

Command line option conventions

-h –help for help
-V –version for version info

Data driven development

The source of the usage and version screens are text files which look exactly like those screens. During make, they are sedded into header files with lists of string initializers. The headers are then included in the middle of const table definitions, to make the text available as a list of strings, line by line.

Write programs to write programs

I used Lex and Yacc to parse the input and to write the syntax. I can still hardly believe what these nearly 40 year old tools can do.

ogc – The OG Calculator

July 29th, 2009 subogero No comments

So my yacc studies led me to a series of thoughts about writing my own command-line calculator with integer arithmetics. Which the Windows Calculator is not.

I set the following goals:

  • 32-bit integer arithmetics (don’t ask me why, I just need it at work, OK?)
  • decimal, octal and hexadecimal formats
  • unlimited undo
  • a fair amount of memory registers
  • ability to continue from the last result (+5 should add 5 to the last result)
  • no mouse clicking
  • following Unix/GNU conventions

The program’s called ogc. I wrote it in yacc surprisingly quickly. The related info and the sources are available on my dedicated ogc page.

Categories: posts Tags: , , ,