|
###########################################################################
##
#W omputbin.gi OpenMath Package Max Nicosia
##
##
#Y Copyright (C) 1999, 2000, 2001, 2006
#Y School Math and Comp. Sci., University of St. Andrews, Scotland
#Y Copyright (C) 2004, 2005, 2006 Marco Costantini
##
## Low-level methods for output in the OpenMath binary format
##
###########################################################################
##
#M BigIntToListofInts( <integer> )
##
## Returns a list of 4 integers as to represent the number over 4 bytes
##
BindGlobal ( "BigIntToListofInts", function(int)
local hexValue, hexValueLength, finalHexString, lengthDiff, listofInts;
listofInts:=[];
finalHexString := "";
hexValue := HexStringInt(int);
hexValueLength := Length(hexValue);
if (hexValueLength < 8) then
lengthDiff := 8 - hexValueLength;
while lengthDiff > 0 do
Append(finalHexString,"0");
lengthDiff := lengthDiff - 1;
od;
fi;
Append(finalHexString, hexValue);
Add(listofInts, IntHexString(finalHexString{[1..2]}));
Add(listofInts, IntHexString(finalHexString{[3..4]}));
Add(listofInts, IntHexString(finalHexString{[5..6]}));
Add(listofInts, IntHexString(finalHexString{[7..8]}));
return listofInts;
end);
###########################################################################
#
#M IsIntFloat( <object> )
#
# Checks whethere it is a real float
BindGlobal( "IsIntFloat", function(x)
return Float(0) = x-Float(Int(x));
end);
###########################################################################
##
#M CreateListWithFalses( <integer> )
##
## Returns a list with the number of falses specified,
## if 0 then returns an empty list.
##
BindGlobal( "CreateListWithFalses", function(numFalses)
local listFalses, i;
listFalses := [];
for i in [1..numFalses] do
listFalses[i]:=false;
od;
return listFalses;
end);
###########################################################################
##
#M WriteIntasBytes( <stream>, <list> )
##
## Writes an integer as four bytes given a list representing the integer,
## in binary and the stream
##
BindGlobal( "WriteIntasBytes", function( stream, listofInts )
WriteByte(stream, listofInts[1]);
WriteByte(stream, listofInts[2]);
WriteByte(stream, listofInts[3]);
WriteByte(stream, listofInts[4]);
end);
###########################################################################
##
#M FindFirst1BinaryString( <string> )
##
## Obtains position of first 1 in the binary string
##
BindGlobal( "FindFirst1BinaryString", function( binStri )
local i, binStriLen;
binStriLen := Length(binStri);
i := 1;
while binStri[i] <> '1' and i <= binStriLen do
i := i +1;
od;
return i;
end);
###########################################################################
##
#M WriteDecasHex( <float> )
##
## Returns the decimal number in a hexadecimal representation
##
BindGlobal( "WriteDecasHex", function( decPart )
local intPart, resultHex, number, i, zeroF;
i := 0;
resultHex := "";
zeroF := Float("0.0");
while decPart <> zeroF do
if i > 10 then
break;
fi;
number := decPart * 16;
intPart := Int(number);
decPart := number - intPart;
Append(resultHex, HexStringInt(intPart));
i := i +1;
od;
return resultHex;
end);
###########################################################################
##
#M WriteHexAsBin( <hexNum>, <bool> )
##
## Returns the given hexadecimal number as a binary string.
## Leading zeroes are included if the flag is set to TRUE.
##
BindGlobal( "WriteHexAsBin", function( hexNum, withLeadingZeroes )
local hexNumLen, binStri, num, charStri, counter,
binArrayWithZeroes, binArrayNoLeadingZeroes;
hexNumLen := Length(hexNum);
binStri := "";
counter:= 1;
binArrayWithZeroes :=
["0000", "0001" ,"0010", "0011", "0100", "0101", "0110", "0111",
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"];
binArrayNoLeadingZeroes :=
["", "1" ,"10", "11", "100", "101", "110", "111", "1000",
"1001", "1010", "1011", "1100", "1101", "1110", "1111"];
charStri := hexNum{[counter]};
num := IntHexString(charStri);
if withLeadingZeroes then
Append(binStri, binArrayWithZeroes[num+1]);
else
Append(binStri, binArrayNoLeadingZeroes[num+1]);
fi;
counter := counter +1;
while counter <= hexNumLen do
charStri := hexNum{[counter]};
num := IntHexString(charStri);
Append(binStri, binArrayWithZeroes[num+1]);
counter := counter +1;
od;
return binStri;
end);
###########################################################################
##
#M WriteBinAsHex( <string> )
##
## Returns the binary string passed as a hexadecimal number
##
BindGlobal( "WriteBinAsHex", function( binStri )
local binStriLen, hexStri, counter, binArray,hexArray, limit, upper, lower;
binStriLen := Length(binStri);
hexStri := "";
counter:= 1;
binArray :=
["0000", "0001" ,"0010", "0011", "0100", "0101", "0110", "0111",
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"];
hexArray :=
["0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "A", "B", "C", "D", "E", "F"];
#limit := binStriLen /4;
upper := 4;
lower := 1;
while upper <= binStriLen do
for counter in [1..16] do
if binStri{[lower..upper]} = binArray[counter] then
Append(hexStri, hexArray[counter]);
break;
fi;
counter := counter + 1;
od;
upper := upper +4;
lower := lower + 4;
od;
return hexStri;
end);
###########################################################################
###
##M
## removes all falses at the start of the list.
#BindGlobal( "NormaliseBlist",
#function( list )
#local i, listLen, finalList;
#i:= 1;
#listLen := Length(list);
#while i <= listLen and list[i] = false do
# i := i +1;
#od;
#if i >= listLen then
# finalList := [list[listLen]];
#else
# finalList := list{[i..listLen]};
#fi;
#list := finalList;
#return i;
#end);
###########################################################################
##
#M WriteHexStriAsBytes( <string>, <stream> )
##
## Writes the hexadecimal string to the stream as bytes.
##
BindGlobal( "WriteHexStriAsBytes", function( hexStri, stream )
local hexStriLen, intValue, upper, lower;
upper := 2;
lower := 1;
intValue := 0;
hexStriLen := Length(hexStri);
while upper <= hexStriLen do
intValue := IntHexString(hexStri{[lower..upper]});
WriteByte(stream, intValue);
upper := upper +2;
lower := lower +2;
od;
end);
###########################################################################
##
#M WriteBinStringsAsBytes( <)
##
##
BindGlobal("WriteBinStringsAsBytes", function(sign,exponent,mantissa,stream)
local exponentLen, mantissaLen, firstPart, secondPart, numbZeroes, hexStri;
exponentLen := Length(exponent);
mantissaLen := Length(mantissa);
firstPart := "";
secondPart := mantissa;
if sign then
Append(firstPart, "1" );
else
Append(firstPart, "0" );
fi;
if exponentLen < 11 then
numbZeroes := 11 - exponentLen ;
while numbZeroes <> 0 do
Append(firstPart, "0");
numbZeroes := numbZeroes - 1;
od;
fi;
Append(firstPart, exponent);
if mantissaLen < 52 then
numbZeroes := 52 - mantissaLen;
while numbZeroes <> 0 do
Append(secondPart, "0");
numbZeroes := numbZeroes -1;
od;
fi;
Append(firstPart,secondPart);
hexStri := WriteBinAsHex(firstPart);
WriteHexStriAsBytes(hexStri, stream);
end);
###########################################################################
##
#O OMPutOMOBJ( <stream> )
#O OMPutEndOMOBJ( <stream> )
##
InstallMethod(OMPutOMOBJ, "to write OMOBJ in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 24 );
end);
InstallMethod(OMPutEndOMOBJ, "to write /OMOBJ in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 25 );
end);
###########################################################################
##
#M OMPut( <OMWriter>, <int> )
##
## Printing for integers: specified in the standard
##
InstallMethod(OMPut, "for an integer to binary OpenMath", true,
[ IsOpenMathBinaryWriter, IsInt ],0,
function( writer, int )
local intStri, intLength, intListLength;
intStri := String(AbsInt(int));
intLength := Length(intStri);
if int >= -128 and int <= 127 then
WriteByte( writer![1], 1);
if int < 0 then
int := 256 + int;
fi;
WriteByte(writer![1], int);
elif int >= -2^31 and int <= 2^31-1 then
WriteByte( writer![1], 129); #1+128
if int < 0 then
int := 2^32 + int;
fi;
intListLength := BigIntToListofInts(int);
WriteIntasBytes(writer![1], intListLength);
elif intLength >= 0 and intLength <= 255 then
WriteByte( writer![1], 2);
WriteByte(writer![1], intLength);
if int < 0 then
WriteByte(writer![1], 45); #base 10 | sign -
else
WriteByte(writer![1], 43); #base 10 | sign +
fi;
WriteAll(writer![1], intStri);
elif intLength > 255 then
WriteByte( writer![1], 130);#2+128
intListLength := BigIntToListofInts(intLength);
WriteIntasBytes(writer![1], intListLength);
if int < 0 then
WriteByte(writer![1], 45); #base 10 | sign -
else
WriteByte(writer![1], 43); #base 10 | sign +
fi;
WriteAll(writer![1], intStri);
fi;
end);
###########################################################################
##
#M OMPut( <OMWriter>, <float> )
##
##
##
InstallMethod(OMPut, "for a float to binary OpenMath", true,
[ IsOpenMathBinaryWriter, IsFloat ],0,
function(writer, f)
local intPart, decPart, sign, decHex, decBin, decBinLen, exponent,
pos, mantissa, intBin, absIntPart;
WriteByte( writer![1], 3);
if f > 0 then
sign := false;
else
sign := true;
fi;
intPart := Int(f);
if IsIntFloat(f) then
decPart := 0;
else
decPart := f - intPart;
fi;
decHex := WriteDecasHex(decPart);
decBin := WriteHexAsBin(decHex, true);
decBinLen := Length(decBin);
absIntPart := AbsInt(intPart);
if absIntPart = 0 then
pos := FindFirst1BinaryString(decBin);
exponent := 1023 - pos;
exponent := WriteHexAsBin(HexStringInt(exponent), false);
mantissa := decBin{[pos+1..decBinLen]};
else
intBin := WriteHexAsBin(HexStringInt(absIntPart),false);
pos := Length(intBin) -1;
exponent := 1023 + pos;
exponent := WriteHexAsBin(HexStringInt(exponent), false);
Append(intBin, decBin);
mantissa := intBin{[2..Length(intBin)]};
fi;
if Length(mantissa) > 52 then
mantissa := mantissa{[1..52]};
fi;
WriteBinStringsAsBytes( sign, exponent, mantissa , writer![1]);
end);
###########################################################################
##
#M OMPutVar( <OMWriter>, <variable> )
##
##
##
InstallMethod(OMPutVar, "for a variable to binary OpenMath", true,
[ IsOpenMathBinaryWriter, IsObject ],0,
function(writer, var)
local varLength, varStri, varLengthList;
varStri := String(var);
varLength := Length(varStri);
if varLength >= 256 then
WriteByte( writer![1], 133); #5+128
varLengthList := BigIntToListofInts(varLength);
WriteIntasBytes(writer![1], varLengthList);
else
WriteByte( writer![1], 5);
WriteByte(writer![1], varLength);
fi;
WriteAll(writer![1], varStri);
end);
###########################################################################
##
#M OMPut( <OMWriter>, <symbol> )
##
##
##
InstallMethod( OMPutSymbol, "for a symbol to binary OpenMath", true,
[IsOpenMathBinaryWriter, IsString, IsString ],0,
function( writer, cd, name )
local cdLength, nameLength, cdListInt, nameListInt;
nameListInt := [];
cdLength := Length(cd);
nameLength := Length(name);
if (cdLength > 255 or nameLength > 255) then
WriteByte( writer![1], 136); #128+8
cdListInt := BigIntToListofInts(cdLength);
nameListInt := BigIntToListofInts(nameLength);
#writing the cd length as 4 bytes
WriteIntasBytes(writer![1], cdListInt);
#writing the name length as 4 bytes
WriteIntasBytes(writer![1], nameListInt);
else
WriteByte(writer![1], 8);
WriteByte(writer![1], cdLength);
WriteByte(writer![1], nameLength);
fi;
WriteAll(writer![1], cd);
WriteAll(writer![1], name);
end);
###########################################################################
##
#M OMPutOMATTR
#M OMPutEndOMATTR
##
InstallMethod(OMPutOMATTR, "to write OMATTR in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 18 );
end);
InstallMethod(OMPutEndOMATTR, "to write /OMATTR in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
OMIndent := OMIndent - 1;
WriteByte( writer![1], 19 );
end);
###########################################################################
##
#M OMPutOMATP
#M OMPutEndOMATP
##
InstallMethod(OMPutOMATP, "to write OMATP in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 20);
end);
InstallMethod(OMPutEndOMATP, "to write /OMATP in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 21 );
end);
###########################################################################
##
#M OMPutOMBIND
#M OMPutEndOMBIND
##
InstallMethod(OMPutOMBIND, "to write OMBIND in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 26 );
end);
InstallMethod(OMPutEndOMBIND, "to write /OMBIND in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 27 );
end);
###########################################################################
##
#M OMPutOMBVAR
#M OMPutEndOMBVAR
##
InstallMethod(OMPutOMBVAR, "to write OMBVAR in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 28 );
end);
InstallMethod(OMPutEndOMBVAR, "to write /OMBVAR in Binary OpenMath", true,
[IsOpenMathBinaryWriter],0,
function( writer )
WriteByte( writer![1], 29 );
end);
###########################################################################
##
#M OMPutByteArray( <OMWriter>, <bitList> )
##
##
InstallGlobalFunction( OMPutByteArray, function( writer, bitList )
# TODO: fill the 2nd branch and move this function to omput.gi
local numBytesLength, bitListLength, tempList, numFalses, hexStri,
numBytes, quoVal, modVal;
if IsOpenMathBinaryWriter(writer) then
bitListLength := Length(bitList);
quoVal := QuoInt(bitListLength,8);
modVal := bitListLength mod 8;
if quoVal = 0 then
numBytes := 1;
numFalses := 8 - bitListLength;
else
if modVal <> 0 then
numBytes := quoVal +1;
numFalses := 8 - modVal;
else
numBytes := quoVal;
numFalses := 0;
fi;
fi;
if numBytes > 255 then
numBytesLength := BigIntToListofInts(numBytes);
WriteByte(writer![1],132); #4+128
#writing the string length as 4 bytes
WriteIntasBytes(writer![1], numBytesLength);
else
WriteByte(writer![1],4);
WriteByte(writer![1], numBytes);
fi;
tempList := CreateListWithFalses(numFalses);
Append(tempList, bitList);
hexStri := HexStringBlist(tempList);
WriteHexStriAsBytes(hexStri, writer![1]);
else
Error("Bytearrays are not supported in the XML mode yet!");
fi;
end);
###########################################################################
##
#M OMPut( <OMWriter>, <string> )
##
##
InstallMethod(OMPut, "for a string to binary OpenMath", true,
[IsOpenMathBinaryWriter, IsString ],0,
function( writer, string )
local strLength, strListLength;
strLength := Length(string);
if strLength > 255 then
strListLength := BigIntToListofInts(strLength);
WriteByte(writer![1], 134); # 6+128
#writing the string length as 4 bytes
WriteIntasBytes(writer![1], strListLength);
else
WriteByte(writer![1], 6);
WriteByte(writer![1], strLength);
fi;
WriteAll(writer![1],string);
end);
###########################################################################
##
#M OMPut( <OMWriter>, <foreign> )
##
##
InstallMethod( OMPutForeign, "for a foreign object to binary OpenMath", true,
[IsOpenMathBinaryWriter, IsString, IsString ],0,
function( writer, encString, objString )
local encStrLength, encStrListLength, objStrLength, objStrListLength;
encStrLength := Length(encString);
objStrLength := Length(objString);
if encStrLength > 255 or objStrLength > 255 then
WriteByte(writer![1], 140);#12+128
encStrListLength := BigIntToListofInts(encStrLength);
objStrListLength := BigIntToListofInts(objStrLength);
WriteIntasBytes(writer![1], encStrListLength);
WriteIntasBytes(writer![1], objStrListLength);
else
WriteByte(writer![1], 12);
WriteByte(writer![1], encStrLength);
WriteByte(writer![1], objStrLength);
fi;
WriteAll(writer![1], encString);
WriteAll(writer![1], objString);
end);
###########################################################################
##
#M OMPutOMAWithId( <OMWriter>, <reference> )
##
##
InstallMethod( OMPutOMAWithId, "to put Applications with Ids", true,
[IsOpenMathBinaryWriter , IsString],0,
function(writer, reference)
local referenceList, referenceLen;
referenceLen := Length(reference);
if referenceLen > 255 then
referenceList := BigIntToListofInts(referenceLen);
WriteByte(writer![1], 208); # 16+64+128
#writing the reference length as 4 bytes
WriteIntasBytes(writer![1], referenceList);
else
WriteByte(writer![1], 80); #16+64
WriteByte(writer![1], referenceLen);
fi;
WriteAll(writer![1], reference);
end);
###########################################################################
##
#O OMPutOMA( <OMWriter> );
#O OMPutEndOMA( <OMWriter> );
##
##
InstallMethod(OMPutOMA, "to write OMA in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 16 );
end);
InstallMethod(OMPutEndOMA, "to write /OMA in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 17 );
end);
###########################################################################
##
#O OMPutOME( <OMWriter> );
#O OMPutEndOME( <OMWriter> );
##
##
InstallMethod(OMPutOME, "to write OME in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 22 );
end);
InstallMethod(OMPutEndOME, "to write /OME in binary OpenMath", true,
[ IsOpenMathBinaryWriter ], 0,
function( writer )
WriteByte( writer![1], 23 );
end);
###########################################################################
##
#M OMPut( <OMWriter>, <reference> )
##
## deals with external references for now
##
InstallMethod( OMPutReference, "for a stream and an object with reference",
true, [ IsOpenMathBinaryWriter, IsObject ], 0,
function( writer, x )
local refStri, refLength, lengthList;
if HasOMReference( x ) and not SuppressOpenMathReferences then
refStri := OMReference( x );
refLength := Length(refStri);
if refLength > 255 then
WriteByte (writer![1], 159); #31+128
lengthList := BigIntToListofInts(refLength);
WriteIntasBytes(writer![1], lengthList);
else
WriteByte (writer![1], 31);
WriteByte (writer![1], refLength);
fi;
WriteAll(writer![1], refStri);
else
OMPut( writer, x );
fi;
end);
###########################################################################
#E
[ Verzeichnis aufwärts0.34unsichere Verbindung
Übersetzung europäischer Sprachen durch Browser
]
|
