FBlag - Informatik

Xmonad and uzbl-browser

nospam@example.com (Frank) — Tue, 06 Sep 2011 20:14:17 +0200

Every release of Opera seems to add more bugs¹ and useless features², whereas Firefox is featureless and slow without or feature-rich and ineffable slow with Add-ons. Time for an alternative! What I want is a small browser with external configurable handlers. What I don't need is qt-bloat, a Firefox clone or something with lua in it. uzbl seems to fit, but I'm tired of learning new shortcuts for tabbing implementations. Everyone and his brother integrate tabs (terminal multiplexer, terminal, browser, editor...) but only one application should obviously manage tabs - the window manager. It turned out that my original configuration of xmonad wasn't the optimal solution. I'd like to have the following behaviour:

First workspace: keep master, switch focus to new window



+---------------+    +-----------+---+

|               |    |           | 2 |

|               |    |           |   |

|       1       | -> |     1     | f |

|    (focus)    |    |           | o |

|               |    |           | c |

|               |    |           | . |

+---------------+    +-----------+---+

Second to fourth workspace: switch master and focus



+---------------+    +-----------+---+

|               |    |           | 1 |

|               |    |           |   |

|       1       | -> |     2     |   |

|    (focus)    |    |  (focus)  |   |

|               |    |           |   |

|               |    |           |   |

+---------------+    +-----------+---+

Fifth workspace (for browsing): keep master and focus and use tabbed layout (open new links/tabs in background)



+---------------+    +-------+-------+

+---------------+    +-------+-------+

|               |    |               |

|       1       | -> |       1       |

|    (focus)    |    |    (focus)    |

|               |    |               |

|               |    |               |

+---------------+    +---------------+

These are the steps that were necessary to achieve this:

1. copy xmonad-contrib-0.9.2/XMonad/Hooks/InsertPosition.hs to ./xmonad/lib/
2. apply the patch (sorry, no google account and no desire to install darcs again):

--- InsertPosition.hs
+++ InsertPositionNew.hs
@@ -16,15 +16,16 @@
module XMonad.Hooks.InsertPosition (
-- * Usage
-- $usage
- insertPosition
+ insertPosition,
+ insertPositionPerWorkspace
,Focus(..), Position(..)
) where

-import XMonad(ManageHook, MonadReader(ask))
+import XMonad(ManageHook, MonadReader(ask), WorkspaceId)
import qualified XMonad.StackSet as W
import Control.Applicative((<$>))
import Data.Maybe(fromMaybe)
-import Data.List(find)
+import Data.List(find,lookup)
import Data.Monoid(Endo(Endo))

-- $usage
@@ -44,26 +45,30 @@
-- | insertPosition. A manage hook for placing new windows. XMonad's default is
-- the same as using: @insertPosition Above Newer@.
insertPosition :: Position -> Focus -> ManageHook
-insertPosition pos foc = Endo . g <$> ask
+insertPosition = insertPositionPerWorkspace []
+
+-- | Specify an insertPosition for a particular Workspace.
+insertPositionPerWorkspace :: [(WorkspaceId, (Position, Focus))] -> Position -> Focus -> ManageHook
+insertPositionPerWorkspace l pos foc = Endo . g <$> ask
where
- g w = viewingWs w (updateFocus w . ins w . W.delete w)
- ins w = (\f ws -> fromMaybe id (W.focusWindow <$> W.peek ws) $ f ws) $
- case pos of
+ g w = viewingWs w (\i -> updateFocus i w . ins i w . W.delete w)
+ ins i w = (\f ws -> fromMaybe id (W.focusWindow <$> W.peek ws) $ f ws) $
+ case fst $ fromMaybe (pos,foc) (lookup i l) of
Master -> W.insertUp w . W.focusMaster
End -> insertDown w . W.modify' focusLast'
Above -> W.insertUp w
Below -> insertDown w
- updateFocus =
- case foc of
+ updateFocus i =
+ case snd $ fromMaybe (pos,foc) (lookup i l) of
Older -> const id
Newer -> W.focusWindow

-- | Modify the StackSet when the workspace containing w is focused
-viewingWs :: (Eq a, Eq s, Eq i, Show i) =>a-> (W.StackSet i l a s sd -> W.StackSet i l a s sd)-> W.StackSet i l a s sd-> W.StackSet i l a s sd
+viewingWs :: (Eq a, Eq s, Eq i, Show i) =>a-> (i -> W.StackSet i l a s sd -> W.StackSet i l a s sd)-> W.StackSet i l a s sd-> W.StackSet i l a s sd
viewingWs w f = do
i <- W.tag . W.workspace . W.current
ws <- find (elem w . W.integrate' . W.stack) . W.workspaces
- maybe id (fmap (W.view i . f) . W.view . W.tag) ws
+ maybe id (fmap (W.view i . f i) . W.view . W.tag) ws

-- | 'insertDown' and 'focusLast' belong in XMonad.StackSet?
insertDown :: (Eq a) => a -> W.StackSet i l a s sd -> W.StackSet i l a s sd

3. reconfigure ./xmonad/xmonad.hs

add imports:

import InsertPositionNew
import XMonad.Hooks.ManageHelpers
import XMonad.Layout.PerWorkspace

add shortcut for uzbl-browser:

, ((modm, xK_u), spawn "uzbl-browser")

change layout hook:

myLayout =
modWorkspaces myWorkspaces avoidStruts $
onWorkspace "5:www" simpleTabbedAlways $
tiled ||| Mirror tiled ||| simpleTabbedAlways ||| Full
where
-- default tiling algorithm partitions the screen into two panes
tiled = Tall nmaster delta ratio

-- The default number of windows in the master pane
nmaster = 1

-- Default proportion of screen occupied by master pane
-- ratio = 1/2
ratio = 7/10

-- Percent of screen to increment by when resizing panes
-- delta = 3/100
delta = 5/100

create manage hooks

myManageHookFloat = composeAll
[ className =? "Gimp" --> doFloat
, className =? "MPlayer" --> doFloat
,(className =? "Firefox" <&&> role =? "Manager" ) --> doFloat
] <+> composeOne [
isDialog -?> doCenterFloat
]
where role = stringProperty "WM_WINDOW_ROLE"

myManageHookShift = composeAll
[ className =? "Uzbl-core" --> doShift "5:www"
, className =? "Firefox" --> doShift "5:www" ]

myManageHookPosition = insertPositionPerWorkspace [("1",(Below,Newer)),("5:www",(Below,Older))] Above Newer

combine manage hooks and override the default config:

manageHook = myManageHookFloat <+> myManageHookPosition <+> myManageHookShift,

Done.

¹ last one: the bookmark menu needs 30s to load all bookmarks
² webserver(!), torrent- and unusable mail client

ne keycodes

nospam@example.com (Frank) — Wed, 24 Aug 2011 19:55:20 +0200

To get expected behaviour for home, end and backspace in ne with rxvt-unicode, start ne (the "nice editor"), press Ctrl+k for the command prompt, enter kc and in the new prompt press the specific key for the key code. Afterwards adjust the config file:

>cat .ne/.keys
KEY 105 MoveSOL
KEY 106 MoveEOL
KEY 7f Backspace

checking string routines with Klee

nospam@example.com (Frank) — Tue, 09 Aug 2011 19:14:29 +0200

Two months ago I discovered some bugs in libpng (CVE-2011-2501, CVE-2011-2692). In the discussion¹ of the second bug I have criticized that libpng is often too permissive in the chunk validation. An example was the unchecked use of strtod(), which allows "infinity" or "nan" as valid values in the ASCII floating point representation in sCAL or pCAL chunks.

These chunks contain byte strings in a quite simple format:

1.2. Floating-point values

The core of PNG does not use floating-point numbers anywhere; it uses integers or, where applicable, fixed-point fractional values. However, special-purpose chunks may need to represent values that do not fit comfortably in fixed-point notation. The textual floating-point notation defined here is recommended for use in all such cases. This representation is simple, has no a priori limits on range or precision, and is portable across all machines.

A floating-point value in this notation is represented by an ASCII text string in a standardized decimal floating-point format. The string is variable-length and must be terminated by a null (zero) character unless it is the last item in its chunk. The string consists of an optional sign ("+" or "-"), an integer part, a fraction part beginning with a decimal point ("."), and an exponent part beginning with an "E" or "e" and optional sign. The integer, fraction, and exponent parts each contain one or more digits (ASCII "0" to "9"). Either the integer part or the fraction part, but not both, may be omitted. A decimal point is allowed, but not required, if there is no fraction part. The exponent part may be omitted. No spaces or any other character besides those specified may appear.

Note in particular that C-language "F" and "L" suffixes are not allowed, the string "." is not allowed as a shorthand for 0 as in some other programming languages, and no commas or underscores are allowed. This format ought to be easily readable in all programming environments.

Later I wondered, if I can use KLEE to find specification mismatches in string handling routines. And what should I say, it worked. I just tested in one direction: if strtod() returns without an error, the string should be valid according to the PNG specification. Of course that's wrong, but this assumption should reveal the cases where the strtod() implementation and the PNG specification differ.

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#include <klee/klee.h>

int is_png_fp(char* p, char* pe) {
int cs;

%%{
machine png_fp;
write data;

main := [+\-]? (([0-9]+ '.'?) | ([0-9]+ '.' [0-9]+) | ('.' [0-9]+)) ([Ee][+\-]? [0-9]+)?;
write init;
write exec;
}%%

return cs >= png_fp_first_final;
}

int main(int argc, char **argv) {
double d;

// create symbolic string
char *s = "____";
klee_make_symbolic(s,5,"s");
s[4] = '\0';
char *se = s + strlen(s);
char *se_= se;

// call strtod and omit error cases
errno = 0;
d = strtod(s,&se_);
if ((errno != 0) || (s == se_)) {
klee_silent_exit(1);
}

// ---- mismatches ----
// data: '0z\x00\x00\x00' (allowed trailing characters)
if (*se_ != '\0') { klee_silent_exit(2); }
// data: '\x0c0\x00\x00\x00' (allowed leading whitespace)
if (isspace(s[0])) { klee_silent_exit(3); }
// data: 'iNF\x00\x00' (infinity)
if (isinf(d)) { klee_silent_exit(4); }
// data: 'nAN\x00\x00' (not a number)
if (isnan(d)) { klee_silent_exit(5); }

// assertion: s is in png ascii floating point format
assert(is_png_fp(s,se));

return 0;
}

For the description of the floating point strings I used a regular expression. In is_png_fp() this regular expression is converted into an automaton via ragel to forgo unnecessary regex-libraries. If one runs the example code with KLEE, the cases in the "mismatches"-section break the assertion. Leading whitespaces, trailing characters, infinity and not a number - all valid in C99/POSIX/GNU but not in PNG. At first I missed the hexadecimal representation but then I realized, that the uclibc I use with KLEE was build without hex-support.

A quick sample run with commented mismatch section in example.c for those who want to follow my short notes. ;)

>ragel -m -o gen.c example.c
>llvm-gcc -c -emit-llvm -I<path to klee>/include gen.c -o genc
>klee --libc=uclibc --optimize --only-output-states-covering-new ./genc
KLEE: output directory = "klee-out-37"
WARNING: While resolving call to function '__user_main' arguments were dropped!
KLEE: WARNING: undefined reference to function: _stdio_term
KLEE: WARNING: undefined reference to function: fcntl
KLEE: WARNING: undefined reference to function: fstat
KLEE: WARNING: undefined reference to function: open
KLEE: WARNING: executable has module level assembly (ignoring)
KLEE: WARNING: silently concretizing (reason: floating point) expression (Add w32 4294967248
(SExt w32 (Read w8 0 arr1))) to value 7 (:0)
KLEE: ERROR: ASSERTION FAIL: is_png_fp(s,se)
KLEE: NOTE: now ignoring this error at this location

KLEE: done: total instructions = 154995
KLEE: done: completed paths = 645
KLEE: done: generated tests = 13

The first found case are the trailing characters:

>ktest-tool klee-last/test000002.ktest
ktest file : 'klee-last/test000002.ktest'
args : ['./genc']
num objects: 1
object 0: name: 's'
object 0: size: 5
object 0: data: '777z\x00'

A satisfying regular expression is:

dec = [+\-]? (([0-9]+ '.'?) | ([0-9]+ '.' [0-9]+) | ('.' [0-9]+)) ([Ee][+\-]? [0-9]+)?;
main := space* (/inf/i | /nan/i | dec) any*;

Keep in mind, that this is no equivalence check. The defined language could be a superset of the language of the accepted strings of strtod().

The corresponding automata images were generated with dot:

>ragel -mpV example.c | dot -Tgif -o ragel_strtod.gif

strtod():

png floating point:

Papers you might be interested in:

A. Kiezun, V. Ganesh, P. J. Guo. HAMPI: A Solver for String Constraints

C. Cadar, D. Dunbar, D. Engler. KLEE: Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs

D. Ramos, D. Engler. Practical, low-effort equivalence verification of real code

F. Yu, T. Bultan, M. Cova, O. Ibarra. Symbolic String Verification: An Automata-based Approach

¹ No, I still don't know their definition of "non-positive".

resort PNG chunks

nospam@example.com (Frank) — Tue, 05 Apr 2011 17:09:43 +0200

If you ever needed to resort or drop chunks in a png file or to repair the signature and crc values, this one-evening-hack might be useful next time.

Resort chunks:

>./png_resort.py brokensuite/hist_after_idat.png foo.png
File: brokensuite/hist_after_idat.png
No. Type (Position,Length)
--------------------------
0. IHDR (8,25)
1. gAMA (33,16)
2. sBIT (49,15)
3. PLTE (64,57)
4. IDAT (121,83)
5. hIST (204,42)
6. IEND (246,12)
Enter new order (p.ex.: 0,3..5,2): 0..3,5,4,6
New order: [0, 1, 2, 3, 5, 4, 6]

Drop chunks and repair crc:

>./png_resort.py brokensuite/chunk_crc.png bar.png
File: brokensuite/chunk_crc.png
No. Type (Position,Length)
--------------------------
[Error] Test failed: chunk crc
repair crc [y|n]:y
0. IHDR (8,25)
1. gAMA (33,16)
2. PLTE (49,780)
3. IDAT (829,445)
4. IEND (1274,12)
Enter new order (p.ex.: 0,3..5,2): 0,2..4
New order: [0, 2, 3, 4]

For huge chunks you have to implement a more intelligent buffering (see read_bytes and writing).

#!/usr/bin/python3

# select chunks from infile.png and write them resorted to outfile.png

# usage: png_resort.py <infile.png> <outfile.png>
# user input:
# comma separated list of chunk indices or index ranges
# p.ex.: 0,2..4,1,5
# or 'exit'

# Literature
# ----------
# Portable Network Graphics (PNG) Specification (Second Edition)

import readline,struct,sys,zlib # drop readline for less dependencies and comfort
from functools import *
from io import *

png_signature = b'\x89\x50\x4e\x47\x0d\x0a\x1a\x0a'

def print_error(*msgs):
"""print highlighted error message(s)"""

msgs = ' '.join(map(str,msgs))
print('\033[1;31m[Error] {0}\033[1;m'.format(msgs))

def test(title,condition,val=None):
"""test condition, if false print test title and (maybe) val"""

if condition: return True
else:
s = 'Test failed: {0} ({1})'.format(title,s) if val else 'Test failed: {0}'.format(title)
print_error(s)
return False

def check_png_signature(f):
"""read and validate png file signature"""

# file signature (5.2)
sig = f.read(8)

return \
test('signature length',len(sig) == 8) and \
test('signature',sig == png_signature)

def is_png_uint32(val):
# (7.1)
return 0 <= val < 2**31

def png_chunks(f):
"""file -> [{'type','pos','length'[,'crc']}]"""

# chunk layout (5.3)
# +-------------------------------------------------+
# | length (4) | type (4) | data (length) | crc (4) |
# +-------------------------------------------------+

def read_bytes(name,length):
"""read length bytes"""
val = f.read(length)

if len(val) < length:
print_error('{0} < {1}'.format(name,length))
raise ValueError
else: return val

ret = []
cnt = 0

print('No. Type (Position,Length)\n'+'-'*26)
while True:
# read chunk
pos = f.tell()
length_ = f.read(4)
if len(length_) == 4:
(length,) = struct.unpack_from('!I',length_,0)
try:
type_ = read_bytes('chunk type',4)
data = read_bytes('chunk data',length) if length > 0 else b''
crc__ = read_bytes('chunk crc',4)
except:
print_error('defective chunk')
break
else:
type = ''
try:
type = type_.decode('ascii')
except:
print_error('non-ascii characters in type')
type = type_.decode('ascii','replace')

(crc_,) = struct.unpack_from('!I',crc__,0)
zcrc = zlib.crc32(type_+data)
crc = crc_ == zcrc

chunk_attrs = {'type':type,'pos':pos,'length':length+12}

# (5.1)
test('chunk length limit',is_png_uint32(length),length)
# check crc and repair
if not test('chunk crc',crc,crc):
while True:
c = input('repair crc [y|n]:').strip().lower()
if c == 'y':
chunk_attrs['crc'] = struct.pack('!I',zcrc)
break
elif c == 'n': break
else: print_error("wrong input, just y or n")

ret.append(chunk_attrs)
print('{3:>2}. {0} ({1},{2})'.format(type,pos,length+12,cnt))
cnt += 1
# eof
elif len(length_) == 0: break
# error
else:
print_error('defective chunk length')
break

return ret

def order_from_string(s):
"""create list of numbers from string s"""

err = False

def convert(si):
nonlocal err

if si == '': return []

try:
# simple integer conversion
i = int(si)
except:
# range notation
try:
a,b = si.split('..')
c,d = int(a),int(b)
l = []
if c < d:
l = list(range(c,d+1))
else:
l = list(range(d,c+1))
l.reverse()
except:
print_error('unknown representation:',si)
err = True
return []
else: return l
else: return [i]

order = reduce(lambda x,i:x+convert(i),s.strip().split(','),[])

return order if not err else None

if __name__ == '__main__':
# command line arguments
if len(sys.argv) != 3:
print_error('Incorrect number of arguments.\n' \
'usage: png_resort.py <infile.png> <outfile.png>')
exit(1)

try:
# read file
infile_name = sys.argv[1]
print('\033[1;32mFile: {0}\033[1;m'.format(infile_name))
with open(infile_name,'rb') as infile:
# read signature
check_png_signature(infile)

# read chunks
chunks = png_chunks(infile)
if len(chunks) == 0: exit(0)

# ask for new order
while True:
cmd = input('Enter new order (p.ex.: 0,3..5,2): ')
cmd = cmd.strip()
if cmd == 'exit': exit(0)

order = order_from_string(cmd)
if order == None: continue
print('New order: {0}'.format(order))

# check new order
if not reduce(lambda b,v: b and 0 <= v < len(chunks),order,True):
print_error('unknown chunk indices in new order')
else: break

# write new file
outfile_name = sys.argv[2]
with open(outfile_name,'wb') as outfile:
# write signature
outfile.write(png_signature)

# write chunks
for chunk_no in order:
c = chunks[chunk_no]
infile.seek(c['pos'],SEEK_SET)
# !!! needs advanced buffering for big files
data = infile.read(c['length'])
data = data if 'crc' not in c else data[:-4]+c['crc']
written = outfile.write(data)
if not c['length'] == len(data) == written:
print_error('copy error')
exit(1)

except IOError as err:
print_error(err)
exit(1)

exit(0)

Verweissalat 2

nospam@example.com (Frank) — Fri, 18 Feb 2011 11:58:22 +0100

Programmiersprachen

CoffeeScript (js)
Coherence
Frink
Gosu (jvm)
ooc
Sass (css)
StratifiedJS (js)
Thyrd
Ur

Bei Löschpedia werden gerade AliceML, Factor, Ioke, Joy, Nemerle, Pure... entfernt. Keine Relevanz für die engstirnigen Blockwarte.

Software

OPA (web)
surfraw
xzgv

Kram

Foundphotos
Genevolu (Namensverteilung)
List of cognitive biases
String Metrics
The Prime That Wasn't
Typefuck - Brainfuck in Haskell type checker
Walter Lewins Regenbögen (eng., Video)

Konferenzen 2010

nospam@example.com (Frank) — Fri, 18 Feb 2011 11:56:11 +0100

27C3
Emerging Languages Camp 2010 (videos)
CUFP 2010 - videos
Haskell Symposium 2010
ICFP 2010 (videos)
Principles of Programming Languages 2010 (papers)

dfa minimisation in Python

nospam@example.com (Frank) — Fri, 11 Feb 2011 19:40:18 +0100

Recently I stumbled upon a paper by Marco Almeida, Nelma Moreira and Rogerio Reis: Incremental DFA minimisation. Beside some minor flaws, like e.g. the missing "ICDFA" definition (already present in the predecessor: On the performance of automata minimization algorithms) and the slightly strange pseudo code, I'm still not convinced about their normalisation-function.

They argue (section 4 below listing 1.1 resp. proof of lemma 1) that this function reduces the considered pairs to n²/2 - n. If we take all pairs p,q, we obviously get n² pairs. After sorting and removing the duplicates we get (n²+n)/2 pairs, without identities (n²-n)/2...

In order to better understand some parts of the algorithm, I reimplemented it in Python. I left out most optimizations and tried to stay close to the original pseudo code. It works at least for two examples. ;)

#!/usr/bin/python3

# Implementation of the MIN-INCR ICDFA minimisation algorithm without(!)
# optimized data structures.
#
# Use minimalIncremental() from FAdo Project for your projects.

# Literature
# ----------
#
# [idm] Almeida, Moreira, Reis: Incremental DFA minimisation
# [ufa] Tarjan: Efficiency of a Good But Not Linear Set Union Algorithm
#
#
# Links
# -----
#
# FAdo Project:
# - http://www.ncc.up.pt/FAdo/
# - http://fado.dcc.fc.up.pt/FAdo/

verbose = False

# ==== fake union-find ==== ([ufa])

sets = {}

def make(x):
"""creates new singleton set {x}"""
global sets

sets[x] = set([x])

def find_(sets,x):
"""returns representative element of set containing x"""

for id,s in sets.items():
if x in s:
return id

def find(x):
"""wrapper for find_"""
global sets

return find_(sets,x)

def union(p,q):
"""combines a and b"""
global sets

a,b = normalise(find(p),find(q))
if a != b:
sets[a] |= sets[b]
del sets[b]

# ==== minimisation ==== ([idm])

neq = set()
equiv = set()
path = set()
dfa = {}

# (idm L1.1)
def normalise(p,q):
return (p,q) if p<q else (q,p)

# (idm L1.4) - just use python's set implementation
def set_make():
return set()

def set_insert(v,s):
s.add(v)

def set_remove(v,s):
s.remove(v)

def set_search(v,s):
return v in s

def set_elements(s):
return s

# (idm L1.3)
def equiv_p(p,q):
"""tests equivalence of p and q"""
global neq, equiv, path, dfa, verbose
d = dfa

print_("equiv: {0}\npath : {1}\nneq : {2}\n".format(equiv,path,neq))

if (p,q) in neq:
return False

if set_search((p,q),path):
return True

set_insert((p,q),path)

for a in d['Sigma']:
print_("p,a,q:",p,a,q)

(p_,q_) = normalise(find(d['delta'](p,a)),find(d['delta'](q,a)))

if p_ != q_ and not set_search((p_,q_),equiv):
set_insert((p_,q_),equiv)

if not equiv_p(p_,q_):
return False
else:
set_remove((p_,q_),path)

set_insert((p,q),equiv)

return True

# (idm Theorem 2)
def joinstates(d,classes):
"""returns new dfa based on equivalence classes"""

Q = set(classes.keys())
Sigma = d['Sigma']
delta = lambda p,a: find_(classes,d['delta'](p,a))
q0 = find_(classes,d['q0'])
F = set(map(lambda x: find_(classes,x),list(d['F'])))

return {'Q':Q,'Sigma':Sigma,'delta':delta,'q0':q0,'F':F}

# (idm L1.2)
def min_incr(d):
global neq, equiv, path, dfa
dfa = d

for q in d['Q']:
make(q)

neq = set([normalise(p,q) for p in d['F'] for q in d['Q'] - d['F']])

for p in d['Q']:
for q in [x for x in d['Q'] if x > p]:
if (p,q) in neq:
continue

if find(p) == find(q):
continue

equiv = set_make()
path = set_make()

if equiv_p(p,q):
for (p_,q_) in set_elements(equiv):
union(p_,q_)
else:
neq |= path

classes = {}
for p in d['Q']:
lider = find(p)
classes[lider] = classes[lider] | set([p]) if lider in classes else set([p])

print_('classes:',classes,'\n')

return joinstates(d,classes)

# ==== I/O ====

def print_(*args):
global verbose

if verbose:
print(*args)

def print_dfa(name,d):
print('{0}\n{1}'.format(name,'='*len(name)))
print('Q : {0}\nSigma: {1}\ndelta:'.format(d['Q'],d['Sigma']))
for q,a in [(q,a) for q in d['Q'] for a in d['Sigma']]:
print(' '*6,q,a,d['delta'](q,a))
print('q0 : {0}\nF : {1}\n'.format(d['q0'],d['F']))

# ==== examples ====

# DFA d={q,s,d,q0,f}

def dfa_01_d(p,a):
tab = {
0:{'a':1,'b':2},
1:{'a':4,'b':2},
2:{'a':3,'b':2},
3:{'a':4,'b':0},
4:{'a':4,'b':4}}

return tab[p][a]

dfa_01 = {'Q':set([0,1,2,3,4]),'Sigma':set(['a','b']),'delta':dfa_01_d,'q0':0,'F':set([4])}

def dfa_02_d(p,a):
tab = {
0:{'a':1,'b':4},
1:{'a':2,'b':5},
2:{'a':3,'b':2},
3:{'a':3,'b':2},
4:{'a':5,'b':0},
5:{'a':4,'b':1}}

return tab[p][a]

dfa_02 = {'Q':set(range(0,6)),'Sigma':set(['a','b']),'delta':dfa_02_d,'q0':0,'F':set([2,3,4])}

# ==== main ====

if __name__ == '__main__':
print_dfa('DFA 01',dfa_01)
dfa_01_min = min_incr(dfa_01)
print_dfa('DFA 01 min',dfa_01_min)

print_dfa('DFA 02',dfa_02)
dfa_02_min = min_incr(dfa_02)
print_dfa('DFA 02 min',dfa_02_min)

Feel free to play around with it.

Gentoo: rlwrap

nospam@example.com (Frank) — Fri, 21 Jan 2011 16:29:01 +0100

Wer Software wie Ocaml verwendet, bei der readline aus lizenztechnischen Gründen nicht rangebastelt werden darf, weicht notgedrungen auf ledit oder rlwrap aus. Leider ist die Version in Gentoos Portage ziemlich alt (stable 0.30, maskiert 0.32). Für 0.37 reicht es, das Ebuild der letzten Version in ein lokales Overlay zu kopieren, in ...-0.37 umzubenennen, das Manifest zu bauen und die neue Version zu installieren. Die letzten Schritte hatte ich vor Kurzem schon angerissen...

Matrox und mesa 7.9 unter Gentoo

nospam@example.com (Frank) — Mon, 03 Jan 2011 14:44:47 +0100

xorg/mesa-Aktualisierungen sind immer etwas Feines. Das udev-Keyword flog vorher raus, man kennt ja das udev/hal-Debakel und die Treiber übersetzt man schon aus Reflex neu, man wurde ja schließlich nicht nur einmal von inaktiver Maus und Tastatur überrascht:

sudo emerge xf86-input-keyboard xf86-input-mouse xf86-video-mga

und trotzdem gab es etwas Neues: lahme und ruckelnde Videos. Die Ursache fand sich schnell:

(EE) AIGLX error: dlopen of /usr/lib/dri/mga_dri.so failed (/usr/lib/dri/mga_dri.so: cannot open shared object file: No such file or directory)
(EE) AIGLX: reverting to software rendering
(II) AIGLX: Loaded and initialized /usr/lib/dri/swrast_dri.so
(II) GLX: Initialized DRISWRAST GL provider for screen 0

die Lösung auch: Lokales Overlay verwenden bzw. anlegen, media-libs/mesa reinkopieren, im ebuild unter "classic"

driver_enable video_cards_mga mga

hinzufügen, Manifest basteln:

sudo ebuild mesa-7.9.ebuild manifest

mesa erneut kompilieren und fertig.

JMStV

nospam@example.com (Frank) — Wed, 01 Dec 2010 11:53:18 +0100

Die Dummheit kennt länderweit mal wieder keine Grenzen, die Änderungen zum JMStV werden wohl durchgewunken und hoffentlich irgendwann auf anderer Ebene wieder einkassiert.

Bis dahin kann man sich vorübergehend tolle Bildchen für die eigene Netzseite kreieren lassen, um Kinder vor der bösen Welt zu schützen. ZB. bei jusprog, einem Kinderschutzprogramm der Erotikindustrie.

Nach Beantwortung der Fragen erhält man Zeichensalat zum Einbinden:

Mit "alternativer" Eingabe kann man die Ausgabe aufhübschen...

Ein-/Ausgabevalidierung lässt grüßen...

Hex Editor unter Linux

nospam@example.com (Frank) — Fri, 19 Nov 2010 19:02:00 +0100

Ich dachte nicht, dass das so ein Problem sein kann. Anzeigen via hexdump, xxd... kann jeder, dafür braucht man keinen Editor. Aber einfach mal bequem ein paar Bytes einfügen, ohne zu überschreiben ist schon zu kompliziert. Wtf?! Für derart triviale Sachen benötigen manche Exemplare Mono (bless), Gnome (ghex) oder gar Qt (lfhex):

Minimal dependencies (just Qt)

Wirklich minimal - nur 160MB allein an Qt-Kram. Für biew muss man TERM erst auf vt100 setzen, damit es überhaupt startet. Kurz darauf würgt man schon ob der Steuerung und ruft ganz schnell emerge --unmerge auf. Bei wxhexeditor reichte schon der Screenshot auf der Netzseite als Ausschlusskriterium. Ein kleines bescheidenes bvi funktionierte dann tadellos - so kann's gehen.

pdfnup --trim

nospam@example.com (Frank) — Mon, 26 Jul 2010 16:20:15 +0200

Parameterreihenfolge ist: "left bottom right top", Eselsbrücke: css rückwärts.

Verweissalat 1

nospam@example.com (Frank) — Wed, 23 Jun 2010 10:10:34 +0200

BugSpy
checkmycode
Panopticlick (browser tracking)
TinEye Reverse Image Search
wtfjs (JS)

A Twisty Maze of Linux Clocks, All Slightly Different
C Language Quirks
Command-Line Printing and Options (cups)
Data Compression Explained
How Not To Sort By Average Rating
List of Printers Which Do or Do Not Display Tracking Dots
List of software development philosophies
Online Emulation of Soviet Ternary Computer Setun
Tail Call Improvements in .NET Framework 4
Ten divisions to Easter
Zip Files All The Way Down

Charity
dompdf
GeSHI
phash (perceptual hash library)
pixlr (online graphics editor)
push (dataflow shell)
re2 (regular expressions)
SQL Buddy
stringencoders (string transformations)
The Disciplined Disciple Compiler (strict evaluated Haskell)
The Maxine Virtual Machine
The Transterpreter Project (vm)
tinypy
tmux

c++ productivity

nospam@example.com (Frank) — Tue, 08 Jun 2010 09:51:00 +0200

Wieder ein schöner Beitrag von Linus Trovalds über C++:

So there are particular reasons why I think C is "as simple
as possible, but no simpler" for the particular case of an
OS kernel, or system programming in particular. That's why
I'm absolutely not saying that you should use C for all
projects.

But C++? I really don't think the "good features" of it
are very good at all. If you leave C behind, do it properly
and get some real features that matter. GC, some
concurrency support, dynamic code generation, whatever.

Punktlandung.

von dwm und mrxvt zu Xmonad und urxvt

nospam@example.com (Frank) — Sun, 16 May 2010 20:16:00 +0200

Mit der Entwicklung von dwm war ich schon eine Weile unzufrieden, Xmonad hingegen hat sich seit meinem ersten Versuch vor drei Jahren inzwischen zu einem richtigen Metafenstermanager entwickelt. Nahezu jede Funktion ist anpassbar und bereits in mehreren Varianten verfügbar, ganz ohne C schreiben oder veraltete Patches anpassen zu müssen. Sehr, sehr nett.

Die erste .xmonad/xmonad.hs - weitestgehend zusammenkopiert aus der Doku:

import XMonad
import XMonad.Actions.CopyWindow
import XMonad.Actions.DwmPromote
import XMonad.Hooks.DynamicLog
import XMonad.Hooks.ManageDocks
import XMonad.Layout.Tabbed
import XMonad.Util.Run(spawnPipe)

import Data.Monoid
import System.Exit
import System.IO.UTF8

import qualified XMonad.StackSet as W
import qualified Data.Map as M

-- The preferred terminal program, which is used in a binding below and by
-- certain contrib modules.
--
myTerminal = "urxvtc"

-- Whether focus follows the mouse pointer.
myFocusFollowsMouse :: Bool
myFocusFollowsMouse = True

-- Width of the window border in pixels.
--
myBorderWidth = 1

-- modMask lets you specify which modkey you want to use. The default
-- is mod1Mask ("left alt"). You may also consider using mod3Mask
-- ("right alt"), which does not conflict with emacs keybindings. The
-- "windows key" is usually mod4Mask.
--
myModMask = mod4Mask

-- The mask for the numlock key. Numlock status is "masked" from the
-- current modifier status, so the keybindings will work with numlock on or
-- off. You may need to change this on some systems.
--
-- You can find the numlock modifier by running "xmodmap" and looking for a
-- modifier with Num_Lock bound to it:
--
-- > $ xmodmap | grep Num
-- > mod2 Num_Lock (0x4d)
--
-- Set numlockMask = 0 if you don't have a numlock key, or want to treat
-- numlock status separately.
--
myNumlockMask = mod2Mask

-- The default number of workspaces (virtual screens) and their names.
-- By default we use numeric strings, but any string may be used as a
-- workspace name. The number of workspaces is determined by the length
-- of this list.
--
-- A tagging example:
--
-- > workspaces = ["web", "irc", "code" ] ++ map show [4..9]
--
-- myWorkspaces = ["1","2","3","4","5","6","7","8","9"]
myWorkspaces = ["1","2","3","4","5:www","6:min"]

-- Border colors for unfocused and focused windows, respectively.
--
myNormalBorderColor = "#dddddd"
myFocusedBorderColor = "#ff0000"

------------------------------------------------------------------------
-- Key bindings. Add, modify or remove key bindings here.
--
myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList $

-- launch a terminal
[ ((modm .|. shiftMask, xK_Return), spawn $ XMonad.terminal conf)

-- launch dmenu
, ((modm, xK_p ), spawn "exe=`dmenu_path | dmenu` && eval \\"exec $exe\\"")

-- launch gmrun
-- , ((modm .|. shiftMask, xK_p ), spawn "gmrun")

-- close focused window
, ((modm .|. shiftMask, xK_c ), kill)

-- close focused window or just remove copy
, ((modm .|. shiftMask .|. controlMask, xK_c ), kill1)

-- Rotate through the available layout algorithms
, ((modm, xK_space ), sendMessage NextLayout)

-- Reset the layouts on the current workspace to default
, ((modm .|. shiftMask, xK_space ), setLayout $ XMonad.layoutHook conf)

-- Resize viewed windows to the correct size
, ((modm, xK_n ), refresh)

-- Move focus to the next window
, ((modm, xK_Tab ), windows W.focusDown)

-- Move focus to the next window
, ((modm, xK_j ), windows W.focusDown)

-- Move focus to the previous window
, ((modm, xK_k ), windows W.focusUp )

-- Move focus to the master window
, ((modm, xK_m ), windows W.focusMaster )

-- Swap the focused window and the master window
, ((modm, xK_Return), dwmpromote)

-- Swap the focused window with the next window
, ((modm .|. shiftMask, xK_j ), windows W.swapDown )

-- Swap the focused window with the previous window
, ((modm .|. shiftMask, xK_k ), windows W.swapUp )

-- Shrink the master area
, ((modm, xK_h ), sendMessage Shrink)

-- Expand the master area
, ((modm, xK_l ), sendMessage Expand)

-- Push window back into tiling
, ((modm, xK_t ), withFocused $ windows . W.sink)

-- Increment the number of windows in the master area
, ((modm , xK_comma ), sendMessage (IncMasterN 1))

-- Deincrement the number of windows in the master area
, ((modm , xK_period), sendMessage (IncMasterN (-1)))

-- Toggle the status bar gap
-- Use this binding with avoidStruts from Hooks.ManageDocks.
-- See also the statusBar function from Hooks.DynamicLog.
--
, ((modm , xK_b ), sendMessage ToggleStruts)

-- Quit xmonad
, ((modm .|. shiftMask, xK_q ), io (exitWith ExitSuccess))

-- Restart xmonad
, ((modm , xK_q ), spawn "xmonad --recompile; xmonad --restart")
]
++

-- mod-[1..9] @@ Switch to workspace N
-- mod-shift-[1..9] @@ Move client to workspace N
-- mod-control-shift-[1..9] @@ Copy client to workspace N
[((m .|. modm, k), windows $ f i)
| (i, k) <- zip (XMonad.workspaces conf) [xK_1 .. ]
, (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask), (copy, shiftMask .|. controlMask)]]

--
-- mod-{w,e,r}, Switch to physical/Xinerama screens 1, 2, or 3
-- mod-shift-{w,e,r}, Move client to screen 1, 2, or 3
--
-- [((m .|. modm, key), screenWorkspace sc >>= flip whenJust (windows . f))
-- | (key, sc) <- zip [xK_w, xK_e, xK_r] [0..]
-- , (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]

++
[ ((modm, xK_o), spawn "opera -nomail -nolirc")
, ((modm, xK_e), spawn "claws-mail")
, ((modm, xK_f), spawn "firefox")
, ((modm, xK_g), spawn "gqview")
, ((modm .|. shiftMask, xK_g), spawn "geany")
, ((modm, xK_s), spawn "urxvt -pe tabbed,matcher")
, ((modm, xK_less), windows $ W.greedyView "5:www")
]

------------------------------------------------------------------------
-- Mouse bindings: default actions bound to mouse events
--
myMouseBindings (XConfig {XMonad.modMask = modm}) = M.fromList $

-- mod-button1, Set the window to floating mode and move by dragging
[ ((modm, button1), (\w -> focus w >> mouseMoveWindow w
>> windows W.shiftMaster))

-- mod-button2, Raise the window to the top of the stack
, ((modm, button2), (\w -> focus w >> windows W.shiftMaster))

-- mod-button3, Set the window to floating mode and resize by dragging
, ((modm, button3), (\w -> focus w >> mouseResizeWindow w
>> windows W.shiftMaster))

-- you may also bind events to the mouse scroll wheel (button4 and button5)
]

------------------------------------------------------------------------
-- Layouts:

-- You can specify and transform your layouts by modifying these values.
-- If you change layout bindings be sure to use 'mod-shift-space' after
-- restarting (with 'mod-q') to reset your layout state to the new
-- defaults, as xmonad preserves your old layout settings by default.
--
-- The available layouts. Note that each layout is separated by |||,
-- which denotes layout choice.
--
myLayout = avoidStruts(tiled ||| Mirror tiled ||| simpleTabbedAlways ||| Full)
where
-- default tiling algorithm partitions the screen into two panes
tiled = Tall nmaster delta ratio

-- The default number of windows in the master pane
nmaster = 1

-- Default proportion of screen occupied by master pane
-- ratio = 1/2
ratio = 7/10

-- Percent of screen to increment by when resizing panes
-- delta = 3/100
delta = 5/100

------------------------------------------------------------------------
-- Window rules:

-- Execute arbitrary actions and WindowSet manipulations when managing
-- a new window. You can use this to, for example, always float a
-- particular program, or have a client always appear on a particular
-- workspace.
--
-- To find the property name associated with a program, use
-- > xprop | grep WM_CLASS
-- and click on the client you're interested in.
--
-- To match on the WM_NAME, you can use 'title' in the same way that
-- 'className' and 'resource' are used below.
--
myManageHook = composeAll
[ className =? "Gimp" --> doFloat
, className =? "MPlayer" --> doFloat
, className =? "Opera" --> doShift "5:www"
,(className =? "Firefox" <&&> resource =? "Dialog") --> doFloat ]

------------------------------------------------------------------------
-- Event handling

-- * EwmhDesktops users should change this to ewmhDesktopsEventHook
--
-- Defines a custom handler function for X Events. The function should
-- return (All True) if the default handler is to be run afterwards. To
-- combine event hooks use mappend or mconcat from Data.Monoid.
--
myEventHook = mempty

------------------------------------------------------------------------
-- Status bars and logging

-- Perform an arbitrary action on each internal state change or X event.
-- See the 'XMonad.Hooks.DynamicLog' extension for examples.
--
-- myLogHook = return ()
myLogHook h = dynamicLogWithPP $ myPP h

myPP h = defaultPP
{ ppCurrent = wrap "^bg(#e5f9ff)^fg(#105468)" "^bg()^fg()"
, ppVisible = wrap "^fg(#a00000)" "^fg()"
, ppHidden = wrap "^fg(#ffffff)" "^fg()"
, ppHiddenNoWindows = wrap "^fg(#7eacb9)" "^fg()"
, ppSep = " | "
, ppWsSep = " "
, ppTitle = shorten 80
, ppOrder = workspaceTag
, ppOutput = System.IO.UTF8.hPutStrLn h
}
where workspaceTag (x:xs) = ("[ " ++ x ++ " ]") : xs

------------------------------------------------------------------------
-- Startup hook

-- Perform an arbitrary action each time xmonad starts or is restarted
-- with mod-q. Used by, e.g., XMonad.Layout.PerWorkspace to initialize
-- per-workspace layout choices.
--
-- By default, do nothing.
myStartupHook = return ()

------------------------------------------------------------------------
-- Now run xmonad with all the defaults we set up.

-- Run xmonad with the settings you specify. No need to modify this.
--
-- main = xmonad defaults
main = do dzenh <- spawnPipe "dzen2 -p -w 1280 -ta l"
xmonad $ defaults dzenh

-- A structure containing your configuration settings, overriding
-- fields in the default config. Any you don't override, will
-- use the defaults defined in xmonad/XMonad/Config.hs
--
-- No need to modify this.
--
defaults dzenh = defaultConfig {
-- simple stuff
terminal = myTerminal,
focusFollowsMouse = myFocusFollowsMouse,
borderWidth = myBorderWidth,
modMask = myModMask,
numlockMask = myNumlockMask,
workspaces = myWorkspaces,
normalBorderColor = myNormalBorderColor,
focusedBorderColor = myFocusedBorderColor,

-- key bindings
keys = myKeys,
mouseBindings = myMouseBindings,

-- hooks, layouts
layoutHook = myLayout,
manageHook = myManageHook,
handleEventHook = myEventHook,
logHook = myLogHook dzenh,
startupHook = myStartupHook
}

Die .xinitrc:

xsetroot -cursor_name left_ptr
urxvtd -f -o -q
exec xmonad

Der Ressourcenverbrauch ist höher, aber wenn ich dadurch schneller arbeiten kann, ist es mir egal.

PR NI VIRT RES SHR S %CPU %MEM TIME+
40 0 6916 3628 2496 S 0.0 0.7 0:00.05 xmonad
40 0 3020 1144 940 S 0.0 0.2 0:00.01 dzen2
40 0 3132 932 808 S 0.0 0.2 0:00.11 dwm

Gleiches gilt für mrxvt. Ein paar Bugs nervten auf Dauer (zB. Zeichenverlust beim Ändern der Fenstergröße) und die Dämonvariante urxvtd wird dem Tiling-Konzept meiner Meinung nach besser gerecht.