open Bitv
 open List
 open Printf

 (* convenience functions *)
 let bits initf = Bitv.init 16 initf 
 let zeros = Bitv.create 16 false
 let ones = Bitv.create 16 true
 let from_str s = function n -> (String.get s n) == '1'

 (* CC-ITT CRC polynomials: big endian and little endian *)
 let poly8048 =   from_str "1000010000001000" 
 let poly1021 =   from_str "0001000000100001" 

 (* bit twiddling functions. I hate that OCaml doesn't have a bit vector type *)
 (* and unsigned ints are 30 bits, and signed ints are 31 bits if that isn't wierd enough *)
 (* and no, there is no 16 bit type that can be used as an integer. Sigh. *)
 let bit n bits = Bitv.get bits n
 let shl n bitv = Bitv.shiftl bitv n
 let bxor bitv1 bitv2 = Bitv.bw_xor bitv1 bitv2
 let byte_bits c = Bitv.sub (Bitv.of_int_us(int_of_char c)) 0 8
 let pad n bits = Bitv.append bits (Bitv.create n false)

 (* calculate the CRC for a given byte value. can use this to create a table *)
 (* lookup version that should be faster, should you find yourself in a big hurry *)
 let chksum poly remainder byte = 
   let rem = bxor (shl 8 (pad 8 byte)) remainder in
   let sum remnant = 
     let shifted = shl 1 remnant in 
     if bit 15 remnant then bxor shifted poly else shifted
   in let rec bits at max remnant byte =
     if at < max then bits (at + 1) max (sum remnant) byte else remnant
   in bits 0 8 rem byte

 (* fold the list, collecting and applying the checksum to each byte *)
 let crc init bytes =
   List.fold_left (chksum (bits poly8048)) init bytes

 (* test to see if we get the proper output corresponding to a correct implementation *)
 (* should be 0x29B1, ocaml ints have 30 bits, accounting for strange pad value used *)
 let result = 
   let bits = List.map byte_bits ['1';'2';'3';'4';'5';'6';'7';'8';'9';] in
   printf "0x%X\n" (Bitv.to_int_us(pad 14 (crc ones bits)))

class Number
  
  def self.to_words(number)
    Number.new.to_s(number)
  end
  
  def self.commify(number)
    (s=number.to_s;x=s.length;s).rjust(x+(3-(x%3))).gsub(/(\d)(?=\d{3}+(\.\d*)?$)/,'\1,')
  end
    
  def initialize
    @unit = %w[zero one two three four five six seven eight nine]
    @teen = %w[ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen]
    @tens = %w[zero ten twenty thirty fourty fifty sixty seventy eighty ninety]
    @qtys = %w[hundred thousand million billion trillion quadrillion quintillion]
    @zero = ["zero"]
    @hundred = "hundred"
    @sepr = "and"
  end
    
  def to_s(number)
    out = quantify(number).flatten
    for x in 0 .. out.length - 1
      out[x] = nil if out[x] == @sepr && out[x+1] == @sepr
    end
    out.compact!
    out = @zero if out.length == 1 && out[0] == @sepr
    out.pop while out.last == @sepr
    out.shift while out.first == @sepr    
    out.join(' ').gsub(/ ,/,',')
  end
        
  private 
  
  def padded_groups(v)
    out = []
    padded = (s=v.to_s;x=s.length;s).rjust(x+(3-(x%3))).gsub(//,'0')
    padded.scan(/.{3}/)
  end
  
  def wordify(v)
    out = []
    zero = '0'[0]
    h, t, u = v[0] - zero, v[1] - zero, v[2] - zero
    if h != 0
      out << @unit[h]
      out << @hundred
    end
    out << @sepr if h != 0 && (t != 0 || u != 0)
    out << @sepr if h == 0 && t == 0 && u != 0
    if t == 1
      out << @teen[u]
    else
      out << @tens[t] if t != 0
      out << @unit[u] if u != 0
    end
    return out
  end
  
  def quantify(v)
    v = padded_groups(v).reverse
    pos = v.length - 1
    out = []
    while pos >= 0
      word = wordify(v[pos])
      if word[0] != nil
        out << word
        out << @qtys[pos] if pos != 0                
      else
        out << @sepr
      end
      pos -= 1
    end
    return out
  end

end

# for number in [
#     0, 
#     1, 
#     3, 
#     11, 
#     100,
#     1000, 
#     1001, 
#     1100, 
#     1101, 
#     1_000_001, 
#     8_000_000_000, 
#     8_000_000_001, 
#     4_567_890_923, 
#     6_804_567_890_903, 
#     5_006_804_567_890_903
#   ]
#   print "#{Number.commify(number)}: #{Number.to_words(number)}\n"
# end

void succ(int* ip, char* cp, char* ch)
{
    int il = strlen(ch);
    char *np;
        
    if(*(cp + *ip) == '\0') {
        *(cp + *ip) = *ch;
        return;
    }
        
    np = strchr(ch, *(cp + *ip));
        
    if(np == NULL) {
        (*ip)++;
        *(cp + *ip) = *ch;
    } else if(np == ch + il - 1) {
        *(cp + *ip) = *ch;
    } else {
        *(cp + *ip) = *(np + 1);
    }
}

int textual_input(int line, char *destination, int maxlen)
{
    int nKey, i = 0;
    char text[128];

    memset(text, 0, sizeof(text));

    while(1)
    {
        nKey = Sys_Key_WaitKey();
        switch (nKey)
        {
            case KEY_DEL: text[i] = '\0'; i > 0 ? i-- : i = 0; break;
            case KEY_0: i++; text[i] = ' '; break;
            case KEY_1: i++; break;
            case KEY_2: succ(&i, text, "ABC"); break;
            case KEY_3: succ(&i, text, "DEF"); break;
            case KEY_4: succ(&i, text, "GHI"); break;
            case KEY_5: succ(&i, text, "JKL"); break;
            case KEY_6: succ(&i, text, "MNO"); break;
            case KEY_7: succ(&i, text, "PQRS"); break;
            case KEY_8: succ(&i, text, "TUV"); break;
            case KEY_9: succ(&i, text, "WXYZ"); break;
            case KEY_ENTER: goto done; break;
            case KEY_CANCEL: goto cancel; break;
        }
        Syd_ClearWindow(line,line);
        Syd_DisplayLine(line, text, 0, ALIGN_LEFT );
    }
done:
    strncpy(destination, text, maxlen);
    return 0;
cancel:
    memset(destination, 0, maxlen);
    return -1;
}

        sudo port install coreutils
        sudo port install gsed
        
        sudo ln -s /opt/local/bin/gcp /opt/local/bin/cp
        sudo ln -s /opt/local/bin/gnused /opt/local/bin/sed
        
        export PATH=/opt/local/bin:$PATH 
        
        sudo gcc_select 3.3

        TARGET=m68k-elf
        PREFIX=/usr/local/m68k-uclinux-tools
        BINUTILSVERS="2.14.90.0.8"
        GCCVERS="3.4.0"
        GDBVERS="6.1"
        BDMVERS="1.3.0"
        UCLIBCVERS="0.9.26"
        ELF2FLTVERS="20040326"
        ROOTDIR="${BASEDIR}/uClinux-dist"
        KERNEL="${ROOTDIR}/linux-2.4.x"

        cd where-ever-your-buildroot-is
        sh build-uclinux-tools build

        sh build-uclinux-tools continue

        cp uClibc-0.9.26/include/elf.h elf2flt-20040326

                LDFLAGS = @LDFLAGS@ -static

                LDFLAGS = @LDFLAGS@ 

        sh build-uclinux-tools continue    

        --with-libiberty=${BASEDIR}/${TARGET}-binutils/libiberty/libiberty.a \
        ${PREFIXOPT}

     --with-libiberty=${BASEDIR}/${TARGET}-binutils/libiberty/libiberty.a \
        --disable-ioperm --disable-driver \
        ${PREFIXOPT}

        bdmctrl_LDFLAGS = -static

        bdmctrl_LDFLAGS =

@strong{Note:} a trace experiment and data collection may stop automatically if any tracepoint's passcount is reached
(@pxref{Tracepoint Passcounts}), or if the trace buffer becomes full.

Note: a trace experiment and data collection may stop automatically if any tracepoint's passcount is reached
(@pxref{Tracepoint Passcounts}), or if the trace buffer becomes full.

def commify(number)
    c = { :value => "", :length => 0 }
    r = number.to_s.reverse.split("").inject(c) do |t, e|  
      iv, il = t[:value], t[:length]
      iv += ',' if il % 3 == 0 && il != 0    
      { :value => iv + e, :length => il + 1 }
    end
    r[:value].reverse!
  end

def commify(v)
 (s=v.to_s;x=s.length;s).rjust(x+(3-(x%3))).scan(/.{3}/).join(',').strip
end

number_with_delimiter(number, delimiter)

def number_with_delimiter(number, delimiter=",")
  number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
end

def commify(n)
    n.to_s =~ /([^\.]*)(\..*)?/
    int, dec = $1.reverse, $2 ? $2 : ""
    while int.gsub!(/(,|\.|^)(\d{3})(\d)/, '\1\2,\3')
    end
    int.reverse + dec
end

ENV["FIXTURE_ORDER"] = 
  %w( entities interaction_sources interaction_devices payments 
      interactions accounts employments enrollments payables 
      receivables tenures wards ).join(' ')

require File.expand_path(File.dirname(__FILE__) + "/../../config/environment")
require File.expand_path(File.dirname(__FILE__) + "/../../test/ordered_fixtures")

ENV["FIXTURE_ORDER"] ||= ""

desc "Load fixtures into #{ENV['RAILS_ENV']} database"
task :load_fixtures_ordered => :environment do
  require 'active_record/fixtures'  
  ordered_fixtures = Hash.new
  ENV["FIXTURE_ORDER"].split.each { |fx| ordered_fixtures[fx] = nil }
  other_fixtures = Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}')).collect { |file| File.basename(file, '.*') }.reject {|fx| ordered_fixtures.key? fx }
  ActiveRecord::Base.establish_connection(ENV['RAILS_ENV'])
  (ordered_fixtures.keys + other_fixtures).each do |fixture|
    Fixtures.create_fixtures('test/fixtures',  fixture)
  end unless :environment == 'production' 
  # You really don't want to load your *fixtures* 
  # into your production database, do you?  
end

sudo port install subversion

svnadmin create /Users/xyz/Repositories

<?xml version="1.0" encoding="UTF-8"?>
DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
        <key>Debugkey>
        />
        <key>GroupNamekey>
        xyz</string>
        <key>Labelkey>
        org.tigris.subversion.svnserve</string>
        <key>OnDemandkey>
        />
        <key>Programkey>
        /opt/local/bin/svnservestring>
        ProgramArguments</key>
        <array>
                <string>svnservestring>
                --inetd</string>
                <string>--root=/Users/xyz/Repositoriesstring>
        </array>
        <key>ServiceDescriptionkey>
        SVN Version Control System</string>
        <key>Socketskey>
        
                Listeners</key>
                <array>
                <dict>
                        <key>SockFamilykey>
                        IPv4</string>
                        <key>SockServiceNamekey>
                        svn</string>
                        <key>SockTypekey>
                        stream</string>
                dict>
                
                        SockFamily</key>
                        <string>IPv6string>
                        SockServiceName</key>
                        <string>svnstring>
                        SockType</key>
                        <string>streamstring>
                </dict>
                array>
        </dict>
        <key>Umaskkey>
        2</integer>
        <key>UserNamekey>
        xyz</string>
        <key>inetdCompatibilitykey>
        
                Wait</key>
                <false/>
        dict>
</dict>
plist>

sudo launchctl load /Library/LaunchDaemons/org.tigris.subversion.svnserve.plist

sudo launchctl start org.tigris.subversion.svnserve

svn co svn://your.host.name/aModule/In/Your/Repository