Merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba

[Paul J. Lucas]

Completely reworked the implementation of Integer so that it now correctly handles xs:integer, xs:negativeInteger, xs:nonNegativeInteger, and xs:positiveInteger.

Also cleaned-up #includes for Zorba classes so as to reduce uncessary #includes.

This is an intermediate merge proposal just go get all of the above changes in. The actual fix for distinct-values() will come later depending on the outcome of the thread posted to zorba-dev.

Completely reworked the implementation of Integer so that it now correctly handles xs:integer, xs:negativeInteger, xs:nonNegativeInteger, and xs:positiveInteger.

Also cleaned-up #includes for Zorba classes so as to reduce uncessary #includes.

This is an intermediate merge proposal just go get all of the above changes in. The actual fix for distinct-values() will come later depending on the outcome of the thread posted to zorba-dev.

[Paul J. Lucas (paul-lucas)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-04-30T14-52-16.682Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-04-30T14-52-16.682Z is finished. The
  final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-04-30T15-05-58.851Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-04-30T15-05-58.851Z is finished. The
  final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-04-30T17-37-58.355Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-04-30T17-37-58.355Z is finished. The
  final status was:

  25 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-04-30T23-29-18.17Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-04-30T23-29-18.17Z is finished. The
  final status was:

  25 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-01T04-39-58.887Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-05-01T04-39-58.887Z is finished. The
  final status was:

  8 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-04T00-48-32.868Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-05-04T00-48-32.868Z is finished. The
  final status was:

  3 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-04T17-34-09.498Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-05-04T17-34-09.498Z is finished. The
  final status was:

  2 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-05T03-23-20.786Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~paul-lucas/zorba/bug-1090089 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug-1090089-2013-05-05T03-23-20.786Z is finished. The
  final status was:

  1 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-05T03-55-20.658Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug-1090089-2013-05-05T03-55-20.658Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Approve.

[lp:~paul-lucas/zorba/bug-1090089]

11442. By Paul J. Lucas on 2013-05-06

Merge from trunk.

11443. By Paul J. Lucas on 2013-05-06

Cosmetic change.

11444. By Paul J. Lucas on 2013-05-07

Now always returning Integer for binary operators.

11445. By Paul J. Lucas on 2013-05-08

Merge from trunk.

11446. By Paul J. Lucas on 2013-05-08

Updated ChangeLog.

11447. By Paul J. Lucas on 2013-05-08

Undid change.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug-1090089-2013-05-08T19-45-21.587Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug-1090089-2013-05-08T19-45-21.587Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2013-05-08 03:22:27 +0000
+++ ChangeLog	2013-05-08 15:05:31 +0000
@@ -1,5 +1,6 @@
 Zorba - The XQuery Processor
 
+
 version 2.9
 
 New Features:
 
=== modified file 'src/api/dynamiccontextimpl.cpp'
--- src/api/dynamiccontextimpl.cpp	2013-05-08 03:19:57 +0000
+++ src/api/dynamiccontextimpl.cpp	2013-05-08 15:05:31 +0000
@@ -27,6 +27,7 @@
 #include "types/typemanager.h"
 #include "types/root_typemanager.h"
 #include "types/schema/validate.h"
+#include "zorbatypes/integer.h"
 
 #include "api/unmarshaller.h"
 #include "api/zorbaimpl.h"
 
=== modified file 'src/api/item.cpp'
--- src/api/item.cpp	2013-02-26 04:12:43 +0000
+++ src/api/item.cpp	2013-05-08 15:05:31 +0000
@@ -38,7 +38,9 @@
 #include "store/api/iterator.h"
 #include "store/api/collection.h"
 
-#include <zorbatypes/numconversions.h>
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/numconversions.h"
 
 namespace zorba {
 
 
=== modified file 'src/api/itemfactoryimpl.cpp'
--- src/api/itemfactoryimpl.cpp	2013-03-27 03:30:14 +0000
+++ src/api/itemfactoryimpl.cpp	2013-05-08 15:05:31 +0000
@@ -25,14 +25,17 @@
 
 #include "api/itemfactoryimpl.h"
 
-#include "zorbatypes/duration.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/schema_types.h"
 
 #include "system/globalenv.h"
 
+#include "store/api/copymode.h"
+#include "store/api/item.h"
 #include "store/api/item_factory.h"
 #include "store/api/store.h"
-#include "store/api/copymode.h"
-#include "store/api/item.h"
 
 #include "api/unmarshaller.h"
 
 
=== modified file 'src/api/serialization/serializer.cpp'
--- src/api/serialization/serializer.cpp	2013-04-25 02:05:20 +0000
+++ src/api/serialization/serializer.cpp	2013-05-08 15:05:31 +0000
@@ -39,6 +39,7 @@
 
 #include "system/globalenv.h"
 #include "zorbamisc/ns_consts.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 
 #include "store/api/iterator.h"
 
=== modified file 'src/capi/csequence.cpp'
--- src/capi/csequence.cpp	2013-02-07 17:24:36 +0000
+++ src/capi/csequence.cpp	2013-05-08 15:05:31 +0000
@@ -18,16 +18,17 @@
 #include "capi/csequence.h"
 
 #include <cassert>
-#include <string.h>
+#include <cstring>
 
 #include <zorba/zorba.h>
 #include <zorba/diagnostic_list.h>
 #include <zorba/iterator.h>
 #include <zorba/store_consts.h>
-#include <zorbamisc/ns_consts.h>
-#include <zorbatypes/numconversions.h>
 
 #include "util/string_util.h"
+#include "zorbamisc/ns_consts.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/numconversions.h"
 
 #include "error.h"
 
 
=== modified file 'src/common/shared_types.h'
--- src/common/shared_types.h	2013-04-26 04:44:36 +0000
+++ src/common/shared_types.h	2013-05-08 15:05:31 +0000
@@ -133,18 +133,20 @@
 typedef rchandle<GMonth> GMonth_t;
 
 /* numerics */
-template<typename FloatType> class FloatImpl;
+template<typename F> class FloatImpl;
 typedef FloatImpl<double> Double;
 typedef FloatImpl<float>  Float;
-#ifdef ZORBA_WITH_BIG_INTEGER
-class IntegerImpl;
-typedef IntegerImpl Integer;
-typedef IntegerImpl UInteger;
-#else
-template<typename IntType> class IntegerImpl;
-typedef IntegerImpl<long long> Integer;
-typedef IntegerImpl<unsigned long long> UInteger;
-#endif /* ZORBA_WITH_BIG_INTEGER */
+class integer_traits;
+class negative_traits;
+class nonNegative_traits;
+class nonPositive_traits;
+class positive_traits;
+template<class T> class IntegerImpl;
+typedef IntegerImpl<integer_traits>     Integer;
+typedef IntegerImpl<negative_traits>    NegativeInteger;
+typedef IntegerImpl<nonNegative_traits> NonNegativeInteger;
+typedef IntegerImpl<nonPositive_traits> NonPositiveInteger;
+typedef IntegerImpl<positive_traits>    PositiveInteger;
 
 /* api */
 class serializer;
 
=== modified file 'src/compiler/expression/expr.cpp'
--- src/compiler/expression/expr.cpp	2013-03-07 10:10:10 +0000
+++ src/compiler/expression/expr.cpp	2013-05-08 15:05:31 +0000
@@ -49,6 +49,9 @@
 
 #include "store/api/store.h"
 #include "store/api/item_factory.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba
 
=== modified file 'src/compiler/expression/expr_manager.cpp'
--- src/compiler/expression/expr_manager.cpp	2013-04-16 20:06:08 +0000
+++ src/compiler/expression/expr_manager.cpp	2013-05-08 15:05:31 +0000
@@ -15,22 +15,24 @@
  */
 
 #include "stdafx.h"
+
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
+
+#include "expr.h"
 #include "expr_manager.h"
-
-#include "mem_manager.h"
-
-#include "expr.h"
-#include "ftnode.h"
-#include "var_expr.h"
 #include "flwor_expr.h"
 #include "fo_expr.h"
 #include "ft_expr.h"
+#include "ftnode.h"
 #include "function_item_expr.h"
+#include "json_exprs.h"
+#include "mem_manager.h"
 #include "path_expr.h"
+#include "pragma.h"
 #include "script_exprs.h"
 #include "update_exprs.h"
-#include "json_exprs.h"
-#include "pragma.h"
+#include "var_expr.h"
 
 namespace zorba
 {
 
=== modified file 'src/compiler/parser/jsoniq_parser.cpp'
--- src/compiler/parser/jsoniq_parser.cpp	2013-04-24 17:26:02 +0000
+++ src/compiler/parser/jsoniq_parser.cpp	2013-05-08 15:05:31 +0000
@@ -50,14 +50,13 @@
 #pragma warning(disable: 4786)
 #endif
 
+#include "compiler/api/compilercb.h"
+#include "compiler/parser/parse_constants.h"
+#include "compiler/parser/parser_helpers.h"
+#include "compiler/parser/xquery_driver.h"
 #include "compiler/parsetree/parsenodes.h"
-#include "compiler/parser/parse_constants.h"
-#include "compiler/api/compilercb.h"
 #include "store/api/update_consts.h"
-
-#include "compiler/parser/xquery_driver.h"
-
-#include "compiler/parser/parser_helpers.h"
+#include "zorbatypes/integer.h"
 
 #define SYMTAB( n ) driver.symtab.get( (off_t)n )
 #define SYMTAB_PUT( s ) driver.symtab.put( s )
 
=== modified file 'src/compiler/parser/parser_helpers.h'
--- src/compiler/parser/parser_helpers.h	2013-03-16 00:58:28 +0000
+++ src/compiler/parser/parser_helpers.h	2013-05-08 15:05:31 +0000
@@ -23,6 +23,8 @@
 
 namespace zorba {
 
+  class location;
+
   namespace parser {
 
     extern const char *the_tumbling, *the_sliding, *the_start, *the_end, *the_only_end, *the_declare, *the_create;
 
=== modified file 'src/compiler/parser/parser_y_includes.h'
--- src/compiler/parser/parser_y_includes.h	2013-04-17 18:08:27 +0000
+++ src/compiler/parser/parser_y_includes.h	2013-05-08 15:05:31 +0000
@@ -60,14 +60,14 @@
 #pragma warning(disable: 4786)
 #endif
 
-#include "compiler/parsetree/parsenodes.h"
+#include "compiler/api/compilercb.h"
 #include "compiler/parser/parse_constants.h"
-#include "compiler/api/compilercb.h"
+#include "compiler/parser/parser_helpers.h"
+#include "compiler/parser/xquery_driver.h"
+#include "compiler/parsetree/parsenodes.h"
 #include "store/api/update_consts.h"
-
-#include "compiler/parser/xquery_driver.h"
-
-#include "compiler/parser/parser_helpers.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
 
 #define SYMTAB( n ) driver.symtab.get( (off_t)n )
 #define SYMTAB_PUT( s ) driver.symtab.put( s )
 
=== modified file 'src/compiler/parser/symbol_table.cpp'
--- src/compiler/parser/symbol_table.cpp	2013-03-25 19:47:18 +0000
+++ src/compiler/parser/symbol_table.cpp	2013-05-08 15:05:31 +0000
@@ -15,6 +15,9 @@
  */
 #include "stdafx.h"
 
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 
 #include "compiler/parser/symbol_table.h"
 
=== modified file 'src/compiler/parser/xquery_parser.cpp'
--- src/compiler/parser/xquery_parser.cpp	2013-04-24 17:26:02 +0000
+++ src/compiler/parser/xquery_parser.cpp	2013-05-08 15:05:31 +0000
@@ -50,14 +50,13 @@
 #pragma warning(disable: 4786)
 #endif
 
+#include "compiler/api/compilercb.h"
+#include "compiler/parser/parse_constants.h"
+#include "compiler/parser/parser_helpers.h"
+#include "compiler/parser/xquery_driver.h"
 #include "compiler/parsetree/parsenodes.h"
-#include "compiler/parser/parse_constants.h"
-#include "compiler/api/compilercb.h"
 #include "store/api/update_consts.h"
-
-#include "compiler/parser/xquery_driver.h"
-
-#include "compiler/parser/parser_helpers.h"
+#include "zorbatypes/integer.h"
 
 #define SYMTAB( n ) driver.symtab.get( (off_t)n )
 #define SYMTAB_PUT( s ) driver.symtab.put( s )
 
=== modified file 'src/compiler/parsetree/parsenode_print_xml_visitor.cpp'
--- src/compiler/parsetree/parsenode_print_xml_visitor.cpp	2013-03-22 00:38:18 +0000
+++ src/compiler/parsetree/parsenode_print_xml_visitor.cpp	2013-05-08 15:05:31 +0000
@@ -16,9 +16,12 @@
 #include "stdafx.h"
 
 #include <ostream>
-#include "compiler/parsetree/parsenode_print_xml_visitor.h"
-#include "compiler/parsetree/parsenode_visitor.h"
+
 #include "types/typemanager.h"
+#include "zorbatypes/integer.h"
+
+#include "parsenode_print_xml_visitor.h"
+#include "parsenode_visitor.h"
 
 using namespace std;
 
 
=== modified file 'src/compiler/parsetree/parsenodes.cpp'
--- src/compiler/parsetree/parsenodes.cpp	2013-04-17 22:41:05 +0000
+++ src/compiler/parsetree/parsenodes.cpp	2013-05-08 15:05:31 +0000
@@ -29,6 +29,7 @@
 #include "compiler/parsetree/parsenodes.h"
 #include "compiler/parser/parse_constants.h"
 #include "compiler/parsetree/parsenode_visitor.h"
+#include "zorbatypes/integer.h"
 
 #include <iostream>
 #include <sstream>
 
=== modified file 'src/compiler/parsetree/parsenodes.h'
--- src/compiler/parsetree/parsenodes.h	2013-05-08 03:19:57 +0000
+++ src/compiler/parsetree/parsenodes.h	2013-05-08 15:05:31 +0000
@@ -32,6 +32,9 @@
 
 #include "store/api/item.h"
 
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/floatimpl.h"
 #include "zorbatypes/rchandle.h"
 #include "zorbatypes/schema_types.h"
 #include "zorbatypes/zstring.h"
 
=== modified file 'src/compiler/rewriter/rules/flwor_rules.cpp'
--- src/compiler/rewriter/rules/flwor_rules.cpp	2013-04-15 12:07:41 +0000
+++ src/compiler/rewriter/rules/flwor_rules.cpp	2013-05-08 15:05:31 +0000
@@ -37,6 +37,8 @@
 
 #include "system/properties.h"
 
+#include "zorbatypes/integer.h"
+
 #include <memory>
 #include <iterator>
 
@@ -300,7 +302,7 @@
           if (pvar != NULL)
           {
             expr* constExpr = rCtx.theEM->
-            create_const_expr(sctx, udf, loc, xs_integer::zero());
+            create_const_expr(sctx, udf, loc, numeric_consts<xs_integer>::zero());
 
             subst_vars(rCtx, pvar, constExpr, 2);
             fc->set_pos_var(NULL);
@@ -318,7 +320,7 @@
         if (pvar != NULL && (domQuant == TypeConstants::QUANT_ONE || ! outerFor))
         {
           expr* constExpr = rCtx.theEM->
-          create_const_expr(sctx, udf, loc, xs_integer::one());
+          create_const_expr(sctx, udf, loc, numeric_consts<xs_integer>::one());
 
           subst_vars(rCtx, pvar, constExpr, 2);
           fc->set_pos_var(NULL);
@@ -461,7 +463,7 @@
       // since one value is still returned, count variables are changed to 1
       subst_vars(rCtx,
                  static_cast<count_clause*>(clause)->get_var(),
-                 rCtx.theEM->create_const_expr(sctx, udf, loc, xs_integer::one()),
+                 rCtx.theEM->create_const_expr(sctx, udf, loc, numeric_consts<xs_integer>::one()),
                  2);
 
       theFlwor->remove_clause(0);
 
=== modified file 'src/compiler/rewriter/rules/fold_rules.cpp'
--- src/compiler/rewriter/rules/fold_rules.cpp	2013-05-04 20:20:05 +0000
+++ src/compiler/rewriter/rules/fold_rules.cpp	2013-05-08 15:05:31 +0000
@@ -47,6 +47,8 @@
 #include "store/api/store.h"
 #include "store/api/item_factory.h"
 
+#include "zorbatypes/integer.h"
+
 #include <iterator>
 
 namespace zorba {
 
=== modified file 'src/compiler/translator/translator.cpp'
--- src/compiler/translator/translator.cpp	2013-05-08 08:01:05 +0000
+++ src/compiler/translator/translator.cpp	2013-05-08 15:05:31 +0000
@@ -88,9 +88,12 @@
 #include "types/typemanagerimpl.h"
 #include "types/schema/schema.h"
 
+#include "zorbamisc/ns_consts.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/numconversions.h"
 #include "zorbatypes/URI.h"
-#include "zorbatypes/numconversions.h"
-#include "zorbamisc/ns_consts.h"
 
 #ifdef ZORBA_WITH_DEBUGGER
 #include "debugger/debugger_commons.h"
@@ -11932,8 +11935,8 @@
   }
   case FunctionConsts::FN_HEAD_1:
   {
-    arguments.push_back(CREATE(const)(theRootSctx, theUDF, loc, xs_integer::one()));
-    arguments.push_back(CREATE(const)(theRootSctx, theUDF, loc, xs_integer::one()));
+    arguments.push_back(CREATE(const)(theRootSctx, theUDF, loc, numeric_consts<xs_integer>::one()));
+    arguments.push_back(CREATE(const)(theRootSctx, theUDF, loc, numeric_consts<xs_integer>::one()));
 
     function* f = BUILTIN_FUNC(OP_ZORBA_SUBSEQUENCE_INT_3);
 
 
=== modified file 'src/functions/udf.cpp'
--- src/functions/udf.cpp	2013-04-24 01:35:58 +0000
+++ src/functions/udf.cpp	2013-05-08 15:05:31 +0000
@@ -36,6 +36,7 @@
 #include "diagnostics/assert.h"
 
 #include "types/typeops.h"
+#include "zorbatypes/integer.h"
 
 #include "zorbaserialization/serialize_template_types.h"
 #include "zorbaserialization/serialize_zorba_types.h"
 
=== modified file 'src/runtime/base/plan_iterator.cpp'
--- src/runtime/base/plan_iterator.cpp	2013-03-24 20:40:03 +0000
+++ src/runtime/base/plan_iterator.cpp	2013-05-08 15:05:31 +0000
@@ -15,18 +15,14 @@
  */
 #include "stdafx.h"
 
+#include "compiler/api/compilercb.h"
 #include "context/static_context.h"
-
-#include "compiler/api/compilercb.h"
-
 #include "runtime/base/plan_iterator.h"
-
 #include "runtime/util/flowctl_exception.h"
-
+#include "store/api/item_factory.h"
+#include "store/api/store.h"
 #include "system/globalenv.h"
-
-#include "store/api/store.h"
-#include "store/api/item_factory.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba
 
=== modified file 'src/runtime/booleans/BooleanImpl.cpp'
--- src/runtime/booleans/BooleanImpl.cpp	2013-05-02 00:18:56 +0000
+++ src/runtime/booleans/BooleanImpl.cpp	2013-05-08 15:05:31 +0000
@@ -20,6 +20,7 @@
 
 #include "zorbatypes/collation_manager.h"
 #include "zorbatypes/datetime.h"
+#include "zorbatypes/integer.h"
 
 #include "system/globalenv.h"
 
 
=== modified file 'src/runtime/collections/collections_base.h'
--- src/runtime/collections/collections_base.h	2013-02-07 17:24:36 +0000
+++ src/runtime/collections/collections_base.h	2013-05-08 15:05:31 +0000
@@ -31,6 +31,7 @@
 #include "types/typeimpl.h"
 
 #include "diagnostics/util_macros.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba {
 
=== modified file 'src/runtime/collections/collections_impl.cpp'
--- src/runtime/collections/collections_impl.cpp	2013-03-24 20:40:03 +0000
+++ src/runtime/collections/collections_impl.cpp	2013-05-08 15:05:31 +0000
@@ -307,9 +307,9 @@
     lSkip = lSkipItem->getIntegerValue(); 
 
     // negative skip is not allowed
-    if (lSkip < xs_integer::zero())
+    if (lSkip.sign() < 0)
     {
-      lSkip = xs_integer::zero();
+      lSkip = numeric_consts<xs_integer>::zero();
     }
 
     if (!lRefPassed)
@@ -381,11 +381,10 @@
     // skip parameter passed
     store::Item_t skipItem;
     consumeNext(skipItem, theChildren[1].getp(), planState);
-    xs_integer skip = skipItem->getIntegerValue(); 
-
-    count -= (skip <= xs_integer::zero() ? xs_integer::zero() : skip);
-
-    count = (count < xs_integer::zero() ? xs_integer::zero() : count);
+    xs_integer skip( skipItem->getIntegerValue() );
+
+    count -= (skip.sign() <= 0 ? numeric_consts<xs_integer>::zero() : skip);
+    count = (count.sign() < 0 ? numeric_consts<xs_integer>::zero() : count);
   }
 
   STACK_PUSH(GENV_ITEMFACTORY->createInteger(result, count), state);
 
=== modified file 'src/runtime/core/arithmetic_impl.cpp'
--- src/runtime/core/arithmetic_impl.cpp	2013-04-08 21:32:54 +0000
+++ src/runtime/core/arithmetic_impl.cpp	2013-05-08 15:05:31 +0000
@@ -21,6 +21,7 @@
 #include "diagnostics/util_macros.h"
 
 #include "zorbatypes/datetime.h"
+#include "zorbatypes/decimal.h"
 #include "zorbatypes/duration.h"
 
 #include "system/globalenv.h"
 
=== modified file 'src/runtime/core/var_iterators.h'
--- src/runtime/core/var_iterators.h	2013-05-08 08:01:05 +0000
+++ src/runtime/core/var_iterators.h	2013-05-08 15:05:31 +0000
@@ -23,7 +23,7 @@
 #include "runtime/base/unarybase.h"
 #include "runtime/base/narybase.h"
 
-#include "zorbatypes/schema_types.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba
 
=== modified file 'src/runtime/durations_dates_times/durations_dates_times_impl.cpp'
--- src/runtime/durations_dates_times/durations_dates_times_impl.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/durations_dates_times/durations_dates_times_impl.cpp	2013-05-08 15:05:31 +0000
@@ -17,6 +17,8 @@
 
 #include "zorbatypes/datetime.h"
 #include "zorbatypes/duration.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 #include "zorbatypes/datetime/parse.h"
 
 
=== modified file 'src/runtime/full_text/ft_module_impl.cpp'
--- src/runtime/full_text/ft_module_impl.cpp	2013-04-16 22:12:03 +0000
+++ src/runtime/full_text/ft_module_impl.cpp	2013-05-08 15:05:31 +0000
@@ -46,6 +46,7 @@
 #include "types/typeops.h"
 #include "util/stl_util.h"
 #include "util/utf8_util.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/URI.h"
 #include "zorbautils/locale.h"
 
 
=== modified file 'src/runtime/full_text/ft_util.cpp'
--- src/runtime/full_text/ft_util.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ft_util.cpp	2013-05-08 15:05:31 +0000
@@ -20,6 +20,7 @@
 
 #include "diagnostics/xquery_diagnostics.h"
 #include "zorbamisc/ns_consts.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 #include "zorbautils/locale.h"
 
 
=== modified file 'src/runtime/full_text/ftcontains_visitor.cpp'
--- src/runtime/full_text/ftcontains_visitor.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/full_text/ftcontains_visitor.cpp	2013-05-08 15:05:31 +0000
@@ -24,12 +24,11 @@
 #include "compiler/parser/query_loc.h"
 #include "diagnostics/xquery_diagnostics.h"
 #include "store/api/store.h"
-
 #include "system/globalenv.h"
-
 #include "util/cxx_util.h"
 #include "util/indent.h"
 #include "util/stl_util.h"
+#include "zorbatypes/integer.h"
 
 #ifndef NDEBUG
 #include "system/properties.h"
 
=== modified file 'src/runtime/hof/dynamic_fncall_iterator.cpp'
--- src/runtime/hof/dynamic_fncall_iterator.cpp	2013-05-05 04:49:50 +0000
+++ src/runtime/hof/dynamic_fncall_iterator.cpp	2013-05-08 15:05:31 +0000
@@ -34,6 +34,7 @@
 #include "types/root_typemanager.h"
 #include "types/casting.h"
 #include "types/typeops.h"
+#include "zorbatypes/integer.h"
 
 #include "system/globalenv.h"
 
 
=== modified file 'src/runtime/hof/fn_hof_functions_impl.cpp'
--- src/runtime/hof/fn_hof_functions_impl.cpp	2013-04-24 01:35:58 +0000
+++ src/runtime/hof/fn_hof_functions_impl.cpp	2013-05-08 15:05:31 +0000
@@ -42,6 +42,7 @@
 #include "system/globalenv.h"
 
 #include "zorbamisc/ns_consts.h"
+#include "zorbatypes/integer.h"
 
 
 #include "compiler/expression/expr_manager.h"
 
=== modified file 'src/runtime/indexing/index_ddl.cpp'
--- src/runtime/indexing/index_ddl.cpp	2013-03-24 20:40:03 +0000
+++ src/runtime/indexing/index_ddl.cpp	2013-05-08 15:05:31 +0000
@@ -34,6 +34,8 @@
 #include "types/typeimpl.h"
 #include "types/typeops.h"
 #include "types/casting.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
 
 #include "context/static_context.h"
 #include "context/dynamic_context.h"
@@ -623,7 +625,7 @@
     PlanState& planState) const
 {
   store::IndexCondition_t cond;
-  xs_integer skip = xs_integer::zero();
+  xs_integer skip( numeric_consts<xs_integer>::zero() );
 
   try
   {
@@ -641,8 +643,8 @@
         store::Item_t skipItem;
         ZORBA_ASSERT(consumeNext(skipItem, theChildren[1], planState));
         skip = skipItem->getIntegerValue();
-        if (skip < xs_integer::zero())
-          skip = xs_integer::zero();
+        if (skip.sign() < 0)
+          skip = numeric_consts<xs_integer>::zero();
       }
 
       state->theIterator->init(cond, skip);
@@ -687,8 +689,8 @@
         store::Item_t skipItem;
         ZORBA_ASSERT(consumeNext(skipItem, theChildren[1], planState));
         skip = skipItem->getIntegerValue();
-        if (skip < xs_integer::zero())
-          skip = xs_integer::zero();
+        if (skip.sign() < 0)
+          skip = numeric_consts<xs_integer>::zero();
       }
 
       state->theIterator->init(cond, skip);
@@ -1071,7 +1073,7 @@
     PlanState& planState) const
 {
   store::IndexCondition_t cond;
-  xs_integer skip = xs_integer::zero();
+  xs_integer skip( numeric_consts<xs_integer>::zero() );
 
   try
   {
@@ -1087,8 +1089,8 @@
       store::Item_t skipItem;
       ZORBA_ASSERT(consumeNext(skipItem, theChildren[1], planState));
       skip = skipItem->getIntegerValue();
-      if (skip < xs_integer::zero())
-        skip = xs_integer::zero();
+      if (skip.sign() < 0)
+        skip = numeric_consts<xs_integer>::zero();
     }
 
     state->theIterator->init(cond, skip);
@@ -1114,7 +1116,7 @@
     PlanState& planState) const
 {
   store::IndexCondition_t cond;
-  xs_integer skip = xs_integer::zero();
+  xs_integer skip( numeric_consts<xs_integer>::zero() );
 
   try
   {
@@ -1130,8 +1132,8 @@
       store::Item_t skipItem;
       ZORBA_ASSERT(consumeNext(skipItem, theChildren[1], planState));
       skip = skipItem->getIntegerValue();
-      if (skip < xs_integer::zero())
-        skip = xs_integer::zero();
+      if (skip.sign() < 0)
+        skip = numeric_consts<xs_integer>::zero();
     }
 
     state->theIterator->init(cond, skip);
 
=== modified file 'src/runtime/introspection/sctx_impl.cpp'
--- src/runtime/introspection/sctx_impl.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/introspection/sctx_impl.cpp	2013-05-08 15:05:31 +0000
@@ -19,6 +19,7 @@
 
 #include "diagnostics/assert.h"
 #include "diagnostics/xquery_diagnostics.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 
 #include "system/globalenv.h"
 
=== modified file 'src/runtime/item/item_impl.cpp'
--- src/runtime/item/item_impl.cpp	2012-07-17 18:47:54 +0000
+++ src/runtime/item/item_impl.cpp	2013-05-08 15:05:31 +0000
@@ -25,6 +25,7 @@
 #include "store/api/store.h"
 
 #include "util/mem_sizeof.h"
+#include "zorbatypes/integer.h"
 
 using namespace std;
 
 
=== modified file 'src/runtime/json/jsoniq_functions_impl.cpp'
--- src/runtime/json/jsoniq_functions_impl.cpp	2013-05-05 04:49:50 +0000
+++ src/runtime/json/jsoniq_functions_impl.cpp	2013-05-08 15:05:31 +0000
@@ -46,6 +46,7 @@
 #include "types/typeimpl.h"
 #include "types/typeops.h"
 #include "types/root_typemanager.h"
+#include "zorbatypes/integer.h"
 
 #include <runtime/util/doc_uri_heuristics.h>
 
 
=== modified file 'src/runtime/maths/pregenerated/maths.cpp'
--- src/runtime/maths/pregenerated/maths.cpp	2013-03-05 23:11:50 +0000
+++ src/runtime/maths/pregenerated/maths.cpp	2013-05-08 15:05:31 +0000
@@ -640,12 +640,12 @@
 
 void ModfIteratorState::init(PlanState& planState) {
   PlanIteratorState::init(planState);
-  theDoubInteger = xs_double::zero();
+  theDoubInteger = numeric_consts<xs_double>::zero();
 }
 
 void ModfIteratorState::reset(PlanState& planState) {
   PlanIteratorState::reset(planState);
-  theDoubInteger = xs_double::zero();
+  theDoubInteger = numeric_consts<xs_double>::zero();
 }
 // </ModfIterator>
 
@@ -678,12 +678,12 @@
 
 void FrexpIteratorState::init(PlanState& planState) {
   PlanIteratorState::init(planState);
-  theIntExponent = xs_integer::zero();
+  theIntExponent = numeric_consts<xs_integer>::zero();
 }
 
 void FrexpIteratorState::reset(PlanState& planState) {
   PlanIteratorState::reset(planState);
-  theIntExponent = xs_integer::zero();
+  theIntExponent = numeric_consts<xs_integer>::zero();
 }
 // </FrexpIterator>
 
 
=== modified file 'src/runtime/maths/pregenerated/maths.h'
--- src/runtime/maths/pregenerated/maths.h	2013-03-05 23:11:50 +0000
+++ src/runtime/maths/pregenerated/maths.h	2013-05-08 15:05:31 +0000
@@ -29,6 +29,7 @@
 #include "runtime/base/binarybase.h"
 #include "runtime/base/noarybase.h"
 
+#include "zorbatypes/integer.h"
 #include "zorbatypes/schema_types.h"
 
 
 
=== modified file 'src/runtime/numerics/NumericsImpl.cpp'
--- src/runtime/numerics/NumericsImpl.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/numerics/NumericsImpl.cpp	2013-05-08 15:05:31 +0000
@@ -20,6 +20,8 @@
 #include "diagnostics/assert.h"
 #include "diagnostics/util_macros.h"
 #include "diagnostics/xquery_diagnostics.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/zorbatypes_decl.h"
 
 #include "system/globalenv.h"
@@ -393,7 +395,7 @@
 {
   xs_decimal ld0 = i0->getDecimalValue();
   xs_decimal ld1 = i1->getDecimalValue();
-  if ( ld1 == Integer::zero() )
+  if ( ld1.sign() == 0 )
   {
     throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
   }
@@ -412,7 +414,7 @@
 {
   xs_decimal const ll0(i0->getIntegerValue());
   xs_decimal const ll1(i1->getIntegerValue());
-  if ( ll1 == Integer::zero() )
+  if ( ll1.sign() == 0 )
   {
     throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
   }
@@ -435,7 +437,7 @@
   xs_double d0 = i0->getDoubleValue();
   xs_double d1 = i1->getDoubleValue();
 
-  if ( d1 == xs_double::zero() )
+  if ( d1 == numeric_consts<xs_double>::zero() )
   {
     throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
   }
@@ -455,7 +457,7 @@
 
   if (i0->isPosOrNegInf()) {
     // idiv with +-INF divisor has 0 as result
-    return GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    return GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
   }
 
   xs_integer const lInteger( d0 / d1 );
@@ -474,7 +476,7 @@
 {
   xs_float f0 = i0->getFloatValue();
   xs_float f1 = i1->getFloatValue();
-  if ( f1 == xs_float::zero() )
+  if ( f1 == numeric_consts<xs_float>::zero() )
   {
     throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
   }
@@ -494,7 +496,7 @@
   if (i0->isPosOrNegInf()) 
   {
     // idiv with +-INF divisor has 0 as result
-    return GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    return GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
   }
 
   xs_integer const lInteger( f0 / f1 );
@@ -606,7 +608,7 @@
   xs_integer ll0 = i0->getIntegerValue();
   xs_integer ll1 = i1->getIntegerValue();
 
-  if (ll1 == Integer::zero())
+  if ( ll1.sign() == 0 )
   {
     throw XQUERY_EXCEPTION(err::FOAR0001, ERROR_LOC(loc));
   }
 
=== modified file 'src/runtime/numerics/format_integer.cpp'
--- src/runtime/numerics/format_integer.cpp	2013-05-04 20:27:31 +0000
+++ src/runtime/numerics/format_integer.cpp	2013-05-08 15:05:31 +0000
@@ -34,6 +34,7 @@
 #include "util/stream_util.h"
 #include "util/unicode_util.h"
 #include "util/utf8_string.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 
 using namespace std;
 
=== modified file 'src/runtime/numerics/format_number.cpp'
--- src/runtime/numerics/format_number.cpp	2013-05-03 23:19:41 +0000
+++ src/runtime/numerics/format_number.cpp	2013-05-08 15:05:31 +0000
@@ -31,7 +31,8 @@
 #include "types/typeconstants.h"
 #include "types/typeops.h"
 #include "util/xml_util.h"
-#include "zorbatypes/zorbatypes_decl.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
 
 namespace zorba {
 
@@ -258,7 +259,7 @@
   );
 
   store::Item_t zero;
-  GENV_ITEMFACTORY->createDouble( zero, xs_double::zero() );
+  GENV_ITEMFACTORY->createDouble( zero, numeric_consts<xs_double>::zero() );
 
   //
   // Ibid: [T]he positive sub-picture and its associated variables are used if
 
=== modified file 'src/runtime/numerics/numerics_impl.cpp'
--- src/runtime/numerics/numerics_impl.cpp	2013-04-11 17:37:16 +0000
+++ src/runtime/numerics/numerics_impl.cpp	2013-05-08 15:05:31 +0000
@@ -22,6 +22,8 @@
 #include "diagnostics/assert.h"
 #include "diagnostics/util_macros.h"
 #include "diagnostics/xquery_diagnostics.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/zorbatypes_decl.h"
 
 #include "system/globalenv.h"
@@ -97,7 +99,7 @@
     }
     else if (TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
     {
-      if (result->getIntegerValue() >= xs_decimal::zero())
+      if (result->getIntegerValue().sign() >= 0)
       {
         if ( !TypeOps::is_equal(tm, *type, *rtm.INTEGER_TYPE_ONE))
           GENV_ITEMFACTORY->createInteger(result, result->getIntegerValue());
@@ -109,7 +111,7 @@
     }
     else if (TypeOps::is_subtype(tm, *type, *rtm.DECIMAL_TYPE_ONE))
     {
-      if ( result->getDecimalValue() >= xs_decimal::zero())
+      if ( result->getDecimalValue().sign() >= 0)
       {
         if ( !TypeOps::is_equal(tm, *type, *rtm.DECIMAL_TYPE_ONE))
           GENV_ITEMFACTORY->createDecimal(result, result->getDecimalValue());
@@ -301,7 +303,7 @@
     //item type is subtype of INTEGER
     else if(TypeOps::is_subtype(tm, *type, *rtm.INTEGER_TYPE_ONE))
     {
-      if(precision_integer < Integer::zero())
+      if(precision_integer.sign() < 0)
         GENV_ITEMFACTORY->createInteger(result, result->getIntegerValue().round(precision_integer));
     }
 
 
=== modified file 'src/runtime/random/pregenerated/random.h'
--- src/runtime/random/pregenerated/random.h	2013-03-05 23:11:50 +0000
+++ src/runtime/random/pregenerated/random.h	2013-05-08 15:05:31 +0000
@@ -29,6 +29,7 @@
 
 
 #include "runtime/base/narybase.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba {
 
=== modified file 'src/runtime/sequences/pregenerated/sequences.cpp'
--- src/runtime/sequences/pregenerated/sequences.cpp	2013-04-15 20:57:28 +0000
+++ src/runtime/sequences/pregenerated/sequences.cpp	2013-05-08 15:05:31 +0000
@@ -238,15 +238,15 @@
 
 void FnInsertBeforeIteratorState::init(PlanState& planState) {
   PlanIteratorState::init(planState);
-  theCurrentPos = xs_integer::zero();
-  thePosition = xs_integer::zero();
+  theCurrentPos = numeric_consts<xs_integer>::zero();
+  thePosition = numeric_consts<xs_integer>::zero();
   theTargetItem = NULL;
 }
 
 void FnInsertBeforeIteratorState::reset(PlanState& planState) {
   PlanIteratorState::reset(planState);
-  theCurrentPos = xs_integer::zero();
-  thePosition = xs_integer::zero();
+  theCurrentPos = numeric_consts<xs_integer>::zero();
+  thePosition = numeric_consts<xs_integer>::zero();
   theTargetItem = NULL;
 }
 // </FnInsertBeforeIterator>
@@ -284,15 +284,15 @@
 
 void FnRemoveIteratorState::init(PlanState& planState) {
   PlanIteratorState::init(planState);
-  theCurrentPos = xs_integer::zero();
-  thePosition = xs_integer::zero();
+  theCurrentPos = numeric_consts<xs_integer>::zero();
+  thePosition = numeric_consts<xs_integer>::zero();
   theCollator = 0;
 }
 
 void FnRemoveIteratorState::reset(PlanState& planState) {
   PlanIteratorState::reset(planState);
-  theCurrentPos = xs_integer::zero();
-  thePosition = xs_integer::zero();
+  theCurrentPos = numeric_consts<xs_integer>::zero();
+  thePosition = numeric_consts<xs_integer>::zero();
   theCollator = 0;
 }
 // </FnRemoveIterator>
@@ -863,16 +863,16 @@
 
 void OpToIteratorState::init(PlanState& planState) {
   PlanIteratorState::init(planState);
-  theCurInt = xs_integer::zero();
-  theFirstVal = xs_integer::zero();
-  theLastVal = xs_integer::zero();
+  theCurInt = numeric_consts<xs_integer>::zero();
+  theFirstVal = numeric_consts<xs_integer>::zero();
+  theLastVal = numeric_consts<xs_integer>::zero();
 }
 
 void OpToIteratorState::reset(PlanState& planState) {
   PlanIteratorState::reset(planState);
-  theCurInt = xs_integer::zero();
-  theFirstVal = xs_integer::zero();
-  theLastVal = xs_integer::zero();
+  theCurInt = numeric_consts<xs_integer>::zero();
+  theFirstVal = numeric_consts<xs_integer>::zero();
+  theLastVal = numeric_consts<xs_integer>::zero();
 }
 // </OpToIterator>
 
 
=== modified file 'src/runtime/sequences/pregenerated/sequences.h'
--- src/runtime/sequences/pregenerated/sequences.h	2013-04-15 20:57:28 +0000
+++ src/runtime/sequences/pregenerated/sequences.h	2013-05-08 15:05:31 +0000
@@ -31,6 +31,7 @@
 #include "runtime/base/narybase.h"
 #include "runtime/base/narybase.h"
 #include "runtime/core/path_iterators.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba {
 
=== modified file 'src/runtime/sequences/sequences_impl.cpp'
--- src/runtime/sequences/sequences_impl.cpp	2013-05-01 23:06:33 +0000
+++ src/runtime/sequences/sequences_impl.cpp	2013-05-08 15:05:31 +0000
@@ -20,12 +20,13 @@
 #include <vector>
 #include <sstream>
 
-#include <zorbautils/fatal.h>
 #include "diagnostics/xquery_diagnostics.h"
 #include "diagnostics/util_macros.h"
 
-#include <zorbatypes/URI.h>
-#include <zorbamisc/ns_consts.h>
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/URI.h"
+#include "zorbamisc/ns_consts.h"
+#include "zorbautils/fatal.h"
 
 // For timing
 #include <zorba/util/time.h>
@@ -1599,7 +1600,10 @@
     else
     {
       STACK_PUSH(
-				GENV_ITEMFACTORY->createInteger( result, Integer::zero() ), state
+				GENV_ITEMFACTORY->createInteger(
+          result, numeric_consts<xs_integer>::zero()
+        ),
+        state
 			);
     }
   }
@@ -1648,7 +1652,7 @@
   }
   else
   {
-    GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
     STACK_PUSH(true, state);
   }
 
@@ -1697,7 +1701,7 @@
   }
   else
   {
-    GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
     STACK_PUSH(true, state);
   }
 
@@ -1745,7 +1749,7 @@
   }
   else
   {
-    GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
     STACK_PUSH(true, state);
   }
 
@@ -1803,7 +1807,7 @@
   }
   else
   {
-    GENV_ITEMFACTORY->createInteger(result, Integer::zero());
+    GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
     STACK_PUSH(true, state);
   }
 
 
=== modified file 'src/runtime/spec/maths/maths.xml'
--- src/runtime/spec/maths/maths.xml	2013-02-07 17:24:36 +0000
+++ src/runtime/spec/maths/maths.xml	2013-05-08 15:05:31 +0000
@@ -6,6 +6,7 @@
   xsi:schemaLocation="http://www.zorba-xquery.com ../runtime.xsd">
 
 <zorba:header>
+    <zorba:include form="Quoted">zorbatypes/integer.h</zorba:include>
     <zorba:include form="Quoted">zorbatypes/schema_types.h</zorba:include>
 </zorba:header>
     
@@ -462,7 +463,7 @@
   </zorba:function>
 
   <zorba:state generateInit="true" generateReset="true">
-    <zorba:member type="xs_double" name="theDoubInteger" defaultValue="xs_double::zero()"
+    <zorba:member type="xs_double" name="theDoubInteger" defaultValue="numeric_consts&lt;xs_double&gt;::zero()"
                   brief=""/>
   </zorba:state>
     
@@ -485,7 +486,7 @@
   </zorba:function>
 
   <zorba:state generateInit="true" generateReset="true">
-    <zorba:member type="xs_integer" name="theIntExponent" defaultValue="xs_integer::zero()"
+    <zorba:member type="xs_integer" name="theIntExponent" defaultValue="numeric_consts&lt;xs_integer&gt;::zero()"
                   brief=""/>
   </zorba:state>
     
 
=== modified file 'src/runtime/spec/random/random.xml'
--- src/runtime/spec/random/random.xml	2013-02-07 17:24:36 +0000
+++ src/runtime/spec/random/random.xml	2013-05-08 15:05:31 +0000
@@ -12,6 +12,10 @@
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.zorba-xquery.com ../runtime.xsd">
 
+<zorba:header>
+  <zorba:include form="Quoted">zorbatypes/integer.h</zorba:include>
+</zorba:header>
+
 <!--
 /*******************************************************************************
 ********************************************************************************/
 
=== modified file 'src/runtime/spec/sequences/sequences.xml'
--- src/runtime/spec/sequences/sequences.xml	2013-04-15 20:57:28 +0000
+++ src/runtime/spec/sequences/sequences.xml	2013-05-08 15:05:31 +0000
@@ -15,6 +15,7 @@
 <zorba:header>
     <zorba:include form="Quoted">runtime/base/narybase.h</zorba:include>
     <zorba:include form="Quoted">runtime/core/path_iterators.h</zorba:include>
+    <zorba:include form="Quoted">zorbatypes/integer.h</zorba:include>
     <zorba:fwd-decl ns="zorba">NodeHandleHashSet</zorba:fwd-decl>
     <zorba:fwd-decl ns="zorba">AtomicItemHandleHashSet</zorba:fwd-decl>
 </zorba:header>
@@ -283,10 +284,10 @@
 
   <zorba:state>
     <zorba:member type="xs_integer" name="theCurrentPos"
-                  defaultValue="xs_integer::zero()" brief="the current position in the sequence"/>
+                  defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief="the current position in the sequence"/>
 
     <zorba:member type="xs_integer" name="thePosition"
-                  defaultValue="xs_integer::zero()" brief=""/>
+                  defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief=""/>
 
     <zorba:member type="store::Item_t" name="theTargetItem"
                   defaultValue="NULL" brief=""/>
@@ -328,10 +329,10 @@
 
   <zorba:state>
     <zorba:member type="xs_integer" name="theCurrentPos"
-                  defaultValue="xs_integer::zero()" brief="the current position in the sequence"/>
+                  defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief="the current position in the sequence"/>
 
     <zorba:member type="xs_integer" name="thePosition"
-                  defaultValue="xs_integer::zero()" brief="the position to delete"/>
+                  defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief="the position to delete"/>
 
     <zorba:member type="XQPCollator*" name="theCollator"
                   defaultValue="0" brief="the collator"/>
@@ -952,12 +953,12 @@
 
   <zorba:state>
     <zorba:member type="xs_integer" name="theCurInt"
-                  defaultValue="xs_integer::zero()" brief="the current integer"/>
+                  defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief="the current integer"/>
 
      <zorba:member type="xs_integer" name="theFirstVal"
-                   defaultValue="xs_integer::zero()" brief="first integer"/>
+                   defaultValue="numeric_consts&lt;xs_integer&gt;::zero()" brief="first integer"/>
 
-     <zorba:member type="xs_integer" name="theLastVal" defaultValue="xs_integer::zero()"
+     <zorba:member type="xs_integer" name="theLastVal" defaultValue="numeric_consts&lt;xs_integer&gt;::zero()"
                    brief="last integer"/>
   </zorba:state>
 
 
=== modified file 'src/runtime/store/maps_impl.cpp'
--- src/runtime/store/maps_impl.cpp	2013-03-05 12:34:19 +0000
+++ src/runtime/store/maps_impl.cpp	2013-05-08 15:05:31 +0000
@@ -19,6 +19,7 @@
 #include "diagnostics/util_macros.h"
 #include "diagnostics/xquery_diagnostics.h"
 
+#include "zorbatypes/integer.h"
 #include "zorbatypes/URI.h"
 
 #include "system/globalenv.h"
 
=== modified file 'src/runtime/strings/strings_impl.cpp'
--- src/runtime/strings/strings_impl.cpp	2013-05-04 20:20:05 +0000
+++ src/runtime/strings/strings_impl.cpp	2013-05-08 15:05:31 +0000
@@ -25,6 +25,7 @@
 #include "diagnostics/xquery_diagnostics.h"
 #include "diagnostics/util_macros.h"
 
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
 
 #include "system/globalenv.h"
@@ -734,8 +735,12 @@
   }
   else
   {
-    STACK_PUSH(GENV_ITEMFACTORY->createInteger(result, xs_integer::zero()),
-               state);
+    STACK_PUSH(
+      GENV_ITEMFACTORY->createInteger(
+        result, numeric_consts<xs_integer>::zero()
+      ),
+      state
+    );
   }
   STACK_END(state);
 }
 
=== modified file 'src/store/api/collection.h'
--- src/store/api/collection.h	2013-02-07 17:24:36 +0000
+++ src/store/api/collection.h	2013-05-08 15:05:31 +0000
@@ -59,7 +59,7 @@
    * @return Iterator
    */
   virtual Iterator_t getIterator(
-      const xs_integer& aSkip = xs_integer::zero(),
+      const xs_integer& aSkip = numeric_consts<xs_integer>::zero(),
       const zstring& aStart = "") = 0;
 
   /**
 
=== modified file 'src/store/api/iterator.h'
--- src/store/api/iterator.h	2013-03-05 00:45:43 +0000
+++ src/store/api/iterator.h	2013-05-08 15:05:31 +0000
@@ -177,7 +177,7 @@
   virtual ~IndexProbeIterator() { }
 
   virtual void init(const IndexCondition_t& cond,
-                    const xs_integer& aSkip = xs_integer::zero()) = 0;
+                    const xs_integer& aSkip = numeric_consts<xs_integer>::zero()) = 0;
 
   virtual void open() = 0;
   
 
=== modified file 'src/store/naive/atomic_items.cpp'
--- src/store/naive/atomic_items.cpp	2013-04-16 21:12:12 +0000
+++ src/store/naive/atomic_items.cpp	2013-05-08 15:05:31 +0000
@@ -2691,7 +2691,7 @@
 
 bool DecimalItem::getEBV() const
 {
-  return ( theValue != xs_decimal::zero() );
+  return !!theValue.sign();
 }
 
 
 
=== modified file 'src/store/naive/atomic_items.h'
--- src/store/naive/atomic_items.h	2013-04-08 08:45:18 +0000
+++ src/store/naive/atomic_items.h	2013-05-08 15:05:31 +0000
@@ -38,8 +38,11 @@
 #include "naive_ft_token_iterator.h"
 #endif /* ZORBA_NO_FULL_TEXT */
 
+#include "zorbatypes/datetime.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/schema_types.h"
-#include "zorbatypes/datetime.h"
 
 #include "diagnostics/xquery_diagnostics.h"
 #include "ordpath.h"
 
=== modified file 'src/store/naive/collection.h'
--- src/store/naive/collection.h	2013-02-26 04:12:43 +0000
+++ src/store/naive/collection.h	2013-05-08 15:05:31 +0000
@@ -17,6 +17,7 @@
 #define ZORBA_SIMPLESTORE_COLLECTION
 
 #include "store/api/collection.h"
+#include "zorbatypes/integer.h"
 
 #include "shared_types.h"
 #include "tree_id.h"
 
=== modified file 'src/store/naive/collection_tree_info.h'
--- src/store/naive/collection_tree_info.h	2013-02-06 18:52:32 +0000
+++ src/store/naive/collection_tree_info.h	2013-05-08 15:05:31 +0000
@@ -18,6 +18,7 @@
 #define ZORBA_STORE_COLLECTION_TREE_INFO_H
 
 #include <zorba/config.h>
+#include "zorbatypes/integer.h"
 
 namespace zorba
 {
 
=== modified file 'src/store/naive/pul_primitives.cpp'
--- src/store/naive/pul_primitives.cpp	2013-02-26 04:12:43 +0000
+++ src/store/naive/pul_primitives.cpp	2013-05-08 15:05:31 +0000
@@ -1147,7 +1147,7 @@
 
   assert(lColl);
 
-  xs_integer const zero( xs_integer::zero() );
+  xs_integer const zero( numeric_consts<xs_integer>::zero() );
   for (std::size_t i = 0; i < theNumApplied; ++i)
   {
     ZORBA_ASSERT(theNodes[i] == lColl->nodeAt(zero));
 
=== modified file 'src/store/naive/simple_collection.cpp'
--- src/store/naive/simple_collection.cpp	2013-04-16 21:12:12 +0000
+++ src/store/naive/simple_collection.cpp	2013-05-08 15:05:31 +0000
@@ -93,7 +93,7 @@
     const zstring& startRef)
 {
   store::Item_t startNode;
-  xs_integer startPos = xs_integer::zero();
+  xs_integer startPos;
 
   if (startRef.size() != 0 &&
       (!GET_STORE().getNodeByReference(startNode, startRef) ||
@@ -511,7 +511,7 @@
 
   if (num == 0 || pos >= theTrees.size())
   {
-    return xs_integer::zero();
+    return numeric_consts<xs_integer>::zero();
   }
   else
   {
 
=== modified file 'src/store/naive/simple_index_value.h'
--- src/store/naive/simple_index_value.h	2013-02-07 17:24:36 +0000
+++ src/store/naive/simple_index_value.h	2013-05-08 15:05:31 +0000
@@ -17,6 +17,7 @@
 #define ZORBA_SIMPLE_STORE_INDEX_HASH_VALUE
 
 #include "simple_index.h"
+#include "zorbatypes/integer.h"
 #include <map>
 
 namespace zorba
 
=== modified file 'src/store/naive/simple_lazy_temp_seq.cpp'
--- src/store/naive/simple_lazy_temp_seq.cpp	2013-04-16 21:12:12 +0000
+++ src/store/naive/simple_lazy_temp_seq.cpp	2013-05-08 15:05:31 +0000
@@ -21,9 +21,9 @@
 #include "diagnostics/dict.h"
 #include "diagnostics/util_macros.h"
 #include "diagnostics/xquery_exception.h"
-
+#include "simple_lazy_temp_seq.h"
 #include "store/api/item.h"
-#include "simple_lazy_temp_seq.h"
+#include "zorbatypes/integer.h"
 
 
 namespace zorba
 
=== modified file 'src/store/naive/simple_pul.cpp'
--- src/store/naive/simple_pul.cpp	2013-04-17 18:37:33 +0000
+++ src/store/naive/simple_pul.cpp	2013-05-08 15:05:31 +0000
@@ -1419,8 +1419,7 @@
 
   xs_integer pos = position->getIntegerValue();
 
-  if (pos <= xs_integer::zero() ||
-      arr->getArraySize() + 1 < pos)
+  if (pos.sign() <= 0 || arr->getArraySize() + 1 < pos)
   {
     RAISE_ERROR(jerr::JNUP0016, loc,
     ERROR_PARAMS(ZED(JNUP0016_Array), position->getStringValue()));
@@ -1557,8 +1556,7 @@
 
   xs_integer pos = position->getIntegerValue();
 
-  if (pos <= xs_integer::zero() ||
-      arr->getArraySize() < pos)
+  if (pos.sign() <= 0 || arr->getArraySize() < pos)
   {
     RAISE_ERROR(jerr::JNUP0016, loc,
     ERROR_PARAMS(ZED(JNUP0016_Array), position->getStringValue()));
@@ -1623,8 +1621,7 @@
 
   xs_integer pos = position->getIntegerValue();
 
-  if (pos <= xs_integer::zero() ||
-      arr->getArraySize() < pos)
+  if (pos.sign() <= 0 || arr->getArraySize() < pos)
   {
     RAISE_ERROR(jerr::JNUP0016, loc,
     ERROR_PARAMS(ZED(JNUP0016_Array), position->getStringValue()));
 
=== modified file 'src/store/naive/simple_temp_seq.cpp'
--- src/store/naive/simple_temp_seq.cpp	2013-04-17 18:37:33 +0000
+++ src/store/naive/simple_temp_seq.cpp	2013-05-08 15:05:31 +0000
@@ -24,6 +24,7 @@
 #include "store/api/item.h"
 #include "simple_temp_seq.h"
 #include "store/api/copymode.h"
+#include "zorbatypes/integer.h"
 
 namespace zorba { namespace simplestore {
 
 
=== modified file 'src/system/globalenv.cpp'
--- src/system/globalenv.cpp	2013-02-07 17:24:36 +0000
+++ src/system/globalenv.cpp	2013-05-08 15:05:31 +0000
@@ -42,6 +42,7 @@
 
 #include "types/schema/schema.h"
 
+#include "zorbatypes/m_apm.h"
 #include "zorbautils/condition.h"
 
 #include "store/api/collection.h"
 
=== modified file 'src/types/casting.cpp'
--- src/types/casting.cpp	2013-05-02 00:18:56 +0000
+++ src/types/casting.cpp	2013-05-08 15:05:31 +0000
@@ -17,10 +17,13 @@
 
 #include <vector>
 
-#include "zorbatypes/numconversions.h"
+#include "zorbatypes/chartype.h"
 #include "zorbatypes/datetime.h"
+#include "zorbatypes/decimal.h"
 #include "zorbatypes/duration.h"
-#include "zorbatypes/chartype.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/numconversions.h"
 #include "zorbatypes/URI.h"
 
 #include "diagnostics/xquery_diagnostics.h"
@@ -1433,36 +1436,36 @@
 T1_TO_T2(bool, flt)
 {
   if (aItem->getBooleanValue())
-    aFactory->createFloat(result, xs_float::one());
+    aFactory->createFloat(result, numeric_consts<xs_float>::one());
   else
-    aFactory->createFloat(result, xs_float::zero());
+    aFactory->createFloat(result, numeric_consts<xs_float>::zero());
 }
 
 
 T1_TO_T2(bool, dbl)
 {
   if (aItem->getBooleanValue())
-    aFactory->createDouble(result, xs_double::one());
+    aFactory->createDouble(result, numeric_consts<xs_double>::one());
   else
-    aFactory->createDouble(result, xs_double::zero());
+    aFactory->createDouble(result, numeric_consts<xs_double>::zero());
 }
 
 
 T1_TO_T2(bool, dec)
 {
   if (aItem->getBooleanValue())
-    aFactory->createDecimal(result, xs_decimal::one());
+    aFactory->createDecimal(result, numeric_consts<xs_decimal>::one());
   else
-    aFactory->createDecimal(result, xs_decimal::zero());
+    aFactory->createDecimal(result, numeric_consts<xs_decimal>::zero());
 }
 
 
 T1_TO_T2(bool, int)
 {
   if (aItem->getBooleanValue())
-    aFactory->createInteger(result, xs_integer::one());
+    aFactory->createInteger(result, numeric_consts<xs_integer>::one());
   else
-    aFactory->createInteger(result, xs_integer::zero());
+    aFactory->createInteger(result, numeric_consts<xs_integer>::zero());
 }
 
 
@@ -1666,17 +1669,24 @@
 
 T1_TO_T2(dec, uint)
 {
-  xs_nonNegativeInteger const n(aItem->getDecimalValue());
-  aFactory->createNonNegativeInteger(result, n);
+  try
+  {
+    xs_nonNegativeInteger const n(aItem->getDecimalValue());
+    aFactory->createNonNegativeInteger(result, n);
+  }
+  catch ( const std::exception& ) 
+  {
+    throwFOCA0002Exception(aItem->getStringValue(), errInfo);
+  }
 }
 
 
 T1_TO_T2(bool, uint)
 {
-  if (aItem->getBooleanValue())
-    aFactory->createNonNegativeInteger(result, xs_nonNegativeInteger::one());
-  else
-    aFactory->createNonNegativeInteger(result, xs_nonNegativeInteger::zero());
+  xs_nonNegativeInteger const &i = aItem->getBooleanValue() ?
+    numeric_consts<xs_nonNegativeInteger>::one() :
+    numeric_consts<xs_nonNegativeInteger>::zero();
+  aFactory->createNonNegativeInteger(result, i );
 }
 
 
@@ -2024,12 +2034,16 @@
   }
   case store::XS_POSITIVE_INTEGER:
   {
-    xs_positiveInteger const i = aItem->getUnsignedIntegerValue();
-    if (i.sign() > 0)
+    try
     {
-      factory->createPositiveInteger(result, i);
+      xs_positiveInteger const n = aItem->getUnsignedIntegerValue();
+      factory->createPositiveInteger(result, n);
       return;
     }
+    catch ( std::exception const& )
+    {
+      // ignore
+    }
     break;
   }
   default:
 
=== modified file 'src/types/schema/XercesParseUtils.cpp'
--- src/types/schema/XercesParseUtils.cpp	2013-03-05 12:34:19 +0000
+++ src/types/schema/XercesParseUtils.cpp	2013-05-08 15:05:31 +0000
@@ -28,15 +28,18 @@
 #include "LoadSchemaErrorHandler.h"
 #include "PrintSchema.h"
 
+#include "diagnostics/xquery_diagnostics.h"
 #include "store/api/item.h"
 #include "store/api/item_factory.h"
+#include "system/globalenv.h"
 #include "types/typeimpl.h"
-#include "diagnostics/xquery_diagnostics.h"
-#include <zorbatypes/numconversions.h>
-#include "system/globalenv.h"
+#include "util/utf8_util.h"
 #include "zorbatypes/datetime.h"
+#include "zorbatypes/decimal.h"
 #include "zorbatypes/duration.h"
-#include "util/utf8_util.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/numconversions.h"
 
 using namespace std;
 XERCES_CPP_NAMESPACE_USE;
 
=== modified file 'src/util/stl_util.h'
--- src/util/stl_util.h	2013-04-17 15:21:56 +0000
+++ src/util/stl_util.h	2013-05-08 15:05:31 +0000
@@ -421,6 +421,13 @@
   return true;
 }
 
+inline std::enable_if<!ZORBA_TR1_NS::is_signed<char>::value
+                   && !ZORBA_TR1_NS::is_unsigned<char>::value,
+                      bool>::type
+ge0( char c ) {
+  return c >= 0;
+}
+
 template<typename NumericType> inline
 typename std::enable_if<ZORBA_TR1_NS::is_signed<NumericType>::value,bool>::type
 lt0( NumericType n ) {
@@ -433,6 +440,13 @@
   return false;
 }
 
+inline std::enable_if<!ZORBA_TR1_NS::is_signed<char>::value
+                   && !ZORBA_TR1_NS::is_unsigned<char>::value,
+                      bool>::type
+lt0( char c ) {
+  return c < 0;
+}
+
 template<typename NumericType> inline
 typename std::enable_if<ZORBA_TR1_NS::is_signed<NumericType>::value,bool>::type
 le0( NumericType n ) {
@@ -445,6 +459,10 @@
   return n == 0;
 }
 
+inline bool le0( char c ) {
+  return c <= 0;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 //
 
=== modified file 'src/zorbaserialization/serialize_basic_types.cpp'
--- src/zorbaserialization/serialize_basic_types.cpp	2013-04-08 00:12:00 +0000
+++ src/zorbaserialization/serialize_basic_types.cpp	2013-05-08 15:05:31 +0000
@@ -22,6 +22,7 @@
 #include "zorbaserialization/archiver.h"
 #include "zorbaserialization/base64impl.h"
 
+#include "zorbatypes/m_apm.h"
 #include "zorbatypes/floatimpl.h"
 
 #include "diagnostics/xquery_diagnostics.h"
 
=== modified file 'src/zorbaserialization/serialize_zorba_types.cpp'
--- src/zorbaserialization/serialize_zorba_types.cpp	2013-03-27 17:11:24 +0000
+++ src/zorbaserialization/serialize_zorba_types.cpp	2013-05-08 15:05:31 +0000
@@ -82,26 +82,21 @@
 /*******************************************************************************
 
 ********************************************************************************/
-#ifdef ZORBA_WITH_BIG_INTEGER
-
-void operator&(serialization::Archiver& ar, IntegerImpl& obj)
-{
-  ar & obj.value_;
-}
-
-#else
-
-void operator&(serialization::Archiver& ar, IntegerImpl<long long>& obj)
-{
-  ar & obj.value();
-}
-
-void operator&(serialization::Archiver& ar, IntegerImpl<unsigned long long>& obj)
-{
-  ar & obj.value();
-}
-
-#endif
+
+template<class T>
+void operator&(serialization::Archiver& ar, IntegerImpl<T>& obj)
+{
+  ar & obj.value();
+}
+
+#define INSTANTIATE_INTEGER(I) \
+  template void operator&<I::traits_type>(serialization::Archiver&, I&)
+
+INSTANTIATE_INTEGER( Integer );
+INSTANTIATE_INTEGER( NegativeInteger );
+INSTANTIATE_INTEGER( NonNegativeInteger );
+INSTANTIATE_INTEGER( NonPositiveInteger );
+INSTANTIATE_INTEGER( PositiveInteger );
 
 
 /*******************************************************************************
 
=== modified file 'src/zorbaserialization/serialize_zorba_types.h'
--- src/zorbaserialization/serialize_zorba_types.h	2013-02-07 17:24:36 +0000
+++ src/zorbaserialization/serialize_zorba_types.h	2013-05-08 15:05:31 +0000
@@ -23,6 +23,7 @@
 #include "zorbatypes/rchandle.h"
 #include "zorbatypes/m_apm.h"
 #include "zorbatypes/floatimpl.h"
+#include "zorbatypes/zorbatypes_decl.h"
 
 #include "zorbautils/checked_vector.h"
 
@@ -37,24 +38,16 @@
 
 namespace zorba
 {
-  class Decimal;
-  class Duration;
-  class Timezone;
-  class DateTime;
   class Base16;
   class Base64;
-  class QueryLoc;
+  class Diagnostic;
+  class function;
   class HashMapItemPointerCmp;
   class HashMapZStringCmp;
+  class QueryLoc;
+  class Timezone;
   class XQType;
-  class function;
-  class Diagnostic;
   class ZorbaException;
-#ifdef ZORBA_WITH_BIG_INTEGER
-  class IntegerImpl;
-#else
-  template<typename IntType> class IntegerImpl;
-#endif /* ZORBA_WITH_BIG_INTEGER */
 
 namespace serialization
 {
@@ -65,12 +58,8 @@
 
 void operator&(Archiver& ar, const XQType*& obj);
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-void operator&(Archiver& ar, IntegerImpl& obj);
-#else
-void operator&(serialization::Archiver& ar, IntegerImpl<long long>& obj);
-void operator&(serialization::Archiver& ar, IntegerImpl<unsigned long long>& obj);
-#endif
+template<class C>
+void operator&(Archiver& ar, IntegerImpl<C>& obj);
 
 void operator&(Archiver& ar, Decimal& obj);
 
 
=== modified file 'src/zorbatypes/CMakeLists.txt'
--- src/zorbatypes/CMakeLists.txt	2013-02-07 17:24:36 +0000
+++ src/zorbatypes/CMakeLists.txt	2013-05-08 15:05:31 +0000
@@ -17,6 +17,7 @@
   floatimpl.cpp
   integer.cpp
   numconversions.cpp
+  numeric_types.cpp
   binary.cpp
   URI.cpp
   collation_manager.cpp
 
=== modified file 'src/zorbatypes/datetime.h'
--- src/zorbatypes/datetime.h	2013-04-23 06:09:42 +0000
+++ src/zorbatypes/datetime.h	2013-05-08 15:05:31 +0000
@@ -20,11 +20,10 @@
 #include <iostream>
 
 #include <zorba/config.h>
-#include "zorbatypes/timezone.h"
-#include "zorbatypes/duration.h"
-
 #include "util/ascii_util.h"
 
+#include "timezone.h"
+#include "duration.h"
 
 namespace zorba
 {
@@ -301,7 +300,7 @@
       
   int getMinutes() const;
       
-  xs_decimal getSeconds() const;
+  Decimal getSeconds() const;
   
   int getIntSeconds() const;
   
 
=== modified file 'src/zorbatypes/datetime/datetimetype.cpp'
--- src/zorbatypes/datetime/datetimetype.cpp	2013-04-24 17:26:02 +0000
+++ src/zorbatypes/datetime/datetimetype.cpp	2013-05-08 15:05:31 +0000
@@ -29,14 +29,15 @@
 #include <time.h>
 #endif
 
+#include "zorbatypes/datetime.h"
+#include "zorbatypes/datetime/parse.h"
+#include "zorbatypes/decimal.h"
+#include "zorbatypes/duration.h"
+#include "zorbatypes/integer.h"
+#include "zorbatypes/timezone.h"
+#include "zorbatypes/zorbatypes_decl.h"
+#include "zorbatypes/zstring.h"
 #include "zorbautils/hashfun.h"
-#include <zorbatypes/datetime.h>
-#include <zorbatypes/duration.h>
-#include <zorbatypes/timezone.h>
-#include <zorbatypes/zorbatypes_decl.h>
-#include <zorbatypes/zstring.h>
-
-#include "zorbatypes/datetime/parse.h"
 
 #include "util/ascii_util.h"
 #include "util/time_util.h"
@@ -1325,7 +1326,7 @@
     // validate timezone value (-14 .. +14 H)
     if (d->getYears() != 0 || d->getMonths() != 0 ||
         d->getDays() != 0 ||
-        d->getSeconds() != Integer::zero() ||
+        d->getSeconds().sign() != 0 ||
         d->getHours()*3600 + d->getMinutes()*60 > 14*3600 ||
         d->getHours()*3600 + d->getMinutes()*60 < -14*3600)
       throw InvalidTimezoneException( d->getHours()*3600 + d->getMinutes()*60 );
 
=== modified file 'src/zorbatypes/datetime/duration.cpp'
--- src/zorbatypes/datetime/duration.cpp	2013-04-16 21:12:12 +0000
+++ src/zorbatypes/datetime/duration.cpp	2013-05-08 15:05:31 +0000
@@ -19,11 +19,14 @@
 #include <memory>
 #include <string>
 
-#include "zorbautils/hashfun.h"
+#include "zorbatypes/datetime.h"
+#include "zorbatypes/datetime/parse.h"
+#include "zorbatypes/decimal.h"
 #include "zorbatypes/duration.h"
-#include "zorbatypes/datetime/parse.h"
+#include "zorbatypes/floatimpl.h"
+#include "zorbatypes/integer.h"
 #include "zorbatypes/numconversions.h"
-#include "zorbatypes/datetime.h"
+#include "zorbautils/hashfun.h"
 
 #include "diagnostics/xquery_diagnostics.h"
 
@@ -597,7 +600,8 @@
 
 xs_double Duration::getTotalSeconds() const
 {
-  return (is_negative ? xs_double::neg_one() : xs_double::one())
+  return (is_negative ?
+      numeric_consts<xs_double>::neg_one() : numeric_consts<xs_double>::one())
       * ((((((((xs_double(data[YEAR_DATA]) * 12
       + xs_double(data[MONTH_DATA])) * 30)
       + xs_double(data[DAY_DATA])) * 24)
 
=== modified file 'src/zorbatypes/datetime/timezone.cpp'
--- src/zorbatypes/datetime/timezone.cpp	2013-03-13 16:19:33 +0000
+++ src/zorbatypes/datetime/timezone.cpp	2013-05-08 15:05:31 +0000
@@ -22,6 +22,7 @@
 #include <zorbatypes/timezone.h>
 
 #include "zorbatypes/datetime/parse.h"
+#include "zorbatypes/decimal.h"
 
 #include "zorbautils/hashfun.h"
 
 
=== modified file 'src/zorbatypes/decimal.cpp'
--- src/zorbatypes/decimal.cpp	2013-04-11 18:13:48 +0000
+++ src/zorbatypes/decimal.cpp	2013-05-08 15:05:31 +0000
@@ -23,19 +23,10 @@
 #include "util/ascii_util.h"
 
 #include "decimal.h"
+#include "floatimpl.h"
 #include "integer.h"
 #include "numconversions.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(T) /* nothing */
-# define INTEGER_IMPL(I)  IntegerImpl
-#else
-# define TEMPLATE_DECL(T) template<typename T> /* spacer */
-# define INTEGER_IMPL(I)  IntegerImpl<I> /* spacer */
-#endif /* ZORBA_WITH_BIG_INTEGER */
-#define INTEGER_IMPL_LL  INTEGER_IMPL(long long)
-#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
-
 namespace zorba {
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -79,7 +70,6 @@
     delete[] copy;
   } else
     *result = first_non_ws;
-
 }
 
 /**
@@ -178,7 +168,6 @@
   }
 }
 
-
 ////////// constructors ///////////////////////////////////////////////////////
 
 Decimal::Decimal( long long n ) {
@@ -224,14 +213,16 @@
   value_ = f.getNumber();
 }
 
-TEMPLATE_DECL(I)
-Decimal::Decimal( INTEGER_IMPL(I) const &i ) :
-    value_( i.itod() ) {
+template<class T>
+Decimal::Decimal( IntegerImpl<T> const &i ) : value_( i.itod() ) {
 }
-#ifndef ZORBA_WITH_BIG_INTEGER
-template Decimal::Decimal( INTEGER_IMPL_LL const& );
-template Decimal::Decimal( INTEGER_IMPL_ULL const& );
-#endif /* ZORBA_WITH_BIG_INTEGER */
+
+// instantiate Decimal-from-Integer constructors
+template Decimal::Decimal( Integer const& );
+template Decimal::Decimal( NegativeInteger const& );
+template Decimal::Decimal( NonNegativeInteger const& );
+template Decimal::Decimal( NonPositiveInteger const& );
+template Decimal::Decimal( PositiveInteger const& );
 
 ////////// assignment operators ///////////////////////////////////////////////
 
@@ -247,15 +238,17 @@
   return *this;
 }
 
-TEMPLATE_DECL(I)
-Decimal& Decimal::operator=( INTEGER_IMPL(I) const &i ) {
+template<class T>
+Decimal& Decimal::operator=( IntegerImpl<T> const &i ) {
   value_ = i.itod();
   return *this;
 }
-#ifndef ZORBA_WITH_BIG_INTEGER
-template Decimal& Decimal::operator=( INTEGER_IMPL_LL const& );
-template Decimal& Decimal::operator=( INTEGER_IMPL_ULL const& );
-#endif /* ZORBA_WITH_BIG_INTEGER */
+
+template Decimal& Decimal::operator=( Integer const& );
+template Decimal& Decimal::operator=( NegativeInteger const& );
+template Decimal& Decimal::operator=( NonNegativeInteger const& );
+template Decimal& Decimal::operator=( NonPositiveInteger const& );
+template Decimal& Decimal::operator=( PositiveInteger const& );
 
 Decimal& Decimal::operator=( Double const &d ) {
   if ( !d.isFinite() )
@@ -273,20 +266,19 @@
 
 ////////// arithmetic operators ///////////////////////////////////////////////
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define ZORBA_INSTANTIATE(OP) /* nothing */
-#else
-# define ZORBA_INSTANTIATE(OP)                                            \
-  template Decimal operator OP( Decimal const&, INTEGER_IMPL_LL const& ); \
-  template Decimal operator OP( Decimal const&, INTEGER_IMPL_ULL const& )
-#endif /* ZORBA_WITH_BIG_INTEGER */
+#define ZORBA_INSTANTIATE(OP,I) \
+  template Decimal operator OP( Decimal const&, I const& )
 
 #define ZORBA_DECIMAL_OP(OP)                                          \
-  TEMPLATE_DECL(I)                                                    \
-  Decimal operator OP( Decimal const &d, INTEGER_IMPL(I) const &i ) { \
+  template<class T> inline                                            \
+  Decimal operator OP( Decimal const &d, IntegerImpl<T> const &i ) {  \
     return d.value_ OP i.itod();                                      \
   }                                                                   \
-  ZORBA_INSTANTIATE(OP)
+  ZORBA_INSTANTIATE(OP,Integer);                                      \
+  ZORBA_INSTANTIATE(OP,NegativeInteger);                              \
+  ZORBA_INSTANTIATE(OP,NonNegativeInteger);                           \
+  ZORBA_INSTANTIATE(OP,NonPositiveInteger);                           \
+  ZORBA_INSTANTIATE(OP,PositiveInteger);
 
 ZORBA_DECIMAL_OP(+);
 ZORBA_DECIMAL_OP(-);
@@ -298,20 +290,19 @@
 
 ////////// relational operators ///////////////////////////////////////////////
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define ZORBA_INSTANTIATE(OP) /* nothing */
-#else
-# define ZORBA_INSTANTIATE(OP)                                          \
-  template bool operator OP( Decimal const&, INTEGER_IMPL_LL const& );  \
-  template bool operator OP( Decimal const&, INTEGER_IMPL_ULL const& )
-#endif /* ZORBA_WITH_BIG_INTEGER */
+#define ZORBA_INSTANTIATE(OP,I) \
+  template bool operator OP( Decimal const&, I const& )
 
-#define ZORBA_DECIMAL_OP(OP)                                        \
-  TEMPLATE_DECL(I)                                                  \
-  bool operator OP( Decimal const &d, INTEGER_IMPL(I) const &i ) {  \
-    return d.value_ OP i.itod();                                    \
-  }                                                                 \
-  ZORBA_INSTANTIATE(OP)
+#define ZORBA_DECIMAL_OP(OP)                                      \
+  template<class T> inline                                        \
+  bool operator OP( Decimal const &d, IntegerImpl<T> const &i ) { \
+    return d.value_ OP i.itod();                                  \
+  }                                                               \
+  ZORBA_INSTANTIATE( OP, Integer );                               \
+  ZORBA_INSTANTIATE( OP, NegativeInteger );                       \
+  ZORBA_INSTANTIATE( OP, NonNegativeInteger );                    \
+  ZORBA_INSTANTIATE( OP, NonPositiveInteger );                    \
+  ZORBA_INSTANTIATE( OP, PositiveInteger );
 
 ZORBA_DECIMAL_OP(==);
 ZORBA_DECIMAL_OP(!=);
@@ -325,17 +316,19 @@
 ////////// math functions /////////////////////////////////////////////////////
 
 Decimal Decimal::round() const {
-  return round( INTEGER_IMPL_LL::zero() );
+  return round( numeric_consts<xs_integer>::zero() );
 }
 
-TEMPLATE_DECL(I)
-Decimal Decimal::round( INTEGER_IMPL(I) const &precision ) const {
+template<class T>
+Decimal Decimal::round( IntegerImpl<T> const &precision ) const {
   return round2( value_, precision.itod() );
 }
-#ifndef ZORBA_WITH_BIG_INTEGER
-template Decimal Decimal::round( INTEGER_IMPL_LL const& ) const;
-template Decimal Decimal::round( INTEGER_IMPL_ULL const& ) const;
-#endif /* ZORBA_WITH_BIG_INTEGER */
+
+template Decimal Decimal::round( Integer const& ) const;
+template Decimal Decimal::round( NegativeInteger const& ) const;
+template Decimal Decimal::round( NonNegativeInteger const& ) const;
+template Decimal Decimal::round( NonPositiveInteger const& ) const;
+template Decimal Decimal::round( PositiveInteger const& ) const;
 
 Decimal::value_type Decimal::round2( value_type const &v,
                                      value_type const &precision ) {
@@ -352,14 +345,16 @@
   return result;
 }
 
-TEMPLATE_DECL(I)
-Decimal Decimal::roundHalfToEven( INTEGER_IMPL(I) const &precision ) const {
+template<class T>
+Decimal Decimal::roundHalfToEven( IntegerImpl<T> const &precision ) const {
   return roundHalfToEven2( value_, precision.itod() );
 }
-#ifndef ZORBA_WITH_BIG_INTEGER
-template Decimal Decimal::roundHalfToEven( INTEGER_IMPL_LL const& ) const;
-template Decimal Decimal::roundHalfToEven( INTEGER_IMPL_ULL const& ) const;
-#endif /* ZORBA_WITH_BIG_INTEGER */
+
+template Decimal Decimal::roundHalfToEven( Integer const& ) const;
+template Decimal Decimal::roundHalfToEven( NegativeInteger const& ) const;
+template Decimal Decimal::roundHalfToEven( NonNegativeInteger const& ) const;
+template Decimal Decimal::roundHalfToEven( NonPositiveInteger const& ) const;
+template Decimal Decimal::roundHalfToEven( PositiveInteger const& ) const;
 
 Decimal::value_type Decimal::roundHalfToEven2( value_type const &v,
                                                value_type const &precision ) {
@@ -425,21 +420,15 @@
   return static_cast<uint32_t>( n );
 }
 
-Decimal const& Decimal::one() {
-  static Decimal d(1);
-  return d;
-}
-
-zstring Decimal::toString( value_type const &value, int precision ) {
-  return toString(value, false, precision);
-}
-
-zstring Decimal::toString( value_type const &value, bool minusZero, int precision ) {
+zstring Decimal::toString( value_type const &value, bool minusZero,
+                           int precision ) {
   char buf[ 1024 ];
 
-  if ( minusZero )
-  {
-    buf[0] = '-';
+  if ( minusZero ) {
+    if ( value.sign() == 0 )
+      buf[0] = '-';
+    else
+      minusZero = false;
   }
 
   value.toFixPtString( buf + minusZero, precision );
@@ -464,11 +453,6 @@
   return buf;
 }
 
-Decimal const& Decimal::zero() {
-  static Decimal d(0);
-  return d;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 } // namespace zorba
 
=== modified file 'src/zorbatypes/decimal.h'
--- src/zorbatypes/decimal.h	2013-04-11 18:13:48 +0000
+++ src/zorbatypes/decimal.h	2013-05-08 15:05:31 +0000
@@ -28,14 +28,6 @@
 #include "zorbatypes_decl.h"
 #include "zstring.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(I) /* nothing */
-# define INTEGER_IMPL(I)  IntegerImpl
-#else
-# define TEMPLATE_DECL(I) template<typename I> /* spacer */
-# define INTEGER_IMPL(I)  IntegerImpl<I> /* spacer */
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
 namespace zorba {
 
 class Decimal;
@@ -72,8 +64,8 @@
   explicit Decimal( float n );
   explicit Decimal( double n );
 
-  TEMPLATE_DECL(I)
-  explicit Decimal( INTEGER_IMPL(I) const &i );
+  template<class T>
+  explicit Decimal( IntegerImpl<T> const &i );
 
   /**
    * Constructs a %Decimal from a C string.
@@ -133,8 +125,8 @@
   Decimal& operator=( Double const &d );
   Decimal& operator=( Float const &f );
 
-  TEMPLATE_DECL(I)
-  Decimal& operator=( INTEGER_IMPL(I) const &i );
+  template<class T>
+  Decimal& operator=( IntegerImpl<T> const &i );
 
   ////////// arithmetic operators /////////////////////////////////////////////
 
@@ -145,11 +137,11 @@
   friend Decimal operator%( Decimal const&, Decimal const& );
 
 #define ZORBA_DECIMAL_OP(OP)                                            \
-  TEMPLATE_DECL(I)                                                      \
-  friend Decimal operator OP( Decimal const&, INTEGER_IMPL(I) const& ); \
+  template<class T>                                                     \
+  friend Decimal operator OP( Decimal const&, IntegerImpl<T> const& );  \
                                                                         \
-  TEMPLATE_DECL(I)                                                      \
-  friend Decimal operator OP( INTEGER_IMPL(I) const&, Decimal const& )
+  template<class T>                                                     \
+  friend Decimal operator OP( IntegerImpl<T> const&, Decimal const& )
 
   ZORBA_DECIMAL_OP(+);
   ZORBA_DECIMAL_OP(-);
@@ -165,7 +157,7 @@
   Decimal& operator%=( Decimal const& );
 
 #define ZORBA_DECIMAL_OP(OP) \
-  TEMPLATE_DECL(I) Decimal& operator OP( INTEGER_IMPL(I) const& )
+  template<class T> Decimal& operator OP( IntegerImpl<T> const& )
 
   ZORBA_DECIMAL_OP(+=);
   ZORBA_DECIMAL_OP(-=);
@@ -178,12 +170,12 @@
 
   ////////// relational operators /////////////////////////////////////////////
 
-#define ZORBA_DECIMAL_OP(OP)                                          \
-  friend bool operator OP( Decimal const&, Decimal const& );          \
-  TEMPLATE_DECL(I)                                                    \
-  friend bool operator OP( Decimal const&, INTEGER_IMPL(I) const& );  \
-  TEMPLATE_DECL(I)                                                    \
-  friend bool operator OP( INTEGER_IMPL(I) const&, Decimal const& )
+#define ZORBA_DECIMAL_OP(OP)                                        \
+  friend bool operator OP( Decimal const&, Decimal const& );        \
+  template<class T>                                                 \
+  friend bool operator OP( Decimal const&, IntegerImpl<T> const& ); \
+  template<class T>                                                 \
+  friend bool operator OP( IntegerImpl<T> const&, Decimal const& )
 
   ZORBA_DECIMAL_OP(==);
   ZORBA_DECIMAL_OP(!=);
@@ -201,11 +193,11 @@
   Decimal floor() const;
   Decimal round() const;
 
-  TEMPLATE_DECL(I)
-  Decimal round( INTEGER_IMPL(I) const &precision ) const;
+  template<class T>
+  Decimal round( IntegerImpl<T> const &precision ) const;
 
-  TEMPLATE_DECL(I)
-  Decimal roundHalfToEven( INTEGER_IMPL(I) const &precision ) const;
+  template<class T>
+  Decimal roundHalfToEven( IntegerImpl<T> const &precision ) const;
 
   Decimal sqrt() const;
 
@@ -223,9 +215,6 @@
 
   zstring toString( int precision = ZORBA_FLOAT_POINT_PRECISION ) const;
 
-  static Decimal const& one();
-  static Decimal const& zero();
-
   /////////////////////////////////////////////////////////////////////////////
 
 private:
@@ -254,13 +243,15 @@
   static value_type roundHalfToEven2( value_type const &v,
                                       value_type const &precision );
 
-  static zstring toString( value_type const&,
-                           int precision = ZORBA_FLOAT_POINT_PRECISION );
+  static zstring toString( value_type const &value,
+                           int precision = ZORBA_FLOAT_POINT_PRECISION ) {
+    return toString( value, false, precision );
+  }
 
   static zstring toString( value_type const&, bool,
                            int precision = ZORBA_FLOAT_POINT_PRECISION );
 
-  TEMPLATE_DECL(I) friend class IntegerImpl;
+  template<class T> friend class IntegerImpl;
   template<typename F> friend class FloatImpl;
 
   friend xs_long to_xs_long( Decimal const& );
@@ -429,9 +420,6 @@
 
 } // namespace zorba
 
-#undef TEMPLATE_DECL
-#undef INTEGER_IMPL
-
 #endif /* ZORBA_DECIMAL_H */
 /*
  * Local variables:
 
=== modified file 'src/zorbatypes/duration.h'
--- src/zorbatypes/duration.h	2013-02-07 17:24:36 +0000
+++ src/zorbatypes/duration.h	2013-05-08 15:05:31 +0000
@@ -18,10 +18,10 @@
 #define ZORBA_TYPES_DURATION_H
 
 #include <zorba/config.h>
-#include "zorbatypes/zorbatypes_decl.h"
-#include "zorbatypes/schema_types.h"
+#include "zorbatypes_decl.h"
 
 #include "util/ascii_util.h"
+#include "zorbatypes/zstring.h"
 
 namespace zorba
 {
@@ -175,9 +175,9 @@
 
   Duration* operator-(const Duration& d) const;
 
-  Duration* operator*(const xs_double& value) const;
+  Duration* operator*(const Double& value) const;
 
-  Duration* operator/(const xs_double& value) const;
+  Duration* operator/(const Double& value) const;
 
   Decimal operator/(const Duration& d) const;
 
@@ -195,13 +195,13 @@
 
   virtual long getMinutes() const;
 
-  virtual xs_decimal getSeconds() const;
+  virtual Decimal getSeconds() const;
 
   virtual long getFractionalSeconds() const;
 
   virtual long getIntSeconds() const;
 
-  xs_double getTotalSeconds() const;
+  Double getTotalSeconds() const;
 
   long getTotalMilliseconds() const;
 
 
=== modified file 'src/zorbatypes/floatimpl.cpp'
--- src/zorbatypes/floatimpl.cpp	2013-04-02 21:31:04 +0000
+++ src/zorbatypes/floatimpl.cpp	2013-05-08 15:05:31 +0000
@@ -30,16 +30,6 @@
 #include "zorbaserialization/serialize_zorba_types.h"
 #include "zorbaserialization/serialize_template_types.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(T) /* nothing */
-# define INTEGER_IMPL(I)  IntegerImpl
-#else
-# define TEMPLATE_DECL(T) template<typename T> /* spacer */
-# define INTEGER_IMPL(I)  IntegerImpl<I> /* spacer */
-#endif /* ZORBA_WITH_BIG_INTEGER */
-#define INTEGER_IMPL_LL  INTEGER_IMPL(long long)
-#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
-
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace zorba {
@@ -72,8 +62,8 @@
   }
 }
 
-template<typename FloatType>
-void FloatImpl<FloatType>::parse( char const *s ) {
+template<typename F>
+void FloatImpl<F>::parse( char const *s ) {
   if ( !*s )
     throw std::invalid_argument( "empty string" );
 
@@ -151,80 +141,87 @@
 
 ////////// constructors ///////////////////////////////////////////////////////
 
-template<typename FloatType>
-FloatImpl<FloatType>::FloatImpl( Decimal const &d ) {
+template<typename F>
+FloatImpl<F>::FloatImpl( Decimal const &d ) {
   zstring const temp( d.toString() );
   parse( temp.c_str() );
 }
 
-template<typename FloatType>
-TEMPLATE_DECL(IntType)
-FloatImpl<FloatType>::FloatImpl( INTEGER_IMPL(IntType) const &i ) {
+template<typename F>
+template<class T>
+FloatImpl<F>::FloatImpl( IntegerImpl<T> const &i ) {
   zstring const temp( i.toString() );
   parse( temp.c_str() );
 }
 
-#ifndef ZORBA_WITH_BIG_INTEGER
-template FloatImpl<float>::FloatImpl( INTEGER_IMPL_LL const& );
-template FloatImpl<float>::FloatImpl( INTEGER_IMPL_ULL const& );
+template FloatImpl<float>::FloatImpl( Integer const& );
+template FloatImpl<float>::FloatImpl( NegativeInteger const& );
+template FloatImpl<float>::FloatImpl( NonNegativeInteger const& );
+template FloatImpl<float>::FloatImpl( NonPositiveInteger const& );
+template FloatImpl<float>::FloatImpl( PositiveInteger const& );
 
-template FloatImpl<double>::FloatImpl( INTEGER_IMPL_LL const& );
-template FloatImpl<double>::FloatImpl( INTEGER_IMPL_ULL const& );
-#endif /* ZORBA_WITH_BIG_INTEGER */
+template FloatImpl<double>::FloatImpl( Integer const& );
+template FloatImpl<double>::FloatImpl( NegativeInteger const& );
+template FloatImpl<double>::FloatImpl( NonNegativeInteger const& );
+template FloatImpl<double>::FloatImpl( NonPositiveInteger const& );
+template FloatImpl<double>::FloatImpl( PositiveInteger const& );
 
 ////////// assignment operators ///////////////////////////////////////////////
 
-template<typename FloatType>
-FloatImpl<FloatType>& FloatImpl<FloatType>::operator=( Decimal const &d ) {
+template<typename F>
+FloatImpl<F>& FloatImpl<F>::operator=( Decimal const &d ) {
   zstring const temp( d.toString() );
   parse( temp.c_str() );
   return *this;
 }
 
-template<typename FloatType>
-TEMPLATE_DECL(IntType)
-FloatImpl<FloatType>&
-FloatImpl<FloatType>::operator=( INTEGER_IMPL(IntType) const &i ) {
+template<typename F>
+template<class T>
+FloatImpl<F>& FloatImpl<F>::operator=( IntegerImpl<T> const &i ) {
   zstring const temp( i.toString() );
   parse( temp.c_str() );
   return *this;
 }
 
-#ifndef ZORBA_WITH_BIG_INTEGER
-template
-FloatImpl<float>& FloatImpl<float>::operator=( INTEGER_IMPL_LL const& );
-
-template
-FloatImpl<float>& FloatImpl<float>::operator=( INTEGER_IMPL_ULL const& );
-
-template
-FloatImpl<double>& FloatImpl<double>::operator=( INTEGER_IMPL_LL const& );
-
-template
-FloatImpl<double>& FloatImpl<double>::operator=( INTEGER_IMPL_ULL const& );
-#endif /* ZORBA_WITH_BIG_INTEGER */
+#define ZORBA_INSTANTIATE(F,I) \
+  template FloatImpl<F>& FloatImpl<F>::operator=( I const& )
+
+ZORBA_INSTANTIATE(float,Integer);
+ZORBA_INSTANTIATE(float,NegativeInteger);
+ZORBA_INSTANTIATE(float,NonNegativeInteger);
+ZORBA_INSTANTIATE(float,NonPositiveInteger);
+ZORBA_INSTANTIATE(float,PositiveInteger);
+
+ZORBA_INSTANTIATE(double,Integer);
+ZORBA_INSTANTIATE(double,NegativeInteger);
+ZORBA_INSTANTIATE(double,NonNegativeInteger);
+ZORBA_INSTANTIATE(double,NonPositiveInteger);
+ZORBA_INSTANTIATE(double,PositiveInteger);
+#undef ZORBA_INSTANTIATE
 
 ////////// math functions /////////////////////////////////////////////////////
 
-template<typename FloatType>
-FloatImpl<FloatType> FloatImpl<FloatType>::acos() const {
-  if ( *this < neg_one() || *this > one() )
+template<typename F>
+FloatImpl<F> FloatImpl<F>::acos() const {
+  if ( *this < numeric_consts<FloatImpl>::neg_one() ||
+       *this > numeric_consts<FloatImpl>::one() )
     return nan();
-  return FloatImpl<FloatType>(
-    isNegZero() ? -std::acos( value_ ): std::acos( value_ )
+  return FloatImpl<F>(
+    isNegZero() ? -std::acos( value_ ) : std::acos( value_ )
   );
 }
 
-template<typename FloatType>
-FloatImpl<FloatType> FloatImpl<FloatType>::asin() const {
-  if ( *this < neg_one() || *this > one() )
+template<typename F>
+FloatImpl<F> FloatImpl<F>::asin() const {
+  if ( *this < numeric_consts<FloatImpl>::neg_one() ||
+       *this > numeric_consts<FloatImpl>::one() )
     return nan();
-  return FloatImpl<FloatType>( std::asin( value_ ) );
+  return FloatImpl<F>( std::asin( value_ ) );
 }
 
-template<typename FloatType>
-void FloatImpl<FloatType>::frexp( FloatImpl<FloatType> &out_mantissa,
-                                  Integer &out_exponent ) const {
+template<typename F>
+void FloatImpl<F>::frexp( FloatImpl<F> &out_mantissa,
+                          Integer &out_exponent ) const {
   int expint;
   out_mantissa = FloatImpl( ::frexp( value_, &expint ) );
   out_exponent = Integer( expint );
@@ -246,13 +243,13 @@
   out_integer = int_part;
 }
 
-template<typename FloatType>
-FloatImpl<FloatType> FloatImpl<FloatType>::round() const {
-  return round( Integer::zero() );
+template<typename F>
+FloatImpl<F> FloatImpl<F>::round() const {
+  return round( numeric_consts<xs_integer>::zero() );
 }
 
-template<typename FloatType>
-FloatImpl<FloatType> FloatImpl<FloatType>::round( Integer const &precision ) const {
+template<typename F>
+FloatImpl<F> FloatImpl<F>::round( Integer const &precision ) const {
   FloatImpl result;
   if ( isFinite() && !isZero() ) {
     MAPM m(
@@ -274,8 +271,8 @@
   return result;
 }
 
-template<typename FloatType> FloatImpl<FloatType>
-FloatImpl<FloatType>::roundHalfToEven( Integer const &precision) const {
+template<typename F>
+FloatImpl<F> FloatImpl<F>::roundHalfToEven( Integer const &precision ) const {
   FloatImpl result;
   if ( isFinite() && !isZero() ) {
     MAPM m(
@@ -318,48 +315,32 @@
   return false;
 }
 
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::nan() {
-  static FloatImpl<FloatType> const value( std::sqrt( -1.0 ) );
-  return value;
-}
-
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::neg_inf() {
-  static FloatImpl<FloatType> const value(
-    -std::numeric_limits<FloatType>::infinity()
-  );
-  return value;
-}
-
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::neg_one() {
-  static FloatImpl<FloatType> const value( -1 );
-  return value;
-}
-
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::neg_zero() {
-  static FloatImpl<FloatType> const value( -0.0 );
-  return value;
-}
-
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::one() {
-  static FloatImpl<FloatType> const value( 1 );
-  return value;
-}
-
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::pos_inf() {
-  static FloatImpl<FloatType> const value(
-    std::numeric_limits<FloatType>::infinity()
-  );
-  return value;
-}
-
-template<typename FloatType>
-zstring FloatImpl<FloatType>::toIntegerString() const {
+template<typename F>
+FloatImpl<F> const& FloatImpl<F>::nan() {
+  static FloatImpl<F> const value( std::sqrt( -1.0 ) );
+  return value;
+}
+
+template<typename F>
+FloatImpl<F> const& FloatImpl<F>::neg_inf() {
+  static FloatImpl<F> const value( -std::numeric_limits<F>::infinity() );
+  return value;
+}
+
+template<typename F>
+FloatImpl<F> const& FloatImpl<F>::neg_zero() {
+  static FloatImpl<F> const value( -0.0 );
+  return value;
+}
+
+template<typename F>
+FloatImpl<F> const& FloatImpl<F>::pos_inf() {
+  static FloatImpl<F> const value( std::numeric_limits<F>::infinity() );
+  return value;
+}
+
+template<typename F>
+zstring FloatImpl<F>::toIntegerString() const {
   if ( isNaN() )
     return nan_str();
   if  (isPosInf() )
@@ -377,8 +358,8 @@
   return buf;
 }
 
-template<typename FloatType>
-zstring FloatImpl<FloatType>::toString( bool no_scientific_format ) const {
+template<typename F>
+zstring FloatImpl<F>::toString( bool no_scientific_format ) const {
   if ( isNaN() )
     return nan_str();
   if ( isPosInf() )
@@ -390,17 +371,17 @@
   if ( isNegZero() )
     return "-0";
 
-  FloatType const absVal = fabs( value_ );
-  FloatType const lower = 0.000001f, upper = 1000000.0f;
+  value_type const abs_val = fabs( value_ );
+  value_type const lower = 0.000001f, upper = 1000000.0f;
 
-  if (no_scientific_format || (absVal < upper && absVal >= lower) || absVal == 0)
-  {
+  if ( no_scientific_format || (abs_val >= lower && abs_val < upper) ||
+       abs_val == 0 ) {
 #if 1
     // This is the "spec" implementation, i.e., it is an exact application of
     // the spec in  http://www.w3.org/TR/xpath-functions/#casting
     MAPM decimal_mapm( value_ );
     decimal_mapm = decimal_mapm.round( precision_ );
-    return Decimal::toString(decimal_mapm, isNegZero(), max_precision());
+    return Decimal::toString( decimal_mapm, isNegZero(), max_precision() );
 #else
     std::stringstream stream;
     stream.precision(7);
@@ -471,12 +452,6 @@
   }
 }
 
-template<typename FloatType>
-FloatImpl<FloatType> const& FloatImpl<FloatType>::zero() {
-  static FloatImpl<FloatType> const value( 0 );
-  return value;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 template class FloatImpl<double>;
 
=== modified file 'src/zorbatypes/floatimpl.h'
--- src/zorbatypes/floatimpl.h	2013-04-09 01:29:36 +0000
+++ src/zorbatypes/floatimpl.h	2013-05-08 15:05:31 +0000
@@ -29,14 +29,6 @@
 #include "schema_types.h"
 #include "zorbatypes_decl.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(I) /* nothing */
-# define INTEGER_IMPL(I)  IntegerImpl
-#else
-# define TEMPLATE_DECL(I) template<typename I> /* spacer */
-# define INTEGER_IMPL(I)  IntegerImpl<I> /* spacer */
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
 namespace zorba {
 
 template<typename FloatType>
@@ -71,8 +63,8 @@
   explicit FloatImpl( double n );
   explicit FloatImpl( Decimal const &d );
 
-  TEMPLATE_DECL(IntType)
-  explicit FloatImpl( INTEGER_IMPL(IntType) const &i );
+  template<class T>
+  explicit FloatImpl( IntegerImpl<T> const &i );
 
   /**
    * Constructs a %FloatImpl from a C string.
@@ -126,8 +118,8 @@
   FloatImpl& operator=( char const *s );
   FloatImpl& operator=( Decimal const &d );
 
-  TEMPLATE_DECL(I)
-  FloatImpl& operator=( INTEGER_IMPL(I) const &i );
+  template<class T>
+  FloatImpl& operator=( IntegerImpl<T> const &i );
 
   ////////// arithmetic operators /////////////////////////////////////////////
 
@@ -269,11 +261,9 @@
   bool isPosZero() const;
   bool isNegZero() const;
   bool isInteger() const;
+  int sign() const;
 
-  static FloatImpl const& zero();
   static FloatImpl const& neg_zero();
-  static FloatImpl const& one();
-  static FloatImpl const& neg_one();
   static FloatImpl const& nan();
   static FloatImpl const& pos_inf();
   static FloatImpl const& neg_inf();
@@ -283,7 +273,6 @@
   }
 
   zstring toIntegerString() const;
-
   zstring toString( bool no_scientific_mode = false ) const;
 
   /////////////////////////////////////////////////////////////////////////////
@@ -298,14 +287,12 @@
   value_type     value_;
   precision_type precision_;
 
-  FloatImpl( value_type v, precision_type p );
-
   static precision_type max_precision();
 
   void parse( char const* );
   bool parse_etc( char const* );
 
-  TEMPLATE_DECL(I) friend class IntegerImpl;
+  template<class T> friend class IntegerImpl;
   friend class Decimal;
 
   friend class FloatImpl<float>;
@@ -412,24 +399,19 @@
   parse( s );
 }
 
-template<typename F> template<typename G>
+template<typename F>
+template<typename G>
 inline FloatImpl<F>::FloatImpl( FloatImpl<G> const &f ) :
   value_( static_cast<F>( f.value_ ) ), precision_( max_precision() )
 {
 }
 
-template<typename F>
-inline FloatImpl<F>::FloatImpl( value_type v, precision_type p ) :
-  value_( v ), precision_( p )
-{
-}
-
 ////////// assignment operators ///////////////////////////////////////////////
 
-template<typename F> template<typename G>
+template<typename F>
+template<typename G>
 inline FloatImpl<F>& FloatImpl<F>::operator=( FloatImpl<G> const &f ) {
   value_ = static_cast<F>( f.value_ );
-  precision_ = max_precision();
   return *this;
 }
 
@@ -437,7 +419,6 @@
   template<typename F>                                  \
   inline FloatImpl<F>& FloatImpl<F>::operator=( T n ) { \
     value_ = static_cast<F>( n );                       \
-    precision_ = max_precision();                       \
     return *this;                                       \
   }
 
@@ -668,7 +649,8 @@
 ZORBA_FLOAT_OP(/=)
 #undef ZORBA_FLOAT_OP
 
-template<typename F> template<typename G>
+template<typename F>
+template<typename G>
 inline FloatImpl<F>& FloatImpl<F>::operator%=( FloatImpl<G> const &f ) {
   value_ = std::fmod( value_, static_cast<F>( f.value_ ) );
   return *this;
@@ -676,7 +658,7 @@
 
 template<typename F>
 inline FloatImpl<F> FloatImpl<F>::operator-() const {
-  return FloatImpl<F>( -value_, precision_ );
+  return FloatImpl<F>( -value_ );
 }
 
 #define ZORBA_FLOAT_OP(OP) \
@@ -932,7 +914,8 @@
 
 ////////// miscellaneous //////////////////////////////////////////////////////
 
-template<typename F> template<typename G>
+template<typename F>
+template<typename G>
 inline int FloatImpl<F>::compare( FloatImpl<G> const &f ) const {
   return value_ < f.value_ ? -1 : value_ > f.value_ ? 1 : 0;
 }
@@ -987,12 +970,17 @@
   return isFinite() && ::floor( value_ ) == value_;
 }
 
-template <typename F>
+template<typename F>
 inline bool FloatImpl<F>::isZero() const {
   return value_ == 0;
 }
 
 template<typename F>
+inline int FloatImpl<F>::sign() const {
+  return value_ > 0 ? 1 : value_ < 0 ? -1 : 0;
+}
+
+template<typename F>
 inline std::ostream& operator<<( std::ostream &os, FloatImpl<F> const &f ) {
   return os << f.toString();
 }
@@ -1001,9 +989,6 @@
 
 } // namespace zorba
 
-#undef TEMPLATE_DECL
-#undef INTEGER_IMPL
-
 #endif // ZORBA_FLOATIMPL_H
 /*
  * Local variables:
 
=== modified file 'src/zorbatypes/integer.cpp'
--- src/zorbatypes/integer.cpp	2013-04-09 22:38:19 +0000
+++ src/zorbatypes/integer.cpp	2013-05-08 15:05:31 +0000
@@ -16,166 +16,185 @@
 
 #include "stdafx.h"
 
+// standard
 #include <cerrno>
 #include <cstdlib>
+#include <sstream>
 
+// Zorba
 #include <zorba/internal/unique_ptr.h>
 #include "util/cxx_util.h"
 #include "util/string_util.h"
 
-#include "integer.h"
+// local
 #include "decimal.h"
 #include "floatimpl.h"
+#include "integer.h"
 #include "numconversions.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(T) /* nothing */
-# define INTEGER_IMPL(T)  IntegerImpl
-#else
-# define TEMPLATE_DECL(T) template<typename T> /* spacer */
-# define INTEGER_IMPL(T)  IntegerImpl<T> /* spacer */
-#endif /* ZORBA_WITH_BIG_INTEGER */
-#define INTEGER_IMPL_LL  INTEGER_IMPL(long long)
-#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
-
 using namespace std;
 
-#ifndef ZORBA_WITH_BIG_INTEGER
-unsigned long long MaxUIntegerValue = ~0ull >> 1;
-
-inline bool is_too_big( long long ) {
-  return false;
-}
-
-inline bool is_too_big( unsigned long long n ) {
-  return n > MaxUIntegerValue;
-}
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
 namespace zorba {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-TEMPLATE_DECL(I)
-void INTEGER_IMPL(I)::parse( char const *s ) {
+ostream& operator<<( ostream &o, MAPM const &m ) {
+  unique_ptr<char[]> const buf( new char[ m.exponent() + 3 ] );
+  m.toIntegerString( buf.get() );
+  return o << buf.get();
+}
+
+void integer_traits::throw_error( string const &what, bool throw_range_error ) {
+  if ( throw_range_error )
+    throw range_error( what );
+  throw invalid_argument( what );
+}
+
+void integer_traits::throw_error( MAPM const &n, char const *op,
+                                  bool throw_range_error ) {
+  ostringstream oss;
+  oss << n;
+  string const what( BUILD_STRING( oss.str(), ": not ", op, " 0" ) );
+  throw_error( what, throw_range_error );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+template<class T>
+void IntegerImpl<T>::parse( char const *s, bool throw_range_error ) {
 #ifdef ZORBA_WITH_BIG_INTEGER
   Decimal::parse( s, &value_, Decimal::parse_integer );
 #else
-  value_type const temp( ztd::aton<value_type>( s ) );
-  if ( is_too_big( temp ) )
-    throw std::invalid_argument(
-      BUILD_STRING( '"', temp, "\": unsigned integer too big" )
-    );
-  value_ = temp;
+  try {
+    value_ = ztd::aton<value_type>( s );
+  }
+  catch ( std::range_error const &e ) {
+    if ( throw_range_error )
+      throw;
+    throw invalid_argument( e.what() );
+  }
 #endif /* ZORBA_WITH_BIG_INTEGER */
+  T::check_value( value_, throw_range_error );
 }
 
 ////////// constructors ///////////////////////////////////////////////////////
 
 #ifdef ZORBA_WITH_BIG_INTEGER
-IntegerImpl::IntegerImpl( long long n ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( long long n ) {
   ascii::itoa_buf_type buf;
   value_ = ascii::itoa( n, buf );
+  T::check_value( value_, false );
 }
 
 #if ZORBA_SIZEOF_INT == ZORBA_SIZEOF_LONG
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)::IntegerImpl( unsigned int n ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( unsigned int n ) {
   ascii::itoa_buf_type buf;
   value_ = ascii::itoa( n, buf );
+  T::check_value( value_, false );
 }
 #endif /* ZORBA_SIZEOF_INT == ZORBA_SIZEOF_LONG */
 
-IntegerImpl::IntegerImpl( unsigned long n ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( unsigned long n ) {
   ascii::itoa_buf_type buf;
   value_ = ascii::itoa( n, buf );
+  T::check_value( value_, false );
 }
 
-IntegerImpl::IntegerImpl( unsigned long long n ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( unsigned long long n ) {
   ascii::itoa_buf_type buf;
   value_ = ascii::itoa( n, buf );
+  T::check_value( value_, false );
 }
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)::IntegerImpl( Decimal const &d ) {
-  value_ = ftoi( d.value_ );
+template<class T>
+IntegerImpl<T>::IntegerImpl( Decimal const &d ) {
+  value_ = T::check_value( ftoi( d.value_ ), false );
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)::IntegerImpl( Double const &d ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( Double const &d ) {
   if ( !d.isFinite() )
     throw std::invalid_argument( "not finite" );
-  value_ = ftoi( d.getNumber() );
+  value_ = T::check_value( ftoi( d.getNumber() ), false );
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)::IntegerImpl( Float const &f ) {
+template<class T>
+IntegerImpl<T>::IntegerImpl( Float const &f ) {
   if ( !f.isFinite() )
     throw std::invalid_argument( "not finite" );
-  value_ = ftoi( f.getNumber() );
+  value_ = T::check_value( ftoi( f.getNumber() ), false );
 }
 
 ////////// assignment operators ///////////////////////////////////////////////
 
 #ifdef ZORBA_WITH_BIG_INTEGER
-IntegerImpl& IntegerImpl::operator=( long long n ) {
-  ascii::itoa_buf_type buf;
-  value_ = ascii::itoa( n, buf );
-  return *this;
-}
-
-IntegerImpl& IntegerImpl::operator=( unsigned long n ) {
-  ascii::itoa_buf_type buf;
-  value_ = ascii::itoa( n, buf );
-  return *this;
-}
-
-IntegerImpl& IntegerImpl::operator=( unsigned long long n ) {
-  ascii::itoa_buf_type buf;
-  value_ = ascii::itoa( n, buf );
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( long long n ) {
+  ascii::itoa_buf_type buf;
+  value_ = ascii::itoa( n, buf );
+  T::check_value( value_, true );
+  return *this;
+}
+
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( unsigned long n ) {
+  ascii::itoa_buf_type buf;
+  value_ = ascii::itoa( n, buf );
+  T::check_value( value_, true );
+  return *this;
+}
+
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( unsigned long long n ) {
+  ascii::itoa_buf_type buf;
+  value_ = ascii::itoa( n, buf );
+  T::check_value( value_, true );
   return *this;
 }
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)& INTEGER_IMPL(T)::operator=( Decimal const &d ) {
-  value_ = ftoi( d.value_ );
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( Decimal const &d ) {
+  value_ = T::check_value( ftoi( d.value_ ), true );
   return *this;
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)& INTEGER_IMPL(T)::operator=( Double const &d ) {
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( Double const &d ) {
   if ( !d.isFinite() )
     throw std::invalid_argument( "not finite" );
-  value_ = ftoi( d.getNumber() );
+  value_ = T::check_value( ftoi( d.getNumber() ), true );
   return *this;
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)& INTEGER_IMPL(T)::operator=( Float const &f ) {
+template<class T>
+IntegerImpl<T>& IntegerImpl<T>::operator=( Float const &f ) {
   if ( !f.isFinite() )
     throw std::invalid_argument( "not finite" );
-  value_ = ftoi( f.getNumber() );
+  value_ = T::check_value( ftoi( f.getNumber() ), true );
   return *this;
 }
 
 ////////// arithmetic operators ///////////////////////////////////////////////
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define ZORBA_INSTANTIATE(OP) /* nothing */
-#else
-# define ZORBA_INSTANTIATE(OP)                                            \
-  template Decimal operator OP( INTEGER_IMPL_LL const&, Decimal const& ); \
-  template Decimal operator OP( INTEGER_IMPL_ULL const&, Decimal const& );
-#endif /* ZORBA_WITH_BIG_INTEGER */
+#define ZORBA_INSTANTIATE(OP,I) \
+  template Decimal operator OP( I const&, Decimal const& );
 
 #define ZORBA_INTEGER_OP(OP)                                          \
-  TEMPLATE_DECL(T)                                                    \
-  Decimal operator OP( INTEGER_IMPL(T) const &i, Decimal const &d ) { \
+  template<class T>                                                   \
+  Decimal operator OP( IntegerImpl<T> const &i, Decimal const &d ) {  \
     return i.itod() OP d.value_;                                      \
   }                                                                   \
-  ZORBA_INSTANTIATE(OP)
+  ZORBA_INSTANTIATE( OP, Integer );                                   \
+  ZORBA_INSTANTIATE( OP, NegativeInteger );                           \
+  ZORBA_INSTANTIATE( OP, NonNegativeInteger );                        \
+  ZORBA_INSTANTIATE( OP, NonPositiveInteger );                        \
+  ZORBA_INSTANTIATE( OP, PositiveInteger );
 
 ZORBA_INTEGER_OP(+)
 ZORBA_INTEGER_OP(-)
@@ -187,15 +206,26 @@
 
 #ifdef ZORBA_WITH_BIG_INTEGER
 
-#define ZORBA_INTEGER_OP(OP,T)                                            \
-  IntegerImpl operator OP( IntegerImpl const &i, T n ) {                  \
-    ascii::itoa_buf_type buf;                                             \
-    return i.value_ OP IntegerImpl::value_type( ascii::itoa( n, buf ) );  \
-  }                                                                       \
-  IntegerImpl operator OP( T n, IntegerImpl const &i ) {                  \
-    ascii::itoa_buf_type buf;                                             \
-    return IntegerImpl::value_type( ascii::itoa( n, buf ) ) OP i.value_;  \
-  }
+#define ZORBA_INSTANTIATE(OP,I,N)               \
+  template Integer operator OP( I const&, N );  \
+  template Integer operator OP( N, I const& )
+
+#define ZORBA_INTEGER_OP(OP,N)                          \
+  template<class T>                                     \
+  Integer operator OP( IntegerImpl<T> const &i, N n ) { \
+    ascii::itoa_buf_type buf;                           \
+    return i.value_ OP MAPM( ascii::itoa( n, buf ) );   \
+  }                                                     \
+  template<class T>                                     \
+  Integer operator OP( N n, IntegerImpl<T> const &i ) { \
+    ascii::itoa_buf_type buf;                           \
+    return MAPM( ascii::itoa( n, buf ) ) OP i.value_;   \
+  }                                                     \
+  ZORBA_INSTANTIATE( OP, Integer, N );                  \
+  ZORBA_INSTANTIATE( OP, NegativeInteger, N );          \
+  ZORBA_INSTANTIATE( OP, NonNegativeInteger, N );       \
+  ZORBA_INSTANTIATE( OP, NonPositiveInteger, N );       \
+  ZORBA_INSTANTIATE( OP, PositiveInteger, N );
 
 ZORBA_INTEGER_OP(+,long long)
 ZORBA_INTEGER_OP(-,long long)
@@ -210,30 +240,44 @@
 ZORBA_INTEGER_OP(*,unsigned long long)
 ZORBA_INTEGER_OP(%,unsigned long long)
 #undef ZORBA_INTEGER_OP
-
-#define ZORBA_INTEGER_OP(T)                                       \
-  IntegerImpl operator/( IntegerImpl const &i, T n ) {            \
-    ascii::itoa_buf_type buf;                                     \
-    IntegerImpl::value_type const temp( ascii::itoa( n, buf ) );  \
-    return IntegerImpl::ftoi( i.value_ / temp );                  \
-  }                                                               \
-  IntegerImpl operator/( T n, IntegerImpl const &i ) {            \
-    ascii::itoa_buf_type buf;                                     \
-    IntegerImpl::value_type const temp( ascii::itoa( n, buf ) );  \
-    return IntegerImpl::ftoi( temp / i.value_ );                  \
-  }
+#undef ZORBA_INSTANTIATE
+
+#define ZORBA_INSTANTIATE(I,N)                \
+  template Integer operator/( I const&, N );  \
+  template Integer operator/( N, I const& )
+
+#define ZORBA_INTEGER_OP(N)                           \
+  template<class T>                                   \
+  Integer operator/( IntegerImpl<T> const &i, N n ) { \
+    ascii::itoa_buf_type buf;                         \
+    MAPM const temp( ascii::itoa( n, buf ) );         \
+    return Integer::ftoi( i.value_ / temp );          \
+  }                                                   \
+  template<class T>                                   \
+  Integer operator/( N n, IntegerImpl<T> const &i ) { \
+    ascii::itoa_buf_type buf;                         \
+    MAPM const temp( ascii::itoa( n, buf ) );         \
+    return Integer::ftoi( temp / i.value_ );          \
+  }                                                   \
+  ZORBA_INSTANTIATE( Integer, N );                    \
+  ZORBA_INSTANTIATE( NegativeInteger, N );            \
+  ZORBA_INSTANTIATE( NonNegativeInteger, N );         \
+  ZORBA_INSTANTIATE( NonPositiveInteger, N );         \
+  ZORBA_INSTANTIATE( PositiveInteger, N );
 
 ZORBA_INTEGER_OP(long long)
 ZORBA_INTEGER_OP(unsigned long)
 ZORBA_INTEGER_OP(unsigned long long)
 #undef ZORBA_INTEGER_OP
+#undef ZORBA_INSTANTIATE
 
-#define ZORBA_INTEGER_OP(OP,T)                      \
-  IntegerImpl& IntegerImpl::operator OP( T n ) {    \
-    ascii::itoa_buf_type buf;                       \
-    value_type const temp( ascii::itoa( n, buf ) ); \
-    value_ OP temp;                                 \
-    return *this;                                   \
+#define ZORBA_INTEGER_OP(OP,N)                          \
+  template<class T>                                     \
+  IntegerImpl<T>& IntegerImpl<T>::operator OP( N n ) {  \
+    ascii::itoa_buf_type buf;                           \
+    value_type const temp( ascii::itoa( n, buf ) );     \
+    T::check_value( value_ OP temp, true );             \
+    return *this;                                       \
   }
 
 ZORBA_INTEGER_OP(+=,long long)
@@ -250,12 +294,13 @@
 ZORBA_INTEGER_OP(%=,unsigned long long)
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(T) \
-  IntegerImpl& IntegerImpl::operator/=( T n ) {     \
-    ascii::itoa_buf_type buf;                       \
-    value_type const temp( ascii::itoa( n, buf ) ); \
-    value_ = ftoi( value_ / temp );                 \
-    return *this;                                   \
+#define ZORBA_INTEGER_OP(N) \
+  template<class T>                                         \
+  IntegerImpl<T>& IntegerImpl<T>::operator/=( N n ) {       \
+    ascii::itoa_buf_type buf;                               \
+    value_type const temp( ascii::itoa( n, buf ) );         \
+    T::check_value( value_ = ftoi( value_ / temp ), true ); \
+    return *this;                                           \
   }
 
 ZORBA_INTEGER_OP(long long)
@@ -266,36 +311,63 @@
 
 ////////// relational operators ///////////////////////////////////////////////
 
-TEMPLATE_DECL(T)
-bool operator==( INTEGER_IMPL(T) const &i, Decimal const &d ) {
+#define ZORBA_INSTANTIATE(OP,I) \
+  template bool operator OP( I const&, Decimal const& )
+
+template<class T>
+bool operator==( IntegerImpl<T> const &i, Decimal const &d ) {
   return d.is_xs_integer() && i.itod() == d.value_;
 }
 
-#define ZORBA_INTEGER_OP(OP)                                        \
-  TEMPLATE_DECL(T)                                                  \
-  bool operator OP( INTEGER_IMPL(T) const &i, Decimal const &d ) {  \
-    return i.itod() OP d.value_;                                    \
-  }
+ZORBA_INSTANTIATE( ==, Integer );
+ZORBA_INSTANTIATE( ==, NegativeInteger );
+ZORBA_INSTANTIATE( ==, NonNegativeInteger );
+ZORBA_INSTANTIATE( ==, NonPositiveInteger );
+ZORBA_INSTANTIATE( ==, PositiveInteger );
+
+#define ZORBA_INTEGER_OP(OP)                                      \
+  template<class T>                                               \
+  bool operator OP( IntegerImpl<T> const &i, Decimal const &d ) { \
+    return i.itod() OP d.value_;                                  \
+  }                                                               \
+  ZORBA_INSTANTIATE( OP, Integer );                               \
+  ZORBA_INSTANTIATE( OP, NegativeInteger );                       \
+  ZORBA_INSTANTIATE( OP, NonNegativeInteger );                    \
+  ZORBA_INSTANTIATE( OP, NonPositiveInteger );                    \
+  ZORBA_INSTANTIATE( OP, PositiveInteger );
 
 ZORBA_INTEGER_OP(!=)
 ZORBA_INTEGER_OP(< )
 ZORBA_INTEGER_OP(<=)
 ZORBA_INTEGER_OP(> )
 ZORBA_INTEGER_OP(>=)
+#undef ZORBA_INSTANTIATE
 #undef ZORBA_INTEGER_OP
 
 #ifdef ZORBA_WITH_BIG_INTEGER
 
-#define ZORBA_INTEGER_OP(OP,T) \
-  bool operator OP( IntegerImpl const &i, T n ) {                         \
-    ascii::itoa_buf_type buf;                                             \
-    return i.value_ OP IntegerImpl::value_type( ascii::itoa( n, buf ) );  \
-  }                                                                       \
-                                                                          \
-  bool operator OP( T n, IntegerImpl const &i ) {                         \
-    ascii::itoa_buf_type buf;                                             \
-    return IntegerImpl::value_type( ascii::itoa( n, buf ) ) OP i.value_;  \
-  }
+#define ZORBA_INSTANTIATE(OP,I,N)           \
+  template bool operator OP( I const&, N ); \
+  template bool operator OP( N, I const& )
+
+#define ZORBA_INTEGER_OP(OP,N) \
+  template<class T>                                   \
+  bool operator OP( IntegerImpl<T> const &i, N n ) {  \
+    ascii::itoa_buf_type buf;                         \
+    return i.value_ OP MAPM( ascii::itoa( n, buf ) ); \
+  }                                                   \
+                                                      \
+  template<class T>                                   \
+  bool operator OP( N n, IntegerImpl<T> const &i ) {  \
+    ascii::itoa_buf_type buf;                         \
+    return MAPM( ascii::itoa( n, buf ) ) OP i.value_; \
+  }                                                   \
+                                                      \
+  ZORBA_INSTANTIATE( OP, Integer, N );                \
+  ZORBA_INSTANTIATE( OP, NegativeInteger, N );        \
+  ZORBA_INSTANTIATE( OP, NonNegativeInteger, N );     \
+  ZORBA_INSTANTIATE( OP, NonPositiveInteger, N );     \
+  ZORBA_INSTANTIATE( OP, PositiveInteger, N );
 
 ZORBA_INTEGER_OP(==,long long)
 ZORBA_INTEGER_OP(!=,long long)
@@ -315,27 +387,14 @@
 ZORBA_INTEGER_OP(<=,unsigned long long)
 ZORBA_INTEGER_OP(> ,unsigned long long)
 ZORBA_INTEGER_OP(>=,unsigned long long)
-
-#else /* ZORBA_WITH_BIG_INTEGER */
-
-#define ZORBA_INSTANTIATE(OP)                                           \
-  template bool operator OP( INTEGER_IMPL_LL const&, Decimal const& );  \
-  template bool operator OP( INTEGER_IMPL_ULL const&, Decimal const& )
-
-ZORBA_INSTANTIATE(==);
-ZORBA_INSTANTIATE(!=);
-ZORBA_INSTANTIATE(< );
-ZORBA_INSTANTIATE(<=);
-ZORBA_INSTANTIATE(> );
-ZORBA_INSTANTIATE(>=);
 #undef ZORBA_INSTANTIATE
 
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
 ////////// math functions /////////////////////////////////////////////////////
 
-TEMPLATE_DECL(T)
-Double INTEGER_IMPL(T)::pow( INTEGER_IMPL(T) const &power ) const {
+template<class T>
+Double IntegerImpl<T>::pow( IntegerImpl<T> const &power ) const {
 #ifdef ZORBA_WITH_BIG_INTEGER
   value_type const result( value_.pow( power.value_, 15 ) );
   char buf[300];
@@ -349,30 +408,30 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T) INTEGER_IMPL(T)::round( IntegerImpl const &precision ) const {
+template<class T>
+IntegerImpl<T> IntegerImpl<T>::round( IntegerImpl<T> const &precision ) const {
   return IntegerImpl( Decimal::round2( itod(), precision.itod() ) );
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T)
-INTEGER_IMPL(T)::roundHalfToEven( IntegerImpl const &precision ) const {
+template<class T>
+IntegerImpl<T>
+IntegerImpl<T>::roundHalfToEven( IntegerImpl const &precision ) const {
   return IntegerImpl( Decimal::roundHalfToEven2( itod(), precision.itod() ) );
 }
 
 ////////// miscellaneous //////////////////////////////////////////////////////
 
 #ifndef ZORBA_WITH_BIG_INTEGER
-TEMPLATE_DECL(T)
-typename INTEGER_IMPL(T)::value_type INTEGER_IMPL(T)::ftoi( MAPM const &d ) {
+template<class T>
+typename IntegerImpl<T>::value_type IntegerImpl<T>::ftoi( MAPM const &d ) {
   MAPM const temp( d.sign() >= 0 ? d.floor() : d.ceil() );
   unique_ptr<char[]> const buf( new char[ temp.exponent() + 3 ] );
   temp.toIntegerString( buf.get() );
   return ztd::aton<value_type>( buf.get() );
 }
 
-TEMPLATE_DECL(T)
-MAPM INTEGER_IMPL(T)::itod() const {
+template<class T>
+MAPM IntegerImpl<T>::itod() const {
   if ( is_cxx_long() )
     return static_cast<long>( value_ );
   ascii::itoa_buf_type buf;
@@ -381,77 +440,79 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
 #ifdef ZORBA_WITH_BIG_INTEGER
-size_t IntegerImpl::alloc_size() const {
+
+static MAPM xs_byte_min( "-128" );
+static MAPM xs_byte_max( "127" );
+static MAPM xs_short_min( "-32768" );
+static MAPM xs_short_max( "32767" );
+static MAPM xs_unsignedByte_max( "256" );
+static MAPM xs_unsignedInt_max( "4294967295" );
+static MAPM xs_unsignedLong_max( "18446744073709551615" );
+static MAPM xs_unsignedShort_max( "65536" );
+
+template<class T>
+size_t IntegerImpl<T>::alloc_size() const {
   return value_.significant_digits();
 }
 
-uint32_t IntegerImpl::hash() const {
+template<class T>
+uint32_t IntegerImpl<T>::hash() const {
   return Decimal::hash( value_ );
 }
 
-bool IntegerImpl::is_xs_byte() const {
-  static MAPM xs_byte_min( "-128" );
-  static MAPM xs_byte_max( "127" );
+template<class T>
+bool IntegerImpl<T>::is_xs_byte() const {
   return value_ >= xs_byte_min && value_ <= xs_byte_max;
 }
 
-bool IntegerImpl::is_xs_short() const {
-  static MAPM xs_short_min( "-32768" );
-  static MAPM xs_short_max( "32767" );
+template<class T>
+bool IntegerImpl<T>::is_xs_short() const {
   return value_ >= xs_short_min && value_ <= xs_short_max;
 }
 
-bool IntegerImpl::is_xs_unsignedByte() const {
-  static MAPM xs_unsignedByte_max( "256" );
+template<class T>
+bool IntegerImpl<T>::is_xs_unsignedByte() const {
   return value_.sign() >= 0 && value_ <= xs_unsignedByte_max;
 }
 
-bool IntegerImpl::is_xs_unsignedInt() const {
-  static MAPM xs_unsignedInt_max( "4294967295" );
+template<class T>
+bool IntegerImpl<T>::is_xs_unsignedInt() const {
   return value_.sign() >= 0 && value_ <= xs_unsignedInt_max;
 }
 
-bool IntegerImpl::is_xs_unsignedLong() const {
-  static MAPM xs_unsignedLong_max( "18446744073709551615" );
+template<class T>
+bool IntegerImpl<T>::is_xs_unsignedLong() const {
   return value_.sign() >= 0 && value_ <= xs_unsignedLong_max;
 }
 
-bool IntegerImpl::is_xs_unsignedShort() const {
-  static MAPM xs_unsignedShort_max( "65536" );
+template<class T>
+bool IntegerImpl<T>::is_xs_unsignedShort() const {
   return value_.sign() >= 0 && value_ <= xs_unsignedShort_max;
 }
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T) const& INTEGER_IMPL(T)::one() {
-  static INTEGER_IMPL(T) const i(1);
-  return i;
-}
-
-TEMPLATE_DECL(T)
-zstring INTEGER_IMPL(T)::toString() const {
+template<class T>
+zstring IntegerImpl<T>::toString() const {
 #ifdef ZORBA_WITH_BIG_INTEGER
-  unique_ptr<char[]> const buf( new char[ value_.exponent() + 3 ] );
-  value_.toIntegerString( buf.get() );
-  return buf.get();
+  ostringstream oss;
+  oss << value_;
+  return oss.str();
 #else
   ascii::itoa_buf_type buf;
   return ascii::itoa( value_, buf );
 #endif /* ZORBA_WITH_BIG_INTEGER */
 }
 
-TEMPLATE_DECL(T)
-INTEGER_IMPL(T) const& INTEGER_IMPL(T)::zero() {
-  static INTEGER_IMPL(T) const i(0);
-  return i;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef ZORBA_WITH_BIG_INTEGER
-template class IntegerImpl<long long>;
-template class IntegerImpl<unsigned long long>;
-#endif /* ZORBA_WITH_BIG_INTEGER */
+///////////////////////////////////////////////////////////////////////////////
+
+// instantiate integer types
+template class IntegerImpl<integer_traits>;
+template class IntegerImpl<negative_traits>;
+template class IntegerImpl<nonNegative_traits>;
+template class IntegerImpl<nonPositive_traits>;
+template class IntegerImpl<positive_traits>;
+
+///////////////////////////////////////////////////////////////////////////////
 
 } // namespace zorba
 /* vim:set et sw=2 ts=2: */
 
=== modified file 'src/zorbatypes/integer.h'
--- src/zorbatypes/integer.h	2013-02-26 04:12:43 +0000
+++ src/zorbatypes/integer.h	2013-05-08 15:05:31 +0000
@@ -18,60 +18,142 @@
 #ifndef ZORBA_INTEGER_H
 #define ZORBA_INTEGER_H
 
+// standard
 #include <cmath>
 #include <limits>
+#include <string>
 
+// Zorba
 #include <zorba/config.h>
-
 #include "common/common.h"
 #include "util/stl_util.h"
+#include "util/string_util.h"
 
+// local
 #include "m_apm.h"
+#include "numeric_types.h"
 #include "schema_types_base.h"
 #include "zorbatypes_decl.h"
 #include "zstring.h"
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(I)   /* nothing */
-# define INTEGER_IMPL(I)    IntegerImpl
-# define TEMPLATE_TYPENAME  /* nothing */
-#else
-# define TEMPLATE_DECL(I)   template<typename I> /* spacer */
-# define INTEGER_IMPL(I)    IntegerImpl<I> /* spacer */
-# define TEMPLATE_TYPENAME  typename
-#endif /* ZORBA_WITH_BIG_INTEGER */
-#define INTEGER_IMPL_LL   INTEGER_IMPL(long long)
-#define INTEGER_IMPL_ULL  INTEGER_IMPL(unsigned long long)
-
 namespace zorba {
 
-TEMPLATE_DECL(I)
+template<class TraitsType>
 class IntegerImpl;
 
-namespace serialization 
-{
+namespace serialization {
   class Archiver;
-  TEMPLATE_DECL(I) void operator&( Archiver&, INTEGER_IMPL(I)& );
+
+  template<class T>
+  void operator&( Archiver&, IntegerImpl<T>& );
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-TEMPLATE_DECL(IntType)
-class IntegerImpl 
-{
+std::ostream& operator<<( std::ostream&, MAPM const& );
+
+struct integer_traits {
+  static int const default_value = 0;
+
+  template<typename ValueType>
+  static ValueType check_value( ValueType n, bool ) {
+    return n;
+  }
+
+  static MAPM const& check_value( MAPM const &n, bool ) {
+    return n;
+  }
+
+protected:
+  static void throw_error( std::string const&, bool );
+
+  template<typename ValueType>
+  static void throw_error( ValueType n, char const *op,
+                           bool throw_range_error ) {
+    std::string const what( BUILD_STRING( n, ": not ", op, " 0" ) );
+    throw_error( what, throw_range_error );
+  }
+
+  static void throw_error( MAPM const &n, char const *op,
+                           bool throw_range_error );
+};
+
+struct nonPositive_traits : integer_traits {
+  template<typename ValueType>
+  static ValueType check_value( ValueType n, bool throw_range_error ) {
+    if ( !ztd::le0( n ) )
+      throw_error( n, "<=", throw_range_error );
+    return n;
+  }
+  static MAPM const& check_value( MAPM const &n, bool throw_range_error ) {
+    if ( !(n.sign() <= 0) )
+      throw_error( n, "<=", throw_range_error );
+    return n;
+  }
+};
+
+struct negative_traits : nonPositive_traits {
+  static int const default_value = -1;
+
+  template<typename ValueType>
+  static ValueType check_value( ValueType n, bool throw_range_error ) {
+    if ( !ztd::lt0( n ) )
+      throw_error( n, "<", throw_range_error );
+    return n;
+  }
+  static MAPM const& check_value( MAPM const &n, bool throw_range_error ) {
+    if ( !(n.sign() < 0) )
+      throw_error( n, "<", throw_range_error );
+    return n;
+  }
+};
+
+struct nonNegative_traits : integer_traits {
+  template<typename ValueType>
+  static ValueType check_value( ValueType n, bool throw_range_error ) {
+    if ( !ztd::ge0( n ) )
+      throw_error( n, ">=", throw_range_error );
+    return n;
+  }
+  static MAPM const& check_value( MAPM const &n, bool throw_range_error ) {
+    if ( !(n.sign() >= 0) )
+      throw_error( n, ">=", throw_range_error );
+    return n;
+  }
+};
+
+struct positive_traits : nonNegative_traits {
+  static int const default_value = 1;
+
+  template<typename ValueType>
+  static ValueType check_value( ValueType n, bool throw_range_error ) {
+    if ( !ztd::gt0( n ) )
+      throw_error( n, ">", throw_range_error );
+    return n;
+  }
+  static MAPM const& check_value( MAPM const &n, bool throw_range_error ) {
+    if ( !(n.sign() > 0) )
+      throw_error( n, ">", throw_range_error );
+    return n;
+  }
+};
+
+template<class TraitsType>
+class IntegerImpl {
 public:
 #ifdef ZORBA_WITH_BIG_INTEGER
   typedef MAPM value_type;
 #else
-  typedef IntType value_type;
+  typedef long long value_type;
 #endif /* ZORBA_WITH_BIG_INTEGER */
+  typedef TraitsType traits_type;
 
   ////////// constructors /////////////////////////////////////////////////////
 
   explicit IntegerImpl( char c );
   explicit IntegerImpl( signed char c );
   explicit IntegerImpl( short n );
-  explicit IntegerImpl( int n = 0 );
+  explicit IntegerImpl( int n = traits_type::default_value );
   explicit IntegerImpl( long n );
   explicit IntegerImpl( long long n );
   explicit IntegerImpl( unsigned char c );
@@ -112,27 +194,27 @@
   explicit IntegerImpl( Float const &f );
 
   /**
-   * Constructs from another %IntegerImpl even if its \c IntType is different.
-   * (This subsumes the conventional copy constructor.)
+   * Constructs from another %IntegerImpl even if its \c TraitsType is
+   * different.  (This subsumes the conventional copy constructor.)
    *
-   * @tparam IntType2 the integer type of \a i.
+   * @tparam TraitsType2 The traits type of \a i.
    * @param i The %IntegerImpl to copy from.
    */
-  TEMPLATE_DECL(IntType2)
-  IntegerImpl( INTEGER_IMPL(IntType2) const &i );
+  template<class TraitsType2>
+  IntegerImpl( IntegerImpl<TraitsType2> const &i );
 
   ////////// assignment operators /////////////////////////////////////////////
 
   /**
-   * Assign from an %IntegerImpl even if its \c IntType is different.
+   * Assign from an %IntegerImpl even if its \c TraitsType is different.
    * (This subsumes the conventional assignment operator.)
    *
-   * @tparam IntType2 the integer type of \a i.
+   * @tparam TraitsType2 The traits type of \a i.
    * @param i The %IntegerImpl to assign from.
    * @return Returns \c *this.
    */
-  TEMPLATE_DECL(IntType2)
-  IntegerImpl& operator=( INTEGER_IMPL(IntType2) const &i );
+  template<class TraitsType2>
+  IntegerImpl& operator=( IntegerImpl<TraitsType2> const &i );
 
   IntegerImpl& operator=( char c );
   IntegerImpl& operator=( signed char c );
@@ -155,16 +237,15 @@
 
   ////////// arithmetic operators /////////////////////////////////////////////
 
-#define ZORBA_INTEGER_OP(OP)                                      \
-  TEMPLATE_DECL(I) friend                                         \
-  INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const&,            \
-                               INTEGER_IMPL(I) const& );          \
-                                                                  \
-  TEMPLATE_DECL(I) friend                                         \
-  Decimal operator OP( INTEGER_IMPL(I) const&, Decimal const& );  \
-                                                                  \
-  TEMPLATE_DECL(I) friend                                         \
-  Decimal operator OP( Decimal const&, INTEGER_IMPL(I) const& )
+#define ZORBA_INTEGER_OP(OP)                                            \
+  template<class T,class U> friend                                      \
+  Integer operator OP( IntegerImpl<T> const&, IntegerImpl<U> const& );  \
+                                                                        \
+  template<class T> friend                                              \
+  Decimal operator OP( IntegerImpl<T> const&, Decimal const& );         \
+                                                                        \
+  template<class T> friend                                              \
+  Decimal operator OP( Decimal const&, IntegerImpl<T> const& )
 
   ZORBA_INTEGER_OP(+);
   ZORBA_INTEGER_OP(-);
@@ -173,12 +254,12 @@
   ZORBA_INTEGER_OP(%);
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(OP,T)                              \
-  TEMPLATE_DECL(I) friend                                   \
-  INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const&, T ); \
-                                                            \
-  TEMPLATE_DECL(I) friend                                   \
-  INTEGER_IMPL(I) operator OP( T, INTEGER_IMPL(I) const& )
+#define ZORBA_INTEGER_OP(OP,N)                      \
+  template<class T> friend                          \
+  Integer operator OP( IntegerImpl<T> const&, N );  \
+                                                    \
+  template<class T> friend                          \
+  Integer operator OP( N, IntegerImpl<T> const& )
 
   ZORBA_INTEGER_OP(+,char);
   ZORBA_INTEGER_OP(-,char);
@@ -247,19 +328,14 @@
   ZORBA_INTEGER_OP(%,double);
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(OP,TYPE) \
-  IntegerImpl& operator OP( TYPE )
+#define ZORBA_INTEGER_OP(OP,T) \
+  IntegerImpl& operator OP( T )
 
   ZORBA_INTEGER_OP(+=,IntegerImpl const&);
   ZORBA_INTEGER_OP(-=,IntegerImpl const&);
   ZORBA_INTEGER_OP(*=,IntegerImpl const&);
   ZORBA_INTEGER_OP(/=,IntegerImpl const&);
   ZORBA_INTEGER_OP(%=,IntegerImpl const&);
-#undef ZORBA_INTEGER_OP
-
-#define ZORBA_INTEGER_OP(OP,T) \
-  IntegerImpl& operator OP( T )
-
   ZORBA_INTEGER_OP(+=,char);
   ZORBA_INTEGER_OP(-=,char);
   ZORBA_INTEGER_OP(*=,char);
@@ -327,7 +403,7 @@
   ZORBA_INTEGER_OP(%=,double);
 #undef ZORBA_INTEGER_OP
 
-  IntegerImpl operator-() const;
+  Integer operator-() const;
 
   IntegerImpl& operator++();
   IntegerImpl  operator++(int);
@@ -336,107 +412,107 @@
 
   ////////// relational operators /////////////////////////////////////////////
 
-#define ZORBA_INTEGER_OP(OP)                                          \
-  TEMPLATE_DECL(I) friend                                             \
-  bool operator OP( INTEGER_IMPL(I) const&, INTEGER_IMPL(I) const& ); \
-                                                                      \
-  TEMPLATE_DECL(I) friend                                             \
-  bool operator OP( INTEGER_IMPL(I) const&, Decimal const& );         \
-                                                                      \
-  TEMPLATE_DECL(I) friend                                             \
-  bool operator OP( Decimal const&, INTEGER_IMPL(I) const& )
-
-  ZORBA_INTEGER_OP(==);
-  ZORBA_INTEGER_OP(!=);
-  ZORBA_INTEGER_OP(< );
-  ZORBA_INTEGER_OP(<=);
-  ZORBA_INTEGER_OP(> );
-  ZORBA_INTEGER_OP(>=);
-#undef ZORBA_INTEGER_OP
-
-#define ZORBA_INTEGER_OP(OP,T)                                            \
-  TEMPLATE_DECL(I) friend bool operator OP( INTEGER_IMPL(I) const&, T );  \
-  TEMPLATE_DECL(I) friend bool operator OP( T, INTEGER_IMPL(I) const& )
-
-  ZORBA_INTEGER_OP(==,char);
-  ZORBA_INTEGER_OP(!=,char);
-  ZORBA_INTEGER_OP(< ,char);
-  ZORBA_INTEGER_OP(<=,char);
-  ZORBA_INTEGER_OP(> ,char);
-  ZORBA_INTEGER_OP(>=,char);
-  ZORBA_INTEGER_OP(==,signed char);
-  ZORBA_INTEGER_OP(!=,signed char);
-  ZORBA_INTEGER_OP(< ,signed char);
-  ZORBA_INTEGER_OP(<=,signed char);
-  ZORBA_INTEGER_OP(> ,signed char);
-  ZORBA_INTEGER_OP(>=,signed char);
-  ZORBA_INTEGER_OP(==,short);
-  ZORBA_INTEGER_OP(!=,short);
-  ZORBA_INTEGER_OP(< ,short);
-  ZORBA_INTEGER_OP(<=,short);
-  ZORBA_INTEGER_OP(> ,short);
-  ZORBA_INTEGER_OP(>=,short);
-  ZORBA_INTEGER_OP(==,int);
-  ZORBA_INTEGER_OP(!=,int);
-  ZORBA_INTEGER_OP(< ,int);
-  ZORBA_INTEGER_OP(<=,int);
-  ZORBA_INTEGER_OP(> ,int);
-  ZORBA_INTEGER_OP(>=,int);
-  ZORBA_INTEGER_OP(==,long);
-  ZORBA_INTEGER_OP(!=,long);
-  ZORBA_INTEGER_OP(< ,long);
-  ZORBA_INTEGER_OP(<=,long);
-  ZORBA_INTEGER_OP(> ,long);
-  ZORBA_INTEGER_OP(>=,long);
-  ZORBA_INTEGER_OP(==,long long);
-  ZORBA_INTEGER_OP(!=,long long);
-  ZORBA_INTEGER_OP(< ,long long);
-  ZORBA_INTEGER_OP(<=,long long);
-  ZORBA_INTEGER_OP(> ,long long);
-  ZORBA_INTEGER_OP(>=,long long);
-  ZORBA_INTEGER_OP(==,unsigned char);
-  ZORBA_INTEGER_OP(!=,unsigned char);
-  ZORBA_INTEGER_OP(< ,unsigned char);
-  ZORBA_INTEGER_OP(<=,unsigned char);
-  ZORBA_INTEGER_OP(> ,unsigned char);
-  ZORBA_INTEGER_OP(>=,unsigned char);
-  ZORBA_INTEGER_OP(==,unsigned short);
-  ZORBA_INTEGER_OP(!=,unsigned short);
-  ZORBA_INTEGER_OP(< ,unsigned short);
-  ZORBA_INTEGER_OP(<=,unsigned short);
-  ZORBA_INTEGER_OP(> ,unsigned short);
-  ZORBA_INTEGER_OP(>=,unsigned short);
-  ZORBA_INTEGER_OP(==,unsigned int);
-  ZORBA_INTEGER_OP(!=,unsigned int);
-  ZORBA_INTEGER_OP(< ,unsigned int);
-  ZORBA_INTEGER_OP(<=,unsigned int);
-  ZORBA_INTEGER_OP(> ,unsigned int);
-  ZORBA_INTEGER_OP(>=,unsigned int);
-  ZORBA_INTEGER_OP(==,unsigned long);
-  ZORBA_INTEGER_OP(!=,unsigned long);
-  ZORBA_INTEGER_OP(< ,unsigned long);
-  ZORBA_INTEGER_OP(<=,unsigned long);
-  ZORBA_INTEGER_OP(> ,unsigned long);
-  ZORBA_INTEGER_OP(>=,unsigned long);
-  ZORBA_INTEGER_OP(==,unsigned long long);
-  ZORBA_INTEGER_OP(!=,unsigned long long);
-  ZORBA_INTEGER_OP(< ,unsigned long long);
-  ZORBA_INTEGER_OP(<=,unsigned long long);
-  ZORBA_INTEGER_OP(> ,unsigned long long);
-  ZORBA_INTEGER_OP(>=,unsigned long long);
-  ZORBA_INTEGER_OP(==,float);
-  ZORBA_INTEGER_OP(!=,float);
-  ZORBA_INTEGER_OP(< ,float);
-  ZORBA_INTEGER_OP(<=,float);
-  ZORBA_INTEGER_OP(> ,float);
-  ZORBA_INTEGER_OP(>=,float);
-  ZORBA_INTEGER_OP(==,double);
-  ZORBA_INTEGER_OP(!=,double);
-  ZORBA_INTEGER_OP(< ,double);
-  ZORBA_INTEGER_OP(<=,double);
-  ZORBA_INTEGER_OP(> ,double);
-  ZORBA_INTEGER_OP(>=,double);
-#undef ZORBA_INTEGER_OP
+#define ZORBA_REL_OP(OP)                                            \
+  template<class T,class U> friend                                  \
+  bool operator OP( IntegerImpl<T> const&, IntegerImpl<U> const& ); \
+                                                                    \
+  template<class T> friend                                          \
+  bool operator OP( IntegerImpl<T> const&, Decimal const& );        \
+                                                                    \
+  template<class T> friend                                          \
+  bool operator OP( Decimal const&, IntegerImpl<T> const& )
+
+  ZORBA_REL_OP(==);
+  ZORBA_REL_OP(!=);
+  ZORBA_REL_OP(< );
+  ZORBA_REL_OP(<=);
+  ZORBA_REL_OP(> );
+  ZORBA_REL_OP(>=);
+#undef ZORBA_REL_OP
+
+#define ZORBA_REL_OP(OP,N)                                                \
+  template<class T> friend bool operator OP( IntegerImpl<T> const&, N );  \
+  template<class T> friend bool operator OP( N, IntegerImpl<T> const& )
+
+  ZORBA_REL_OP(==,char);
+  ZORBA_REL_OP(!=,char);
+  ZORBA_REL_OP(< ,char);
+  ZORBA_REL_OP(<=,char);
+  ZORBA_REL_OP(> ,char);
+  ZORBA_REL_OP(>=,char);
+  ZORBA_REL_OP(==,signed char);
+  ZORBA_REL_OP(!=,signed char);
+  ZORBA_REL_OP(< ,signed char);
+  ZORBA_REL_OP(<=,signed char);
+  ZORBA_REL_OP(> ,signed char);
+  ZORBA_REL_OP(>=,signed char);
+  ZORBA_REL_OP(==,short);
+  ZORBA_REL_OP(!=,short);
+  ZORBA_REL_OP(< ,short);
+  ZORBA_REL_OP(<=,short);
+  ZORBA_REL_OP(> ,short);
+  ZORBA_REL_OP(>=,short);
+  ZORBA_REL_OP(==,int);
+  ZORBA_REL_OP(!=,int);
+  ZORBA_REL_OP(< ,int);
+  ZORBA_REL_OP(<=,int);
+  ZORBA_REL_OP(> ,int);
+  ZORBA_REL_OP(>=,int);
+  ZORBA_REL_OP(==,long);
+  ZORBA_REL_OP(!=,long);
+  ZORBA_REL_OP(< ,long);
+  ZORBA_REL_OP(<=,long);
+  ZORBA_REL_OP(> ,long);
+  ZORBA_REL_OP(>=,long);
+  ZORBA_REL_OP(==,long long);
+  ZORBA_REL_OP(!=,long long);
+  ZORBA_REL_OP(< ,long long);
+  ZORBA_REL_OP(<=,long long);
+  ZORBA_REL_OP(> ,long long);
+  ZORBA_REL_OP(>=,long long);
+  ZORBA_REL_OP(==,unsigned char);
+  ZORBA_REL_OP(!=,unsigned char);
+  ZORBA_REL_OP(< ,unsigned char);
+  ZORBA_REL_OP(<=,unsigned char);
+  ZORBA_REL_OP(> ,unsigned char);
+  ZORBA_REL_OP(>=,unsigned char);
+  ZORBA_REL_OP(==,unsigned short);
+  ZORBA_REL_OP(!=,unsigned short);
+  ZORBA_REL_OP(< ,unsigned short);
+  ZORBA_REL_OP(<=,unsigned short);
+  ZORBA_REL_OP(> ,unsigned short);
+  ZORBA_REL_OP(>=,unsigned short);
+  ZORBA_REL_OP(==,unsigned int);
+  ZORBA_REL_OP(!=,unsigned int);
+  ZORBA_REL_OP(< ,unsigned int);
+  ZORBA_REL_OP(<=,unsigned int);
+  ZORBA_REL_OP(> ,unsigned int);
+  ZORBA_REL_OP(>=,unsigned int);
+  ZORBA_REL_OP(==,unsigned long);
+  ZORBA_REL_OP(!=,unsigned long);
+  ZORBA_REL_OP(< ,unsigned long);
+  ZORBA_REL_OP(<=,unsigned long);
+  ZORBA_REL_OP(> ,unsigned long);
+  ZORBA_REL_OP(>=,unsigned long);
+  ZORBA_REL_OP(==,unsigned long long);
+  ZORBA_REL_OP(!=,unsigned long long);
+  ZORBA_REL_OP(< ,unsigned long long);
+  ZORBA_REL_OP(<=,unsigned long long);
+  ZORBA_REL_OP(> ,unsigned long long);
+  ZORBA_REL_OP(>=,unsigned long long);
+  ZORBA_REL_OP(==,float);
+  ZORBA_REL_OP(!=,float);
+  ZORBA_REL_OP(< ,float);
+  ZORBA_REL_OP(<=,float);
+  ZORBA_REL_OP(> ,float);
+  ZORBA_REL_OP(>=,float);
+  ZORBA_REL_OP(==,double);
+  ZORBA_REL_OP(!=,double);
+  ZORBA_REL_OP(< ,double);
+  ZORBA_REL_OP(<=,double);
+  ZORBA_REL_OP(> ,double);
+  ZORBA_REL_OP(>=,double);
+#undef ZORBA_REL_OP
 
   ////////// math functions ///////////////////////////////////////////////////
 
@@ -464,8 +540,6 @@
   zstring toString() const;
   value_type& value();
   value_type const& value() const;
-  static IntegerImpl const& one();
-  static IntegerImpl const& zero();
 
   /////////////////////////////////////////////////////////////////////////////
 
@@ -473,20 +547,18 @@
 #ifdef ZORBA_WITH_BIG_INTEGER
   typedef long int_cast_type;
 #else
-  typedef IntType int_cast_type;
+  typedef value_type int_cast_type;
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
   value_type value_;
 
-#ifdef ZORBA_WITH_BIG_INTEGER
-  IntegerImpl( value_type const &v ) : value_( v ) { }
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
   static value_type ftoi( double d ) {
     return value_type( d >= 0 ? floor( d ) : ceil( d ) );
   }
 
 #ifdef ZORBA_WITH_BIG_INTEGER
+  IntegerImpl( value_type const &v ) : value_( v ) { }
+
   static value_type ftoi( MAPM const &d ) {
     return d.sign() >= 0 ? d.floor() : d.ceil();
   }
@@ -499,7 +571,6 @@
   static value_type make_value_type( T n ) {
     return value_type( static_cast<int_cast_type>( n ) );
   }
-
 #else /* ZORBA_WITH_BIG_INTEGER */
 
   static value_type ftoi( value_type v ) {
@@ -516,148 +587,149 @@
   }
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-  void parse( char const *s );
+  void parse( char const *s, bool throw_range_error );
 
   friend class Decimal;
-  template<typename T> friend class FloatImpl;
-
-#ifndef ZORBA_WITH_BIG_INTEGER
-  template<typename T> friend class IntegerImpl;
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
-  friend xs_int to_xs_int( INTEGER_IMPL_LL const& );
-  friend xs_long to_xs_long( INTEGER_IMPL_LL const& );
-  friend xs_unsignedByte to_xs_unsignedByte( INTEGER_IMPL_LL const& );
-  friend xs_unsignedShort to_xs_unsignedShort( INTEGER_IMPL_LL const& );
-  friend xs_unsignedInt to_xs_unsignedInt( INTEGER_IMPL_LL const& );
-  friend xs_unsignedLong to_xs_unsignedLong( INTEGER_IMPL_LL const& );
-
-  TEMPLATE_DECL(I) friend
-  void serialization::operator&( serialization::Archiver&, INTEGER_IMPL(I)& );
+  template<typename F> friend class FloatImpl;
+  template<class T> friend class IntegerImpl;
+
+  friend xs_int to_xs_int( Integer const& );
+  friend xs_long to_xs_long( Integer const& );
+  friend xs_unsignedByte to_xs_unsignedByte( Integer const& );
+  friend xs_unsignedShort to_xs_unsignedShort( Integer const& );
+  friend xs_unsignedInt to_xs_unsignedInt( Integer const& );
+  friend xs_unsignedLong to_xs_unsignedLong( Integer const& );
+
+  template<class T> friend
+  void serialization::operator&( serialization::Archiver&, IntegerImpl<T>& );
 };
 
-typedef INTEGER_IMPL_LL Integer;
-typedef INTEGER_IMPL_ULL UInteger;
+typedef IntegerImpl<integer_traits>     Integer;
+typedef IntegerImpl<negative_traits>    NegativeInteger;
+typedef IntegerImpl<nonNegative_traits> NonNegativeInteger;
+typedef IntegerImpl<nonPositive_traits> NonPositiveInteger;
+typedef IntegerImpl<positive_traits>    PositiveInteger;
 
 ////////// constructors ///////////////////////////////////////////////////////
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( char c ) :
-  value_( static_cast<long>( c ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( signed char c ) :
-  value_( static_cast<long>( c ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( short n ) :
-  value_( static_cast<long>( n ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( int n ) :
-  value_( static_cast<long>( n ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( long n ) :
-  value_( n )
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( char c ) :
+  value_( static_cast<long>( T::check_value( c, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( signed char c ) :
+  value_( static_cast<long>( T::check_value( c, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( short n ) :
+  value_( static_cast<long>( T::check_value( n, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( int n ) :
+  value_( static_cast<long>( T::check_value( n, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( long n ) :
+  value_( T::check_value( n, false ) )
 {
 }
 
 #ifndef ZORBA_WITH_BIG_INTEGER
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( long long n ) :
-  value_( n )
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( long long n ) :
+  value_( T::check_value( n, false ) )
 {
 }
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( unsigned char c ) :
-  value_( static_cast<long>( (unsigned long)c ) )
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned char c ) :
+  value_( static_cast<long>( (unsigned long)T::check_value( c, false ) ) )
 {
 }
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( unsigned short n ) :
-  value_( static_cast<long>( (unsigned long)n ) )
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned short n ) :
+  value_( static_cast<long>( (unsigned long)T::check_value( n, false ) ) )
 {
 }
 
 #ifdef ZORBA_WITH_BIG_INTEGER
 #if ZORBA_SIZEOF_INT != ZORBA_SIZEOF_LONG
-TEMPLATE_DECL(T)
-inline INTEGER_IMPL(T)::IntegerImpl( unsigned int n ) :
-  value_( static_cast<long>( (unsigned long)n ) )
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned int n ) :
+  value_( static_cast<long>( (unsigned long)T::check_value( n, false ) ) )
 {
 }
 #endif /* ZORBA_SIZEOF_INT == ZORBA_SIZEOF_LONG */
 #else /* ZORBA_WITH_BIG_INTEGER */
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( unsigned int n ) :
-  value_( static_cast<value_type>( n ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( unsigned long n ) :
-  value_( static_cast<value_type>( n ) )
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( unsigned long long n ) :
-  value_( static_cast<value_type>( n ) )
-{
-}
-#endif /* ZORBA_WITH_BIG_INTEGER */
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( float n ) :
-#ifdef ZORBA_WITH_BIG_INTEGER
-  value_( static_cast<double>( n ) )
-#else
-  value_( static_cast<value_type>( n ) )
-#endif /* ZORBA_WITH_BIG_INTEGER */
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( double n ) :
-#ifdef ZORBA_WITH_BIG_INTEGER
-  value_( n )
-#else
-  value_( static_cast<value_type>( n ) )
-#endif /* ZORBA_WITH_BIG_INTEGER */
-{
-}
-
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)::IntegerImpl( char const *s ) {
-  parse( s );
-}
-
-TEMPLATE_DECL(I)
-TEMPLATE_DECL(J)
-inline INTEGER_IMPL(I)::IntegerImpl( INTEGER_IMPL(J) const &i ) :
-  value_( i.value_ )
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned int n ) :
+  value_( static_cast<value_type>( T::check_value( n, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned long n ) :
+  value_( static_cast<value_type>( T::check_value( n, false ) ) )
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( unsigned long long n ) :
+  value_( static_cast<value_type>( T::check_value( n, false ) ) )
+{
+}
+#endif /* ZORBA_WITH_BIG_INTEGER */
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( float n ) :
+#ifdef ZORBA_WITH_BIG_INTEGER
+  value_( static_cast<double>( T::check_value( n, false ) ) )
+#else
+  value_( static_cast<value_type>( T::check_value( n, false ) ) )
+#endif /* ZORBA_WITH_BIG_INTEGER */
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( double n ) :
+#ifdef ZORBA_WITH_BIG_INTEGER
+  value_( T::check_value( n, false ) )
+#else
+  value_( static_cast<value_type>( T::check_value( n, false ) ) )
+#endif /* ZORBA_WITH_BIG_INTEGER */
+{
+}
+
+template<class T>
+inline IntegerImpl<T>::IntegerImpl( char const *s ) {
+  parse( s, false );
+}
+
+template<class T>
+template<class U>
+inline IntegerImpl<T>::IntegerImpl( IntegerImpl<U> const &i ) :
+  value_( T::check_value( i.value_, false ) )
 {
 }
 
 ////////// assignment operators ///////////////////////////////////////////////
 
-#define ZORBA_ASSIGN_OP(T)                              \
-  TEMPLATE_DECL(I) inline                               \
-  INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator=( T n ) {  \
-    value_ = static_cast<int_cast_type>( n );           \
-    return *this;                                       \
+#define ZORBA_ASSIGN_OP(N)                                              \
+  template<class T> inline                                              \
+  IntegerImpl<T>& IntegerImpl<T>::operator=( N n ) {                    \
+    value_ = static_cast<int_cast_type>( T::check_value( n, false ) );  \
+    return *this;                                                       \
   }
 
 ZORBA_ASSIGN_OP(char)
@@ -677,25 +749,25 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 #undef ZORBA_ASSIGN_OP
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator=( char const *s ) {
-  parse( s );
+template<class T>
+inline IntegerImpl<T>& IntegerImpl<T>::operator=( char const *s ) {
+  parse( s, false );
   return *this;
 }
 
-TEMPLATE_DECL(I) TEMPLATE_DECL(J)
-inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator=( INTEGER_IMPL(J) const &i ) {
-  value_ = i.value_;
+template<class T>
+template<class U>
+inline IntegerImpl<T>& IntegerImpl<T>::operator=( IntegerImpl<U> const &i ) {
+  T::check_value( value_ = i.value_, false );
   return *this;
 }
 
 ////////// arithmetic operators ///////////////////////////////////////////////
 
-#define ZORBA_INTEGER_OP(OP)                                \
-  TEMPLATE_DECL(I) inline                                   \
-  INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const &i,    \
-                               INTEGER_IMPL(I) const &j ) { \
-    return INTEGER_IMPL(I)( i.value_ OP j.value_ );         \
+#define ZORBA_INTEGER_OP(OP)                                                \
+  template<class T,class U> inline                                          \
+  Integer operator OP( IntegerImpl<T> const &i, IntegerImpl<U> const &j ) { \
+    return Integer( i.value_ OP j.value_ );                                 \
   }
 
 ZORBA_INTEGER_OP(+)
@@ -704,21 +776,20 @@
 ZORBA_INTEGER_OP(%)
 #undef ZORBA_INTEGER_OP
 
-TEMPLATE_DECL(I) inline
-INTEGER_IMPL(I) operator/( INTEGER_IMPL(I) const &i,
-                           INTEGER_IMPL(I) const &j ) {
-  return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( i.value_ / j.value_ ) );
+template<class T,class U>
+inline Integer operator/( IntegerImpl<T> const &i, IntegerImpl<U> const &j ) {
+  return Integer( Integer::ftoi( i.value_ / j.value_ ) );
 }
 
-#define ZORBA_INTEGER_OP(OP,T)                                    \
-  TEMPLATE_DECL(I) inline                                         \
-  INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const &i, T n ) {  \
-    return INTEGER_IMPL(I)( i.value_ OP INTEGER_IMPL(I)::make_value_type( n ) ); \
+#define ZORBA_INTEGER_OP(OP,N)                                    \
+  template<class T> inline                                        \
+  Integer operator OP( IntegerImpl<T> const &i, N n ) {           \
+    return Integer( i.value_ OP Integer::make_value_type( n ) );  \
   }                                                               \
                                                                   \
-  TEMPLATE_DECL(I) inline                                         \
-  INTEGER_IMPL(I) operator OP( T n, INTEGER_IMPL(I) const &i ) {  \
-    return INTEGER_IMPL(I)( INTEGER_IMPL(I)::make_value_type( n ) OP i.value_ ); \
+  template<class T> inline                                        \
+  Integer operator OP( N n, IntegerImpl<T> const &i ) {           \
+    return Integer( Integer::make_value_type( n ) OP i.value_ );  \
   }
 
 ZORBA_INTEGER_OP(+,char)
@@ -777,15 +848,15 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(T)                                     \
-  TEMPLATE_DECL(I) inline                                       \
-  INTEGER_IMPL(I) operator/( INTEGER_IMPL(I) const &i, T n ) {  \
-    return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( i.value_ / INTEGER_IMPL(I)::make_value_type( n ) ) ); \
-  }                                                             \
-                                                                \
-  TEMPLATE_DECL(I) inline                                       \
-  INTEGER_IMPL(I) operator/( T n, INTEGER_IMPL(I) const &i ) {  \
-    return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( INTEGER_IMPL(I)::make_value_type( n ) / i.value_ ) ); \
+#define ZORBA_INTEGER_OP(N)                           \
+  template<class T> inline                            \
+  Integer operator/( IntegerImpl<T> const &i, N n ) { \
+    return Integer( Integer::ftoi( i.value_ / Integer::make_value_type( n ) ) ); \
+  }                                                   \
+                                                      \
+  template<class T> inline                            \
+  Integer operator/( N n, IntegerImpl<T> const &i ) { \
+    return Integer( Integer::ftoi( Integer::make_value_type( n ) / i.value_ ) ); \
   }
 
 ZORBA_INTEGER_OP(signed char)
@@ -805,11 +876,11 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(OP)                                              \
-  TEMPLATE_DECL(I) inline                                                 \
-  INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator OP( IntegerImpl const &i ) { \
-    value_ OP i.value_;                                                   \
-    return *this;                                                         \
+#define ZORBA_INTEGER_OP(OP)                                                \
+  template<class T> inline                                                  \
+  IntegerImpl<T>& IntegerImpl<T>::operator OP( IntegerImpl<T> const &i ) {  \
+    T::check_value( value_ OP i.value_, true );                             \
+    return *this;                                                           \
   }
 
 ZORBA_INTEGER_OP(+=)
@@ -818,17 +889,17 @@
 ZORBA_INTEGER_OP(%=)
 #undef ZORBA_INTEGER_OP
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator/=( IntegerImpl const &i ) {
-  value_ = ftoi( value_ / i.value_ );
+template<class T>
+inline IntegerImpl<T>& IntegerImpl<T>::operator/=( IntegerImpl<T> const &i ) {
+  value_ = T::check_value( ftoi( value_ / i.value_ ), true );
   return *this;
 }
 
-#define ZORBA_INTEGER_OP(OP,T)                            \
-  TEMPLATE_DECL(I) inline                                 \
-  INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator OP( T n ) {  \
-    value_ OP make_value_type( n );                       \
-    return *this;                                         \
+#define ZORBA_INTEGER_OP(OP,N)                              \
+  template<class T> inline                                  \
+  IntegerImpl<T>& IntegerImpl<T>::operator OP( N n ) {      \
+    T::check_value( value_ OP make_value_type( n ), true ); \
+    return *this;                                           \
   }
 
 ZORBA_INTEGER_OP(+=,char)
@@ -887,11 +958,11 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 #undef ZORBA_INTEGER_OP
 
-#define ZORBA_INTEGER_OP(T)                             \
-  TEMPLATE_DECL(I) inline                               \
-  INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator/=( T n ) { \
-    value_ = ftoi( value_ / make_value_type( n ) );     \
-    return *this;                                       \
+#define ZORBA_INTEGER_OP(N)                                                 \
+  template<class T> inline                                                  \
+  IntegerImpl<T>& IntegerImpl<T>::operator/=( N n ) {                       \
+    value_ = T::check_value( ftoi( value_ / make_value_type( n ) ), true ); \
+    return *this;                                                           \
   }
 
 ZORBA_INTEGER_OP(char)
@@ -911,243 +982,247 @@
 #endif /* ZORBA_WITH_BIG_INTEGER */
 #undef ZORBA_INTEGER_OP
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I) INTEGER_IMPL(I)::operator-() const {
-  return INTEGER_IMPL(I)( -value_ );
+template<class T>
+inline Integer IntegerImpl<T>::operator-() const {
+  return Integer( -value_ );
 }
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator++() {
-  ++value_;
+template<class T>
+inline IntegerImpl<T>& IntegerImpl<T>::operator++() {
+  T::check_value( ++value_, true );
   return *this;
 }
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I) INTEGER_IMPL(I)::operator++(int) {
-  INTEGER_IMPL(I) const result( *this );
-  ++value_;
+template<class T>
+inline IntegerImpl<T> IntegerImpl<T>::operator++(int) {
+  IntegerImpl<T> const result( *this );
+  T::check_value( ++value_, true );
   return result;
 }
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator--() {
-  --value_;
+template<class T>
+inline IntegerImpl<T>& IntegerImpl<T>::operator--() {
+  T::check_value( --value_, true );
   return *this;
 }
 
-TEMPLATE_DECL(I)
-inline INTEGER_IMPL(I) INTEGER_IMPL(I)::operator--(int) {
-  INTEGER_IMPL(I) const result( *this );
-  --value_;
+template<class T>
+inline IntegerImpl<T> IntegerImpl<T>::operator--(int) {
+  IntegerImpl<T> const result( *this );
+  T::check_value( --value_, true );
   return result;
 }
 
 ////////// relational operators ///////////////////////////////////////////////
 
-#define ZORBA_INTEGER_OP(OP)                                                \
-  TEMPLATE_DECL(I) inline                                                   \
-  bool operator OP( INTEGER_IMPL(I) const &i, INTEGER_IMPL(I) const &j ) {  \
-    return i.value_ OP j.value_;                                            \
+#define ZORBA_REL_OP(OP)                                                  \
+  template<class T,class U> inline                                        \
+  bool operator OP( IntegerImpl<T> const &i, IntegerImpl<U> const &j ) {  \
+    return i.value_ OP j.value_;                                          \
   }
 
-ZORBA_INTEGER_OP(==)
-ZORBA_INTEGER_OP(!=)
-ZORBA_INTEGER_OP(< )
-ZORBA_INTEGER_OP(<=)
-ZORBA_INTEGER_OP(> )
-ZORBA_INTEGER_OP(>=)
-#undef ZORBA_INTEGER_OP
+ZORBA_REL_OP(==)
+ZORBA_REL_OP(!=)
+ZORBA_REL_OP(< )
+ZORBA_REL_OP(<=)
+ZORBA_REL_OP(> )
+ZORBA_REL_OP(>=)
+#undef ZORBA_REL_OP
 
-#define ZORBA_INTEGER_OP(OP,T)                                \
-  TEMPLATE_DECL(I) inline                                     \
-  bool operator OP( INTEGER_IMPL(I) const &i, T n ) {         \
-    return i.value_ OP INTEGER_IMPL(I)::make_value_type( n ); \
+#define ZORBA_REL_OP(OP,N)                                    \
+  template<class T> inline                                    \
+  bool operator OP( IntegerImpl<T> const &i, N n ) {          \
+    return i.value_ OP IntegerImpl<T>::make_value_type( n );  \
   }                                                           \
                                                               \
-  TEMPLATE_DECL(I) inline                                     \
-  bool operator OP( T n, INTEGER_IMPL(I) const &i ) {         \
-    return INTEGER_IMPL(I)::make_value_type( n ) OP i.value_; \
+  template<class T> inline                                    \
+  bool operator OP( N n, IntegerImpl<T> const &i ) {          \
+    return IntegerImpl<T>::make_value_type( n ) OP i.value_;  \
   }
 
-ZORBA_INTEGER_OP(==,char)
-ZORBA_INTEGER_OP(!=,char)
-ZORBA_INTEGER_OP(< ,char)
-ZORBA_INTEGER_OP(<=,char)
-ZORBA_INTEGER_OP(> ,char)
-ZORBA_INTEGER_OP(>=,char)
-ZORBA_INTEGER_OP(==,signed char)
-ZORBA_INTEGER_OP(!=,signed char)
-ZORBA_INTEGER_OP(< ,signed char)
-ZORBA_INTEGER_OP(<=,signed char)
-ZORBA_INTEGER_OP(> ,signed char)
-ZORBA_INTEGER_OP(>=,signed char)
-ZORBA_INTEGER_OP(==,short)
-ZORBA_INTEGER_OP(!=,short)
-ZORBA_INTEGER_OP(< ,short)
-ZORBA_INTEGER_OP(<=,short)
-ZORBA_INTEGER_OP(> ,short)
-ZORBA_INTEGER_OP(>=,short)
-ZORBA_INTEGER_OP(==,int)
-ZORBA_INTEGER_OP(!=,int)
-ZORBA_INTEGER_OP(< ,int)
-ZORBA_INTEGER_OP(<=,int)
-ZORBA_INTEGER_OP(> ,int)
-ZORBA_INTEGER_OP(>=,int)
-ZORBA_INTEGER_OP(==,long)
-ZORBA_INTEGER_OP(!=,long)
-ZORBA_INTEGER_OP(< ,long)
-ZORBA_INTEGER_OP(<=,long)
-ZORBA_INTEGER_OP(> ,long)
-ZORBA_INTEGER_OP(>=,long)
-ZORBA_INTEGER_OP(==,unsigned char)
-ZORBA_INTEGER_OP(!=,unsigned char)
-ZORBA_INTEGER_OP(< ,unsigned char)
-ZORBA_INTEGER_OP(<=,unsigned char)
-ZORBA_INTEGER_OP(> ,unsigned char)
-ZORBA_INTEGER_OP(>=,unsigned char)
-ZORBA_INTEGER_OP(==,unsigned short)
-ZORBA_INTEGER_OP(!=,unsigned short)
-ZORBA_INTEGER_OP(< ,unsigned short)
-ZORBA_INTEGER_OP(<=,unsigned short)
-ZORBA_INTEGER_OP(> ,unsigned short)
-ZORBA_INTEGER_OP(>=,unsigned short)
-ZORBA_INTEGER_OP(==,unsigned int)
-ZORBA_INTEGER_OP(!=,unsigned int)
-ZORBA_INTEGER_OP(< ,unsigned int)
-ZORBA_INTEGER_OP(<=,unsigned int)
-ZORBA_INTEGER_OP(> ,unsigned int)
-ZORBA_INTEGER_OP(>=,unsigned int)
-ZORBA_INTEGER_OP(==,float)
-ZORBA_INTEGER_OP(!=,float)
-ZORBA_INTEGER_OP(< ,float)
-ZORBA_INTEGER_OP(<=,float)
-ZORBA_INTEGER_OP(> ,float)
-ZORBA_INTEGER_OP(>=,float)
-ZORBA_INTEGER_OP(==,double)
-ZORBA_INTEGER_OP(!=,double)
-ZORBA_INTEGER_OP(< ,double)
-ZORBA_INTEGER_OP(<=,double)
-ZORBA_INTEGER_OP(> ,double)
-ZORBA_INTEGER_OP(>=,double)
+ZORBA_REL_OP(==,char)
+ZORBA_REL_OP(!=,char)
+ZORBA_REL_OP(< ,char)
+ZORBA_REL_OP(<=,char)
+ZORBA_REL_OP(> ,char)
+ZORBA_REL_OP(>=,char)
+ZORBA_REL_OP(==,signed char)
+ZORBA_REL_OP(!=,signed char)
+ZORBA_REL_OP(< ,signed char)
+ZORBA_REL_OP(<=,signed char)
+ZORBA_REL_OP(> ,signed char)
+ZORBA_REL_OP(>=,signed char)
+ZORBA_REL_OP(==,short)
+ZORBA_REL_OP(!=,short)
+ZORBA_REL_OP(< ,short)
+ZORBA_REL_OP(<=,short)
+ZORBA_REL_OP(> ,short)
+ZORBA_REL_OP(>=,short)
+ZORBA_REL_OP(==,int)
+ZORBA_REL_OP(!=,int)
+ZORBA_REL_OP(< ,int)
+ZORBA_REL_OP(<=,int)
+ZORBA_REL_OP(> ,int)
+ZORBA_REL_OP(>=,int)
+ZORBA_REL_OP(==,long)
+ZORBA_REL_OP(!=,long)
+ZORBA_REL_OP(< ,long)
+ZORBA_REL_OP(<=,long)
+ZORBA_REL_OP(> ,long)
+ZORBA_REL_OP(>=,long)
+ZORBA_REL_OP(==,unsigned char)
+ZORBA_REL_OP(!=,unsigned char)
+ZORBA_REL_OP(< ,unsigned char)
+ZORBA_REL_OP(<=,unsigned char)
+ZORBA_REL_OP(> ,unsigned char)
+ZORBA_REL_OP(>=,unsigned char)
+ZORBA_REL_OP(==,unsigned short)
+ZORBA_REL_OP(!=,unsigned short)
+ZORBA_REL_OP(< ,unsigned short)
+ZORBA_REL_OP(<=,unsigned short)
+ZORBA_REL_OP(> ,unsigned short)
+ZORBA_REL_OP(>=,unsigned short)
+ZORBA_REL_OP(==,unsigned int)
+ZORBA_REL_OP(!=,unsigned int)
+ZORBA_REL_OP(< ,unsigned int)
+ZORBA_REL_OP(<=,unsigned int)
+ZORBA_REL_OP(> ,unsigned int)
+ZORBA_REL_OP(>=,unsigned int)
+ZORBA_REL_OP(==,float)
+ZORBA_REL_OP(!=,float)
+ZORBA_REL_OP(< ,float)
+ZORBA_REL_OP(<=,float)
+ZORBA_REL_OP(> ,float)
+ZORBA_REL_OP(>=,float)
+ZORBA_REL_OP(==,double)
+ZORBA_REL_OP(!=,double)
+ZORBA_REL_OP(< ,double)
+ZORBA_REL_OP(<=,double)
+ZORBA_REL_OP(> ,double)
+ZORBA_REL_OP(>=,double)
 #ifndef ZORBA_WITH_BIG_INTEGER
-ZORBA_INTEGER_OP(==,long long)
-ZORBA_INTEGER_OP(!=,long long)
-ZORBA_INTEGER_OP(< ,long long)
-ZORBA_INTEGER_OP(<=,long long)
-ZORBA_INTEGER_OP(> ,long long)
-ZORBA_INTEGER_OP(>=,long long)
-ZORBA_INTEGER_OP(==,unsigned long)
-ZORBA_INTEGER_OP(!=,unsigned long)
-ZORBA_INTEGER_OP(< ,unsigned long)
-ZORBA_INTEGER_OP(<=,unsigned long)
-ZORBA_INTEGER_OP(> ,unsigned long)
-ZORBA_INTEGER_OP(>=,unsigned long)
-ZORBA_INTEGER_OP(==,unsigned long long)
-ZORBA_INTEGER_OP(!=,unsigned long long)
-ZORBA_INTEGER_OP(< ,unsigned long long)
-ZORBA_INTEGER_OP(<=,unsigned long long)
-ZORBA_INTEGER_OP(> ,unsigned long long)
-ZORBA_INTEGER_OP(>=,unsigned long long)
+ZORBA_REL_OP(==,long long)
+ZORBA_REL_OP(!=,long long)
+ZORBA_REL_OP(< ,long long)
+ZORBA_REL_OP(<=,long long)
+ZORBA_REL_OP(> ,long long)
+ZORBA_REL_OP(>=,long long)
+ZORBA_REL_OP(==,unsigned long)
+ZORBA_REL_OP(!=,unsigned long)
+ZORBA_REL_OP(< ,unsigned long)
+ZORBA_REL_OP(<=,unsigned long)
+ZORBA_REL_OP(> ,unsigned long)
+ZORBA_REL_OP(>=,unsigned long)
+ZORBA_REL_OP(==,unsigned long long)
+ZORBA_REL_OP(!=,unsigned long long)
+ZORBA_REL_OP(< ,unsigned long long)
+ZORBA_REL_OP(<=,unsigned long long)
+ZORBA_REL_OP(> ,unsigned long long)
+ZORBA_REL_OP(>=,unsigned long long)
 #endif /* ZORBA_WITH_BIG_INTEGER */
-#undef ZORBA_INTEGER_OP
+#undef ZORBA_REL_OP
 
 ////////// miscellaneous //////////////////////////////////////////////////////
 
 #ifdef ZORBA_WITH_BIG_INTEGER
 
-inline int IntegerImpl::compare( IntegerImpl const &i ) const {
+template<class T>
+inline int IntegerImpl<T>::compare( IntegerImpl<T> const &i ) const {
   return value_.compare( i.value_ );
 }
 
-inline bool IntegerImpl::is_xs_int() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_int() const {
   return value_ >= MAPM::getMinInt32() && value_ <= MAPM::getMaxInt32();
 }
 
-inline bool IntegerImpl::is_xs_long() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_long() const {
   return value_ >= MAPM::getMinInt64() && value_ <= MAPM::getMaxInt64();
 }
 
-inline int IntegerImpl::sign() const {
+template<class T>
+inline int IntegerImpl<T>::sign() const {
   return value_.sign();
 }
 
 #else /* ZORBA_WITH_BIG_INTEGER */
 
-template<typename I>
-inline int IntegerImpl<I>::compare( IntegerImpl const &i ) const {
+template<class T>
+inline int IntegerImpl<T>::compare( IntegerImpl<T> const &i ) const {
   return value_ < i.value_ ? -1 : value_ > i.value_ ? 1 : 0;
 }
 
-template<typename I>
-inline uint32_t IntegerImpl<I>::hash() const {
+template<class T>
+inline uint32_t IntegerImpl<T>::hash() const {
   return static_cast<uint32_t>( value_ );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_cxx_long() const {
+template<class T>
+inline bool IntegerImpl<T>::is_cxx_long() const {
   return ZORBA_IN_RANGE( value_, long );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_byte() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_byte() const {
   return ZORBA_IN_RANGE( value_, xs_byte );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_int() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_int() const {
   return ZORBA_IN_RANGE( value_, xs_int );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_long() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_long() const {
   return ZORBA_IN_RANGE( value_, xs_long );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_short() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_short() const {
   return ZORBA_IN_RANGE( value_, xs_short );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_unsignedByte() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_unsignedByte() const {
   return ZORBA_IN_RANGE( value_, xs_unsignedByte );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_unsignedInt() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_unsignedInt() const {
   return ZORBA_IN_RANGE( value_, xs_unsignedInt );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_unsignedLong() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_unsignedLong() const {
   return ZORBA_IN_RANGE( value_, xs_unsignedLong );
 }
 
-template<typename I>
-inline bool IntegerImpl<I>::is_xs_unsignedShort() const {
+template<class T>
+inline bool IntegerImpl<T>::is_xs_unsignedShort() const {
   return ZORBA_IN_RANGE( value_, xs_unsignedShort );
 }
 
-template<typename I>
-inline int IntegerImpl<I>::sign() const {
+template<class T>
+inline int IntegerImpl<T>::sign() const {
   return ztd::lt0( value_ ) ? -1 : value_ > 0 ? 1 : 0;
 }
 
 #endif /* ZORBA_WITH_BIG_INTEGER */
 
-TEMPLATE_DECL(I) inline
-TEMPLATE_TYPENAME INTEGER_IMPL(I)::value_type& INTEGER_IMPL(I)::value() {
-  return value_;
-}
-
-TEMPLATE_DECL(I) inline
-TEMPLATE_TYPENAME INTEGER_IMPL(I)::value_type const&
-INTEGER_IMPL(I)::value() const {
-  return value_;
-}
-
-TEMPLATE_DECL(I)
-inline std::ostream& operator<<( std::ostream &os, INTEGER_IMPL(I) const &i ) {
+template<class T>
+inline typename IntegerImpl<T>::value_type& IntegerImpl<T>::value() {
+  return value_;
+}
+
+template<class T>
+inline typename IntegerImpl<T>::value_type const&
+IntegerImpl<T>::value() const {
+  return value_;
+}
+
+template<class T>
+inline std::ostream& operator<<( std::ostream &os, IntegerImpl<T> const &i ) {
   return os << i.toString();
 }
 
@@ -1155,11 +1230,6 @@
 
 } // namespace zorba
 
-#undef TEMPLATE_DECL
-#undef INTEGER_IMPL
-#undef INTEGER_IMPL_LL
-#undef INTEGER_IMPL_ULL
-
 #endif // ZORBA_INTEGER_H
 /*
  * Local variables:
 
=== modified file 'src/zorbatypes/numconversions.cpp'
--- src/zorbatypes/numconversions.cpp	2013-03-22 19:06:44 +0000
+++ src/zorbatypes/numconversions.cpp	2013-05-08 15:05:31 +0000
@@ -15,11 +15,18 @@
  */
 #include "stdafx.h"
 
+// standard
 #include <stdexcept>
 
+// Zorba
 #include "common/common.h"
 #include "util/string_util.h"
-#include "zorbatypes/numconversions.h"
+
+// local
+#include "decimal.h"
+#include "floatimpl.h"
+#include "integer.h"
+#include "numconversions.h"
 
 namespace zorba {
 
 
=== modified file 'src/zorbatypes/numconversions.h'
--- src/zorbatypes/numconversions.h	2013-03-22 19:06:44 +0000
+++ src/zorbatypes/numconversions.h	2013-05-08 15:05:31 +0000
@@ -64,6 +64,7 @@
  */
 xs_long to_xs_long( xs_integer const &i );
 
+#if 0
 #ifndef ZORBA_WITH_BIG_INTEGER
 /**
  * Converts an \c xs:nonNegativeInteger value to an \c xs:long.
@@ -75,6 +76,7 @@
  */
 xs_long to_xs_long( xs_nonNegativeInteger const &i );
 #endif /* ZORBA_WITH_BIG_INTEGER */
+#endif
 
 /**
  * Converts an \c xs:integer value to an \c xs:unsignedByte.
 
=== added file 'src/zorbatypes/numeric_types.cpp'
--- src/zorbatypes/numeric_types.cpp	1970-01-01 00:00:00 +0000
+++ src/zorbatypes/numeric_types.cpp	2013-05-08 15:05:31 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "stdafx.h"
+
+// local
+#include "decimal.h"
+#include "floatimpl.h"
+#include "integer.h"
+
+using namespace std;
+
+namespace zorba {
+
+///////////////////////////////////////////////////////////////////////////////
+
+template<class NumericType>
+NumericType const& numeric_consts<NumericType>::zero() {
+  static NumericType const n(0);
+  return n;
+}
+
+template<class NumericType>
+NumericType const& numeric_consts<NumericType>::one() {
+  static NumericType const n(1);
+  return n;
+}
+
+template<class NumericType>
+NumericType const& numeric_consts<NumericType>::neg_one() {
+  static NumericType const n(-1);
+  return n;
+}
+
+// instantiate non-special cases
+template class numeric_consts<Decimal>;
+template class numeric_consts<Double>;
+template class numeric_consts<Float>;
+template class numeric_consts<Integer>;
+
+NonNegativeInteger const& numeric_consts<NonNegativeInteger>::zero() {
+  static NonNegativeInteger const n(0);
+  return n;
+}
+
+NonNegativeInteger const& numeric_consts<NonNegativeInteger>::one() {
+  static NonNegativeInteger const n(1);
+  return n;
+}
+
+NonPositiveInteger const& numeric_consts<NonPositiveInteger>::zero() {
+  static NonPositiveInteger const n(0);
+  return n;
+}
+
+NonPositiveInteger const& numeric_consts<NonPositiveInteger>::neg_one() {
+  static NonPositiveInteger const n(-1);
+  return n;
+}
+
+PositiveInteger const& numeric_consts<PositiveInteger>::one() {
+  static PositiveInteger const n(1);
+  return n;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace zorba
+/* vim:set et sw=2 ts=2: */
 
=== added file 'src/zorbatypes/numeric_types.h'
--- src/zorbatypes/numeric_types.h	1970-01-01 00:00:00 +0000
+++ src/zorbatypes/numeric_types.h	2013-05-08 15:05:31 +0000
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+#ifndef ZORBA_NUMERIC_CONSTS_H
+#define ZORBA_NUMERIC_CONSTS_H
+
+namespace zorba {
+
+///////////////////////////////////////////////////////////////////////////////
+
+class integer_traits;
+class negative_traits;
+class nonNegative_traits;
+class nonPositive_traits;
+class positive_traits;
+
+template<class T> class IntegerImpl;
+typedef IntegerImpl<integer_traits>     Integer;
+typedef IntegerImpl<negative_traits>    NegativeInteger;
+typedef IntegerImpl<nonNegative_traits> NonNegativeInteger;
+typedef IntegerImpl<nonPositive_traits> NonPositiveInteger;
+typedef IntegerImpl<positive_traits>    PositiveInteger;
+
+class Decimal;
+
+template<typename F> class FloatImpl;
+typedef FloatImpl<float> Float;
+typedef FloatImpl<double> Double;
+
+/**
+ * This contains references to singleton objects having constant values for the
+ * often-used numeric constants -1, 0, and +1.
+ *
+ * @tparam NumericType One of Integer, NegativeInteger, NonNegativeInteger,
+ * NonPositiveInteger, PositiveInteger, Decimal, Float, or Double.
+ */
+template<class NumericType>
+struct numeric_consts {
+  static NumericType const& neg_one();
+  static NumericType const& zero();
+  static NumericType const& one();
+};
+
+/**
+ * Specialization for NegativeInteger that has only a reference to a singleton
+ * object having the constant value -1.
+ */
+template<>
+struct numeric_consts<NegativeInteger> {
+  static NegativeInteger const& neg_one();
+};
+
+/**
+ * Specialization for NonNegativeInteger that has only references to the
+ * singleton objects having the constant values 0 and 1.
+ */
+template<>
+struct numeric_consts<NonNegativeInteger> {
+  static NonNegativeInteger const& zero();
+  static NonNegativeInteger const& one();
+};
+
+/**
+ * Specialization for NonPositiveInteger that has only references to the
+ * singleton objects having the constant values -1 and 0.
+ */
+template<>
+struct numeric_consts<NonPositiveInteger> {
+  static NonPositiveInteger const& neg_one();