Re: [pdf-devel] New pdf_i64 functions using pdf_i32_t as input parameters

[Aleksander Morgado]

>    It would be simpler to have something like, where there is no need to 
>    have another extra variable for the '1':
>
>    pdf_i64_add_i32(&var1, var1, 1);
>
> Should not be difficult to add such convenience functions, so I would
> say to go ahead and implement it. 
>
> Also, a pdf_i64_to_i32 like function is also useful. 

Hi all,

Find attached the new set of pdf_i64_* functions. Both documentation and 
implementation of the functions are included. Didn't really test them 
yet, but they are quite simple so shouldn't be any problem if the 
underlying functions work correctly.

This should close task #40.

-Aleksander

Index: doc/gnupdf.texi
===================================================================
RCS file: /cvsroot/pdf/libgnupdf/doc/gnupdf.texi,v
retrieving revision 1.73
diff -r1.73 gnupdf.texi
622a623,661
> @deftypefun pdf_status_t pdf_i64_add_i32 (pdf_i64_t address@hidden, const 
> pdf_i64_t @var{addend1}, const pdf_i32_t @var{addend2})
> 
> Adds a 64bit number and a 32bit number.
> 
> @table @strong
> @item Parameters
> @table @var
> @item addend1
> First addend of the sum (64bit type)
> @item addend2
> Second addend of the sum (32 bit)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t addend_1;
> 
> addend_1 = pdf_i64_new(0, 25);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_add (dest, addend_1, 35) != PDF_OK) /* Now dest is 60 */
> @{
>    /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
> 
662a702,779
> @deftypefun pdf_status_t pdf_i64_subtraction_i32_min (pdf_i64_t 
> address@hidden, const pdf_i32_t @var{minuend}, const pdf_i64_t 
> @var{subtrahend})
> 
> Finds the difference between a 32bit number and a 64bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item minuend
> The minuend of the subtraction (32 bits)
> @item subtrahend
> The subtrahend of the subtraction (64 bits type)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t subtrahend;
> 
> subtrahend = pdf_i64_new(0, 35);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_subtraction (dest, 25, subtrahend) != PDF_OK) /* Now dest is -10 
> */
> @{
>   /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
> 
> @deftypefun pdf_status_t pdf_i64_subtraction_i32_sub (pdf_i64_t 
> address@hidden, const pdf_i64_t @var{minuend}, const pdf_i32_t 
> @var{subtrahend})
> 
> Finds the difference between a 64bit number and a 32bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item minuend
> The minuend of the subtraction (64 bits type)
> @item subtrahend
> The subtrahend of the subtraction (32 bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t minuend;
> 
> minuend = pdf_i64_new(0, 25);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_subtraction (dest, minuend, 35) != PDF_OK) /* Now dest is -10 */
> @{
>   /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
> 
702a820,857
> @deftypefun pdf_status_t pdf_i64_mult_i32 (pdf_i64_t address@hidden, const 
> pdf_i64_t @var{factor_1}, const pdf_i32_t @var{factor_2})
> 
> Multiplication of a 64bit number and a 32bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item factor_1
> First factor in the multiplication (64 bits)
> @item factor_2
> Second factor in the multiplication (32bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t factor_1;
> 
> factor_1 = pdf_i64_new (0, 10);
> result = pdf_i64_new (0, 0);
> dest = &result;
> 
> if (pdf_i64_mult (dest, factor_1, 100) != PDF_OK) /* Now dest is 1000 */
> @{
>    /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
738a894,961
> @deftypefun pdf_status_t pdf_i64_div_i32_dividend (pdf_i64_t address@hidden, 
> const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor})
> 
> Division of a 32bit number and a 64bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item dividend
> The dividend in the division (64 bits)
> @item divisor
> The divisor in the division (32 bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> PDF_OK        Operation successful
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t divisor;
> 
> divisor = pdf_i64_new(0, 10);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_div (dest, 200, divisor) != PDF_OK) /* Now dest is 20 */
> @{
>    /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
> @deftypefun pdf_status_t pdf_i64_div_i32_divisor (pdf_i64_t address@hidden, 
> const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor})
> 
> Division of a 64bit number and a 32bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item dividend
> The dividend in the division (64 bits)
> @item divisor
> The divisor in the division (32 bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> PDF_OK        Operation successful
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t dividend;
> 
> dividend = pdf_i64_new(0, 200);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_div (dest, dividend, 10) != PDF_OK) /* Now dest is 20 */
> @{
>    /* Error code */
> @}
> @end example
> @end table
> @end deftypefun
> 
779a1003,1078
> @deftypefun pdf_status_t pdf_i64_mod_i32_dividend (pdf_i64_t address@hidden, 
> const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor})
> 
> Returns the remainder of the division between a 32bit number and a 64bit 
> number
> 
> @table @strong
> @item Parameters
> @table @var
> @item dividend
> The dividend in the division (32bits)
> @item divisor
> The divisor in the division (64bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t divisor;
> 
> divisor = pdf_i64_new(0, 10);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_mod (dest, 105, divisor) != PDF_OK) /* Now dest is 5 */
> @{
>    /* Error code */
> @}    
> @end example
> @end table
> @end deftypefun
> 
> @deftypefun pdf_status_t pdf_i64_mod_i32_divisor (pdf_i64_t address@hidden, 
> const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor})
> 
> Returns the remainder of the division between a 64bit number and a 32bit 
> number
> 
> @table @strong
> @item Parameters
> @table @var
> @item dividend
> The dividend in the division (64 bits)
> @item divisor
> The divisor in the division (32 bits)
> @item dest
> Where 64 bit result is stored
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i64_t *dest;
> pdf_i64_t result;
> pdf_i64_t dividend;
> 
> dividend = pdf_i64_new(0, 105);
> result = pdf_i64_new(0, 0);
> dest = &result;
> 
> if (pdf_i64_mod (dest, dividend, 10) != PDF_OK) /* Now dest is 5 */
> @{
>    /* Error code */
> @}    
> @end example
> @end table
> @end deftypefun
> 
850a1150,1182
> @deftypefun int pdf_i64_cmp_i32 (const pdf_i64_t @var{number_1}, const 
> pdf_i32_t @var{number_2})
> 
> Compares a 64bit number and a 32bit number
> 
> @table @strong
> @item Parameters
> @table @var
> @item number_1
> pdf_i64_t type variable
> @item number_2
> pdf_i32_t type variable
> @end table
> @item Returns
> An integer:
> @table @code
> @item 0
> If numbers are equal
> @item 1
> If @var{number_1} is greater than @var{number_2}
> @item -1
> If @var{number_2} is greater than @var{number_1}
> @end table
> @item Usage example
> @example
> pdf_i65_t number_1;
> int result;
> 
> number_1 = pdf_i64_new ((32 << 1), 10); /* number_1 is -10 */
> result = pdf_i64_cmp (number_1, 10); /* Now result is -1 */
> @end example
> @end table
> @end deftypefun
> 
884a1217,1246
> @deftypefun pdf_i32_t pdf_i64_to_i32 (const pdf_i64_t @var{bignum})
> 
> Converts a pdf_i64_t to a 32bit value. If number can't be represented in 32 
> bits
> the result is undefined, so should be used with caution.
> 
> @table @strong
> @item Parameters
> @table @var
> @item bignum
> pdf_i64_t type variable
> @end table
> @item Returns
> A pdf status value:
> @table @code
> @item PDF_OK
> Operation successful
> @end table
> @item Usage example
> @example
> pdf_i32_t num;
> pdf_i64_t bignum;
> 
> bignum = pdf_i64_new (0, 10);
> 
> num = pdf_i64_to_i32(bignum);
> 
> @end example
> @end table
> @end deftypefun
> 
Index: src/base/pdf-types.c
===================================================================
RCS file: /cvsroot/pdf/libgnupdf/src/base/pdf-types.c,v
retrieving revision 1.5
diff -r1.5 pdf-types.c
1032a1033,1143
> 
> 
> 
> /* NOTE for all those functions receiving pdf_i32_t as input, where internal
>  * conversion to pdf_i64_t is done: We know that pdf_i64_new function doesn't 
>  * really do memory allocation, so we could directly call 
> pdf_i64_assign_quick.
>  * This is not allowed outside the basic types module, where pdf_i64_new must
>  * always be called. */
> 
> /* Add a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_add_i32(pdf_i64_t *dest, const pdf_i64_t addend1, const pdf_i32_t 
> addend2)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, addend2);
>   return pdf_i64_add(dest, addend1, aux);
> }
> 
> /* Compare a pdf_i64_t and a pdf_i32_t */
> int pdf_i64_cmp_i32(const pdf_i64_t number_1, const pdf_i32_t number_2)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, number_2);
>   return pdf_i64_cmp(number_1, aux);
> }
> 
> 
> /* Subtract a pdf_i64_t and a pdf_i32_t variable */
> pdf_status_t 
> pdf_i64_subtraction_i32_min(pdf_i64_t *dest, \
>                             const pdf_i32_t minuend, \
>                             const pdf_i64_t subtrahend)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, minuend);
>   return pdf_i64_subtraction(dest, aux, subtrahend);
> }
> pdf_status_t 
> pdf_i64_subtraction_i32_sub(pdf_i64_t *dest, \
>                             const pdf_i64_t minuend, \
>                             const pdf_i32_t subtrahend)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, subtrahend);
>   return pdf_i64_mult(dest, minuend, aux);
> }
> 
> 
> /* Multiply a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_mult_i32(pdf_i64_t *dest, \
>                  const pdf_i64_t factor_1, \
>                  const pdf_i32_t factor_2)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, factor_2);
>   return pdf_i64_mult(dest, factor_1, aux);
> }
> 
> 
> /* Division between a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_div_i32_dividend(pdf_i64_t *dest, \
>                          const pdf_i32_t dividend, \
>                          const pdf_i64_t divisor)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, dividend);
>   return pdf_i64_div(dest, aux, divisor);
> }
> pdf_status_t 
> pdf_i64_div_i32_divisor(pdf_i64_t *dest, \
>                         const pdf_i64_t dividend, \
>                         const pdf_i32_t divisor)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, divisor);
>   return pdf_i64_div(dest, dividend, aux);
> }
> 
> 
> /* Modulus between a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_mod_i32_dividend(pdf_i64_t *dest, \
>                          const pdf_i32_t dividend, \
>                          const pdf_i64_t divisor)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, dividend);
>   return pdf_i64_mod(dest, aux, divisor);
> }
> pdf_status_t 
> pdf_i64_mod_i32_divisor(pdf_i64_t *dest, \
>                         const pdf_i64_t dividend, \
>                         const pdf_i32_t divisor)
> {
>   pdf_i64_t aux;
>   pdf_i64_assign_quick(&aux, divisor);
>   return pdf_i64_mod(dest, dividend, aux);
> }
> 
> 
> 
> /* Get number as pdf_i32_t */
> pdf_i32_t
> pdf_i64_get_i32(const pdf_i64_t bignum)
> {
>   /* From the highest 32bits, take the sign only */
>   return ((bignum.high >= 0) ? bignum.low : (-1 * bignum.low));
> }
> 
Index: src/base/pdf-types.h
===================================================================
RCS file: /cvsroot/pdf/libgnupdf/src/base/pdf-types.h,v
retrieving revision 1.12
diff -r1.12 pdf-types.h
92a93,96
> 
> /********************** 64-bit type built-in support 
> **************************/
> 
> 
104c108,109
< pdf_i64_t pdf_i64_new(const pdf_i32_t high, const pdf_u32_t low);
---
> pdf_i64_t pdf_i64_new(const pdf_i32_t high, \
>                       const pdf_u32_t low);
121a127,129
> /* Add a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_add_i32(pdf_i64_t *dest, const pdf_i64_t addend1, const pdf_i32_t 
> addend2);
124a133,134
> /* Compare a pdf_i64_t and a pdf_i32_t */
> int pdf_i64_cmp_i32(const pdf_i64_t number_1, const pdf_i32_t number_2);
136a147,151
> /* Subtract a pdf_i64_t and a pdf_i32_t variable */
> pdf_status_t 
> pdf_i64_subtraction_i32_min(pdf_i64_t *dest, const pdf_i32_t minuend, const 
> pdf_i64_t subtrahend);
> pdf_status_t 
> pdf_i64_subtraction_i32_sub(pdf_i64_t *dest, const pdf_i64_t minuend, const 
> pdf_i32_t subtrahend);
140a156,158
> /* Multiply a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_mult_i32(pdf_i64_t *dest, const pdf_i64_t factor_1, const pdf_i32_t 
> factor_2);
144a163,167
> /* Divide a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_div_i32_dividend(pdf_i64_t *dest, const pdf_i32_t dividend, const 
> pdf_i64_t divisor);
> pdf_status_t 
> pdf_i64_div_i32_divisor(pdf_i64_t *dest, const pdf_i64_t dividend, const 
> pdf_i32_t divisor);
148a172,183
> /* Modulus between a pdf_i64_t and a pdf_i32_t */
> pdf_status_t 
> pdf_i64_mod_i32_dividend(pdf_i64_t *dest, const pdf_i32_t dividend, const 
> pdf_i64_t divisor);
> pdf_status_t 
> pdf_i64_mod_i32_divisor(pdf_i64_t *dest, const pdf_i64_t dividend, const 
> pdf_i32_t divisor);
> 
> 
> /* Get number as pdf_i32_t. Note that if the pdf_i64_t variable is holding a 
>  * number which can't be represented in 32bits, the result is undefined... so
>  * use it with caution. */
> pdf_i32_t
> pdf_i64_get_i32(const pdf_i64_t bignum);