unit RadixConv;

interface

uses
  SysUtils, Math;

type
  TRadixRange  = 2..256;
  TDigitsRange = 0..255;

const
  FRadixTable = '0123456789ABCDEF';

// 数値 -> n 進数文字列
function IntToStrEx(const Value: Int64; const Radix: TRadixRange = 10; const Digits: TDigitsRange = 0; const RadixTable: string = ''): string;
// n 進数文字列 -> 数値
function StrToIntEx(const s: string; const Radix: TRadixRange = 10; const RadixTable: string = ''): Int64;

// 数値 -> Excel 桁文字列
function IntToExcelHexacos(const Value: Int64): string;
// Excel 桁文字列 -> 数値
function ExcelHexacosToInt(const s: string): Int64;

implementation

function IntToStrEx(const Value: Int64; const Radix: TRadixRange = 10; const Digits: TDigitsRange = 0; const RadixTable: string = ''): string;
// -----------------------------------------------------------------------------
// 数値 -> n 進数文字列
//
// 引数
//   Value     : 変換する数値
//   Radix     : 基数 (Radix 進数) Radix >= 2
//   Digits    : 表示桁 (0 で自動)
//   RadixTable: 桁文字テーブル
//
// 戻り値
//   Radix 進数文字列
// -----------------------------------------------------------------------------
var
  i: Integer;
  dRadixTable: String;
  dValue: UInt64;
begin
  result := '';
  // Radix Table
  if RadixTable = '' then
    dRadixTable := FRadixTable
  else
    dRadixTable := RadixTable;
  // Error
  if Length(dRadixTable) < Radix then
    Exit;
  // Calc
  dValue := Value;
  for i:=1 to 64 do
    begin
      result := dRadixTable[(dValue mod Radix) + 1] + result;
      dValue := dValue div Radix;
      if dValue = 0 then
        Break;
      if (Digits > 0) and (i = Digits) then
        Break;
    end;
  // Format
  if Digits > 0 then
    begin
      result := Copy(result, Min(1, Digits - Length(result) + 1), Digits);
      result := StringOfChar(dRadixTable[1], Digits - Length(result)) + result;
    end;
end;

function StrToIntEx(const s: string; const Radix: TRadixRange = 10; const RadixTable: string = ''): Int64;
// -----------------------------------------------------------------------------
// n 進数文字列 -> 数値
//
// 引数
//   s         : Radix 進数文字列
//   Radix     : 基数 (Radix 進数) Radix >= 2
//   RadixTable: 桁文字テーブル
//
// 戻り値
//   数値
// -----------------------------------------------------------------------------
var
  i: Byte;
  dRadixTable: String;
  dValue: Byte;
  Loop: Byte;
  s2: string;
begin
  result := 0;
  // Radix Table
  if RadixTable = '' then
    dRadixTable := FRadixTable
  else
    dRadixTable := RadixTable;
  // Error
  if Length(dRadixTable) < Radix then
    Exit;
  // Loop Counter
  s2 := Trim(s);
  for i:=1 to Length(s2) do
    if s2[i] = dRadixTable[1] then
      s2[i] := ' '
    else
      Break;
  s2 := Trim(s2);
  Loop := Length(s2);
  // Calc
  for i:=1 to Loop do
    begin
      result := result * Radix;
      dValue := Pos(s2[i], dRadixTable);
      if (dValue = 0) or (dValue > Radix) then
        begin
          result := 0;
          Break;
        end;
      result := result + (dValue - 1);
    end;
end;

function IntToExcelHexacos(const Value: Int64): string;
// -----------------------------------------------------------------------------
// 数値 -> Excel 桁文字列
//
// 引数
//   Value : 変換する数値
//
// 戻り値
//   Excel 桁形式 26 進数文字列
// -----------------------------------------------------------------------------
const
  RadixTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var
  dValue: UInt64;
  dDigits: TDigitsRange;
begin
  // Calc
  dValue  := 0;
  dDigits := 0;
  repeat
    Inc(dDigits);
    dValue := dValue + Trunc(IntPower(26, dDigits));
  until (Value < dValue);
  dValue := dValue - Trunc(IntPower(26, dDigits));
  result := IntToStrEx(Value - dValue, 26, dDigits, RadixTable);
end;

function ExcelHexacosToInt(const s: string): Int64;
// -----------------------------------------------------------------------------
// Excel 桁文字列 -> 数値
//
// 引数
//   s : Excel 桁形式 26 進数文字列
//
// 戻り値
//   数値
// -----------------------------------------------------------------------------
const
  RadixTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var
  i: Integer;
  s2: string;
begin
  s2 := Trim(s);
  // Calc
  result := StrToIntEx(s2, 26, RadixTable);
  for i:=1 to Length(s2)-1 do
    result := result + Trunc(IntPower(26, i));
end;
end.

var
  s: string;
  v: Int64;
begin
  Memo1.Lines.Clear;

  Memo1.Lines.Add('[Decimal -> Hex]');
  Memo1.Lines.Add('-10');

  // -10 を Byte (8 bit) の 16 進数表現で表示
  s := IntToStrEx(Byte(-10), 16, SizeOf(Byte) * 2);
  Memo1.Lines.Add('Byte: '     + s);
  // -10 を Word (16 bit) の 16 進数表現で表示
  s := IntToStrEx(Word(-10), 16, SizeOf(Word) * 2);
  Memo1.Lines.Add('Word: '     + s);
  // -10 を Longword (32 bit) の 16 進数表現で表示
  s := IntToStrEx(Longword(-10), 16, SizeOf(Longword) * 2);
  Memo1.Lines.Add('Longword: ' + s);
  // -10 を UInt64 (64 bit) の 16 進数表現で表示
  s := IntToStrEx(-10, 16, SizeOf(UInt64) * 2);
  Memo1.Lines.Add('UInt64: '   + s);

  Memo1.Lines.Add('');

  Memo1.Lines.Add('[Hex -> Decimal]');

  // 'FF' を 16 進数 -> 10 進値
  s := 'FF';
  Memo1.Lines.Add('0x' + s);
  v := Shortint(StrToIntEx(s, 16));
  Memo1.Lines.Add('Shortint: ' + IntToStr(v));
  v := Byte(StrToIntEx(s, 16));
  Memo1.Lines.Add('Byte: '     + UIntToStr(v));
  v := Smallint(StrToIntEx(s, 16));
  Memo1.Lines.Add('Smallint: ' + IntToStr(v));
  v := Word(StrToIntEx(s, 16));
  Memo1.Lines.Add('Word: '     + UIntToStr(v));
  Memo1.Lines.Add('');

  // 'FFFF' を 16 進数 -> 10 進値
  s := 'FFFF';
  Memo1.Lines.Add('0x' + s);
  v := Smallint(StrToIntEx(s, 16));
  Memo1.Lines.Add('Smallint: ' + IntToStr(v));
  v := Word(StrToIntEx(s, 16));
  Memo1.Lines.Add('Word: '     + UIntToStr(v));
  v := Longint(StrToIntEx(s, 16));
  Memo1.Lines.Add('Longint: '  + IntToStr(v));
  v := Longword(StrToIntEx(s, 16));
  Memo1.Lines.Add('Longword: ' + UIntToStr(v));
  Memo1.Lines.Add('');

  // 'FFFFFFFF' を 16 進数 -> 10 進値
  s := 'FFFFFFFF';
  Memo1.Lines.Add('0x' + s);
  v := Longint(StrToIntEx(s, 16));
  Memo1.Lines.Add('Longint: '  + IntToStr(v));
  v := Longword(StrToIntEx(s, 16));
  Memo1.Lines.Add('Longword: ' + UIntToStr(v));
  v := StrToIntEx(s, 16);
  Memo1.Lines.Add('Int64: '    + IntToStr(v));
  v := UInt64(StrToIntEx(s, 16));
  Memo1.Lines.Add('UInt64: '   + UIntToStr(v));
  Memo1.Lines.Add('');

  // 'FFFFFFFFFFFFFFFF' を 16 進数 -> 10 進値
  s := 'FFFFFFFFFFFFFFFF';
  Memo1.Lines.Add('0x' + s);
  v := StrToIntEx(s, 16);
  Memo1.Lines.Add('Int64: '    + IntToStr(v));
  v := UInt64(StrToIntEx(s, 16));
  Memo1.Lines.Add('UInt64: '   + UIntToStr(v));
end;

var
  dRadixTable: string;
  v: Int64;
  s: string;
begin
  // BASE32
  v := 100;
  dRadixTable :=               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  dRadixTable := dRadixTable + '234567';
  s := IntToStrEx(v, 32, 0, dRadixTable);
  Memo1.Lines.Add(s);

  // BASE64
  v := 100;
  dRadixTable :=               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  dRadixTable := dRadixTable + 'abcdefghijklmnopqrstuvwxyz';
  dRadixTable := dRadixTable + '+/';
  s := IntToStrEx(v, 64, 0, dRadixTable);
  Memo1.Lines.Add(s);
end;

var
  i: Integer;
  v: Int64;
  s: string;
begin
  Memo1.Lines.Clear;
  for i:=0 to 999 do
    begin
      s := IntToExcelHexacos(i);
      v := ExcelHexacosToInt(s);
      Memo1.Lines.Add(IntToStr(i) + ' : ' + s + ' -> ' + IntToStr(v));
    end;
end;