Merge lp:~zorba-coders/zorba/bug-1188058 into lp:zorba/system-module

[Chris Hillery]

Update non-core "system" module to Zorba 3.0 standards. Added system:all-properties() function.

[lp:~zorba-coders/zorba/bug-1188058]

37. By Luis Rodriguez Gonzalez on 2013-08-07

Changes for Zorba 3.0 done

38. By Luis Rodriguez Gonzalez on 2013-08-07

Forgot to add SystemModule::getKey()

[Luis Rodriguez Gonzalez (kuraru)]

review: Approve

[Chris Hillery (ceejatec)]

Looks very good, nice work. However, the moduleDocumentation test doesn't pass, so there must be a typo somewhere in the XQDoc. Also, I suspect once you fix that, it will complain that all those public variable declarations need to have XQDoc; you'll probably need to restore the doc from the old version. (%private variables, like errors codes, don't need XQDoc, but public ones do as far as I know.)

review: Needs Fixing

[lp:~zorba-coders/zorba/bug-1188058]

39. By Luis Rodriguez Gonzalez on 2013-08-08

Fixed XQDoc

[Luis Rodriguez Gonzalez (kuraru)]

> Looks very good, nice work. However, the moduleDocumentation test doesn't
> pass, so there must be a typo somewhere in the XQDoc. Also, I suspect once you
> fix that, it will complain that all those public variable declarations need to
> have XQDoc; you'll probably need to restore the doc from the old version.
> (%private variables, like errors codes, don't need XQDoc, but public ones do
> as far as I know.)

Done.

[Chris Hillery (ceejatec)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/bug-1188058/+merge/178905

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Voting criteria failed for the following merge proposals:

https://code.launchpad.net/~zorba-coders/zorba/bug-1188058/+merge/178905 :
Votes: {'Approve': 2, 'Needs commit message': 1}

[Zorba Build Bot (zorba-buildbot)]

Validation queue result for https://code.launchpad.net/~zorba-coders/zorba/bug-1188058/+merge/178905

Stage "CommitZorba" failed.

Check console output at http://jenkins.lambda.nu/job/CommitZorba/111/console to view the results.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for the following merge proposals:
https://code.launchpad.net/~zorba-coders/zorba/bug-1188058/+merge/178905

Progress dashboard at http://jenkins.lambda.nu/view/ValidationQueue

[Zorba Build Bot (zorba-buildbot)]

Validation queue succeeded - proposal merged!

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2011-07-26 10:43:21 +0000
+++ src/CMakeLists.txt	2013-08-08 20:52:48 +0000
@@ -14,6 +14,4 @@
 
 # all external module libraries are generated in the directory
 # of the corresponding .xq file
-MESSAGE(STATUS "Add com")
-ADD_SUBDIRECTORY(com)
-MESSAGE(STATUS "End modules")
+DECLARE_ZORBA_MODULE (URI "http://zorba.io/modules/system" VERSION 1.0 FILE "system.xq")

=== removed directory 'src/com'
=== removed file 'src/com/CMakeLists.txt'
--- src/com/CMakeLists.txt	2011-10-06 08:19:44 +0000
+++ src/com/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-# 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.
-ADD_SUBDIRECTORY(zorba-xquery)

=== removed directory 'src/com/zorba-xquery'
=== removed file 'src/com/zorba-xquery/CMakeLists.txt'
--- src/com/zorba-xquery/CMakeLists.txt	2011-10-06 08:19:44 +0000
+++ src/com/zorba-xquery/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-# 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.
-ADD_SUBDIRECTORY(www)

=== removed directory 'src/com/zorba-xquery/www'
=== removed file 'src/com/zorba-xquery/www/CMakeLists.txt'
--- src/com/zorba-xquery/www/CMakeLists.txt	2011-10-06 08:19:44 +0000
+++ src/com/zorba-xquery/www/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-# 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.
-ADD_SUBDIRECTORY(modules)

=== removed directory 'src/com/zorba-xquery/www/modules'
=== removed file 'src/com/zorba-xquery/www/modules/CMakeLists.txt'
--- src/com/zorba-xquery/www/modules/CMakeLists.txt	2011-07-01 09:24:04 +0000
+++ src/com/zorba-xquery/www/modules/CMakeLists.txt	1970-01-01 00:00:00 +0000
@@ -1,14 +0,0 @@
-# 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.
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/system" VERSION 1.0 FILE "system.xq")

=== renamed file 'src/com/zorba-xquery/www/modules/system.xq' => 'src/system.xq'
--- src/com/zorba-xquery/www/modules/system.xq	2013-06-15 19:49:56 +0000
+++ src/system.xq	2013-08-08 20:52:48 +0000
@@ -1,4 +1,4 @@
-xquery version "3.0";
+jsoniq version "1.0";
 
 (:
  : Copyright 2006-2009 The FLWOR Foundation.
@@ -18,12 +18,10 @@
 (:~
  : The system module allows developers to access system properties.
  : Part of these system properties are environment variables,
- : local variable to the process running Zorba, and properties defined by Zorba.
- : <br />
+ : local variable to the process running Zorba, and properties defined by Zorba.<p/>
  : To avoid conflicts between environment variables and properties defined by Zorba,
- : all environment variables are prefixed with <i>env.</i>.
- : <br />
- : For instance, the following query: <br />
+ : all environment variables are prefixed with <i>env.</i>.<p/>
+ : For instance, the following query: <p/>
  : <pre class="ace-static">
  : import module namespace system = "http://www.zorba-xquery.com/modules/system";
  : 
@@ -31,19 +29,19 @@
  : return concat($prop, ": ", system:property($prop), "
  : ")
  : </pre>
- : <br />
+ : <p/>
  : Will output:
  : <pre class="ace-static">
  : env.TERM_PROGRAM: Apple_Terminal
  : ...
  : </pre>
  : In this example, it is important to notice that the environnement variable PATH
- : with the key env.PATH.
+ : with the key env.PATH.<p/>
  :
  : @author Markus Pilman
  : @project Zorba/Input Output/System
  :)
-module namespace system = 'http://www.zorba-xquery.com/modules/system';
+module namespace system = "http://zorba.io/modules/system";
 
 declare namespace an = "http://www.zorba-xquery.com/annotations";
 
@@ -53,12 +51,12 @@
 (:~
  : The name of the operating system (os.name).
  :)
-declare variable $system:os-name as xs:string := "os.name";
+declare variable $system:OS-NAME as xs:string := "os.name";
 
 (:~
  : The name of the computer the process is running on (os.node.name).
  :)
-declare variable $system:os-node-name as xs:string := "os.node.name";
+declare variable $system:OS-NODE-NAME as xs:string := "os.node.name";
 
 (:~
  : The major version number of the Windows installation or
@@ -66,7 +64,7 @@
  : (os.version.major).
  : <b>Works on Windows only.</b>
  :)
-declare variable $system:os-version-major as xs:string := "os.version.major";
+declare variable $system:OS-VERSION-MAJOR as xs:string := "os.version.major";
 
 (:~
  : The minor version number of the Windows installation or
@@ -74,7 +72,7 @@
  : (os.version.minor).
  : <b>Works on Windows only.</b>
  :)
-declare variable $system:os-version-minor as xs:string := "os.version.minor";
+declare variable $system:OS-VERSION-MINOR as xs:string := "os.version.minor";
 
 (:~
  : The build number of the Windows installation or
@@ -82,7 +80,7 @@
  : (os.version.build).
  : <b>Works on Windows only.</b>
  :)
-declare variable $system:os-version-build as xs:string := "os.version.build";
+declare variable $system:OS-VERSION-BUILD as xs:string := "os.version.build";
 
 (:~
  : The release of this UNIX installation or
@@ -90,105 +88,108 @@
  : (os.version.release).
  : <b>Works on UNIX based operating systems only.</b>
  :)
-declare variable $system:os-version-release as xs:string := "os.version.release";
+declare variable $system:OS-VERSION-RELEASE as xs:string := "os.version.release";
+
 (:~
  : The version of this UNIX installation or
  : an empty string if the process does not run on a UNIX/Linux installation
  : (os.version.version).
  : <b>Works on UNIX based operating systems only.</b>
  :)
-declare variable $system:os-version-version as xs:string := "os.version.version";
+declare variable $system:OS-VERSION-VERSION as xs:string := "os.version.version";
 
 (:~
  : The version of the Operating System.
  :)
-declare variable $system:os-version as xs:string := "os.version";
+declare variable $system:OS-VERSION as xs:string := "os.version";
 
 (:~
  : The name of the processor architecture (os.arch).
  : For example x86 or x86_64.
  :)
-declare variable $system:os-arch as xs:string := "os.arch";
+declare variable $system:OS-ARCH as xs:string := "os.arch";
 
 (:~
  : True if system architecture is 64bits (os.is64).
  :)
-declare variable $system:os-is64 as xs:string := "os.is64";
+declare variable $system:OS-IS64 as xs:string := "os.is64";
 
 (:~
  : Number of logical processors in the system (hardware.logical.cpu).
  : This information is not available under Mac OS X.
  :)
-declare variable $system:hardware-logical-cpu as xs:string := "hardware.logical.cpu";
+declare variable $system:HARDWARE-LOGICAL-CPU as xs:string := "hardware.logical.cpu";
 
 (:~
- : Number of physical processors in the system (hardware.logical.cpu).
+ : Number of physical processors in the system (hardware.physical.cpu).
  :)
-declare variable $system:hardware-physical-cpu as xs:string := "hardware.physical.cpu";
+declare variable $system:HARDWARE-PHYSICAL-CPU as xs:string := "hardware.physical.cpu";
 
 (:~
  : number of logical per physical processors in the system (hardware.logical.per.physical.cpu).
  : This information is not available under Mac OS X.
  :)
-declare variable $system:hardware-logical-per-physical-cpu as xs:string := "hardware.logical.per.physical.cpu";
+declare variable $system:HARDWARE-LOGICAL-PER-PHYSICAL-CPU as xs:string := "hardware.logical.per.physical.cpu";
 
 (:~
  : Physical memory available (hardware.physical.memory).
  :)
-declare variable $system:hardware-physical-memory as xs:string := "hardware.physical.memory";
+declare variable $system:HARDWARE-PHSICAL-MEMORY as xs:string := "hardware.physical.memory";
+
 (:~
  : Virtual memory available (hardware.virtual.memory).
  :)
-declare variable $system:hardware-virtual-memory as xs:string := "hardware.virtual.memory";
+declare variable $system:HARDWARE-VIRTUAL-MEMORY as xs:string := "hardware.virtual.memory";
+
 (:~
  : Gets the hardware manufacturer (hardware.manufacturer).
  :)
-declare variable $system:hardware-manufacturer as xs:string := "hardware.manufacturer";
+declare variable $system:HARDWARE-MANUFACTURER as xs:string := "hardware.manufacturer";
 
 (:~
  : The Linux distribution, Zorba is running on (linux.distributor).
  : <b>Works on UNIX based operating systems only.</b>
  :)
-declare variable $system:linux-distributor as xs:string := "linux.distributor";
+declare variable $system:LINUX-DISTRIBUTOR as xs:string := "linux.distributor";
 
 (:~
  : The version of the Linux distribution, Zorba is running on (linux.distributor.version).
  : <b>Works on UNIX based operating systems only.</b>
  :)
-declare variable $system:linux-distributor-version as xs:string := "linux.distributor.version";
+declare variable $system:LINUX-DISTRIBUTOR-VERSION as xs:string := "linux.distributor.version";
 
 (:~
  : The username, with which this process was started (user.name).
  : On Unix, this variable is only available if the USER environment
  : variable is set (e.g. it might not be available in a cronjob).
  :)
-declare variable $system:user-name as xs:string := "user.name";
+declare variable $system:USER-NAME as xs:string := "user.name";
 
 (:~
  : The Zorba module path, that is the paths in which Zorba looks
  : for modules (zorba.module.path).
  :)
-declare variable $system:zorba-module-path as xs:string := "zorba.module.path";
+declare variable $system:ZORBA-MODULE-PATH as xs:string := "zorba.module.path";
 
 (:~
  : Zorba version in the format Major.Minor.Patch (zorba.version).
  :)
-declare variable $system:zorba-version as xs:string := "zorba.version";
+declare variable $system:ZORBA-VERSION as xs:string := "zorba.version";
 
 (:~
  : Zorba major version (zorba.version.major).
  :)
-declare variable $system:zorba-version-major as xs:string := "zorba.version.major";
+declare variable $system:ZORBA-VERSION-MAJOR as xs:string := "zorba.version.major";
 
 (:~
  : Zorba minor version (zorba.version.minor).
  :)
-declare variable $system:zorba-version-minor as xs:string := "zorba.version.minor";
+declare variable $system:ZORBA-VERSION-MINOR as xs:string := "zorba.version.minor";
 
 (:~
  : Zorba patch version (zorba.version.patch).
  :)
-declare variable $system:zorba-version-patch as xs:string := "zorba.version.patch";
+declare variable $system:ZORBA-VERSION-PATCH as xs:string := "zorba.version.patch";
 
 (:~
  : Gets the system property indicated by the specified key.
@@ -201,7 +202,7 @@
 (:~
  : This function retrieves the names of the current system properties.
  : This list includes environment variables, local variable to the process running Zorba, and properties defined by Zorba.
- : <br />
+ : <p/>
  : To avoid conflicts between environment variables and properties defined by Zorba,
  : all environment variables are prefixed with <i>env.</i>.
  :
@@ -209,3 +210,19 @@
  :)
 declare %an:nondeterministic function system:properties() as xs:string* external;
 
+(:~
+ : This function retrieves all names and values from the current system properties.
+ : This list includes environment variables, local variable to the process running Zorba, and properties defined by Zorba.
+ : <p/>
+ : To avoid conflicts between environment variables and properties defined by Zorba,
+ : all environment variables are prefixed with <i>env.</i>.
+ :
+ : @return List of all system properties as a JSONiq Object sequence.
+ :)
+declare %an:nondeterministic function system:all-properties() as object() {
+  {
+     for $prop in system:properties()
+     return { $prop : system:property($prop) }
+  }
+};
+

=== renamed directory 'src/com/zorba-xquery/www/modules/system.xq.src' => 'src/system.xq.src'
=== modified file 'src/system.xq.src/system.cpp'
--- src/com/zorba-xquery/www/modules/system.xq.src/system.cpp	2012-07-19 12:29:57 +0000
+++ src/system.xq.src/system.cpp	2013-08-08 20:52:48 +0000
@@ -55,7 +55,33 @@
 
 namespace zorba { namespace system {
 
-  const String SystemModule::SYSTEM_MODULE_NAMESPACE = "http://www.zorba-xquery.com/modules/system";
+  const String SystemModule::SYSTEM_MODULE_NAMESPACE = "http://zorba.io/modules/system";
+
+  // global keys
+  zorba::Item SystemModule::globalOSName;
+  zorba::Item SystemModule::globalOSNodeName;
+  zorba::Item SystemModule::globalOSVersionMajor;
+  zorba::Item SystemModule::globalOSVersionMinor;
+  zorba::Item SystemModule::globalOSVersionBuild;
+  zorba::Item SystemModule::globalOSVersionRelease;
+  zorba::Item SystemModule::globalOSVersionVersion;
+  zorba::Item SystemModule::globalOSVersion;
+  zorba::Item SystemModule::globalOSArch;
+  zorba::Item SystemModule::globalOSis64;
+  zorba::Item SystemModule::globalHWLogicalCPU;
+  zorba::Item SystemModule::globalHWPhysicalCPU;
+  zorba::Item SystemModule::globalHWLogicalPerPhysicalCPU;
+  zorba::Item SystemModule::globalHWPhysicalMemory;
+  zorba::Item SystemModule::globalHWVirtualMemory;
+  zorba::Item SystemModule::globalHWManufacturer;
+  zorba::Item SystemModule::globalLinuxDistributor;
+  zorba::Item SystemModule::globalLinuxDistributorVersion;
+  zorba::Item SystemModule::globalUserName;
+  zorba::Item SystemModule::globalZorbaModulePath;
+  zorba::Item SystemModule::globalZorbaVersion;
+  zorba::Item SystemModule::globalZorbaVersionMajor;
+  zorba::Item SystemModule::globalZorbaVersionMinor;
+  zorba::Item SystemModule::globalZorbaVersionPatch;
 
 #ifdef WIN32
   typedef BOOL (WINAPI *LPFN_GLPI)(
@@ -252,6 +278,30 @@
   SystemModule::SystemModule()
     : thePropertyFunction(0), thePropertiesFunction(0)
   {
+      globalOSName = Zorba::getInstance(0)->getItemFactory()->createString("os.name");
+      globalOSNodeName = Zorba::getInstance(0)->getItemFactory()->createString("os.node.name");
+      globalOSVersionMajor = Zorba::getInstance(0)->getItemFactory()->createString("os.version.major");
+      globalOSVersionMinor = Zorba::getInstance(0)->getItemFactory()->createString("os.version.minor");
+      globalOSVersionBuild = Zorba::getInstance(0)->getItemFactory()->createString("os.version.build");
+      globalOSVersionRelease = Zorba::getInstance(0)->getItemFactory()->createString("os.version.release");
+      globalOSVersionVersion = Zorba::getInstance(0)->getItemFactory()->createString("os.version.version");
+      globalOSVersion = Zorba::getInstance(0)->getItemFactory()->createString("os.version");
+      globalOSArch = Zorba::getInstance(0)->getItemFactory()->createString("os.arch");
+      globalOSis64 = Zorba::getInstance(0)->getItemFactory()->createString("os.is64");
+      globalHWLogicalCPU = Zorba::getInstance(0)->getItemFactory()->createString("hardware.logical.cpu");
+      globalHWPhysicalCPU = Zorba::getInstance(0)->getItemFactory()->createString("hardware.physical.cpu");
+      globalHWLogicalPerPhysicalCPU = Zorba::getInstance(0)->getItemFactory()->createString("hardware.logical.per.physical.cpu");
+      globalHWPhysicalMemory = Zorba::getInstance(0)->getItemFactory()->createString("hardware.physical.memory");
+      globalHWVirtualMemory = Zorba::getInstance(0)->getItemFactory()->createString("hardware.virtual.memory");
+      globalHWManufacturer = Zorba::getInstance(0)->getItemFactory()->createString("hardware.manufacturer");
+      globalLinuxDistributor = Zorba::getInstance(0)->getItemFactory()->createString("linux.distributor");
+      globalLinuxDistributorVersion = Zorba::getInstance(0)->getItemFactory()->createString("linux.distributor.version");
+      globalUserName = Zorba::getInstance(0)->getItemFactory()->createString("user.name");
+      globalZorbaModulePath = Zorba::getInstance(0)->getItemFactory()->createString("zorba.module.path");
+      globalZorbaVersion = Zorba::getInstance(0)->getItemFactory()->createString("zorba.version");
+      globalZorbaVersionMajor = Zorba::getInstance(0)->getItemFactory()->createString("zorba.version.major");
+      globalZorbaVersionMinor = Zorba::getInstance(0)->getItemFactory()->createString("zorba.version.minor");
+      globalZorbaVersionPatch = Zorba::getInstance(0)->getItemFactory()->createString("zorba.version.patch");
   }
 
   ExternalFunction* SystemModule::getExternalFunction(const String& localName) {
@@ -276,6 +326,39 @@
     delete thePropertiesFunction;
   }
 
+  zorba::Item&
+  SystemModule::getGlobalKey(SystemModule::GLOBAL_KEY g)
+  {
+      switch(g)
+      {
+      case OS_NAME: return globalOSName;
+      case OS_NODE_NAME: return globalOSNodeName;
+      case OS_VER_MAJOR: return globalOSVersionMajor;
+      case OS_VER_MINOR: return globalOSVersionMinor;
+      case OS_VER_BUILD: return globalOSVersionBuild;
+      case OS_VER_RELEASE: return globalOSVersionRelease;
+      case OS_VER_VERSION: return globalOSVersionVersion;
+      case OS_VER: return globalOSVersion;
+      case OS_ARCH: return globalOSArch;
+      case OS_IS64: return globalOSis64;
+      case HARDWARE_lOGICAL_CPU: return globalHWLogicalCPU;
+      case HARDWARE_PHYSICAL_CPU: return globalHWPhysicalCPU;
+      case HARDWARE_LOGICAL_PER_PHYSICAL_CPU: return globalHWLogicalPerPhysicalCPU;
+      case HARDWARE_PHYSICAL_MEMORY: return globalHWPhysicalMemory;
+      case HARDWARE_VIRTUAL_MEMORY: return globalHWVirtualMemory;
+      case HARDWARE_MANUFACTURER: return globalHWManufacturer;
+      case LINUX_DISTRIBUTOR: return globalLinuxDistributor;
+      case LINUX_DISTRIBUTOR_VERSION: return globalLinuxDistributorVersion;
+      case USER_NAME: return globalUserName;
+      case ZORBA_MODULE_PATH: return globalZorbaModulePath;
+      case ZORBA_VER: return globalZorbaVersion;
+      case ZORBA_VER_MAJOR: return globalZorbaVersionMajor;
+      case ZORBA_VER_MINOR: return globalZorbaVersionMinor;
+      case ZORBA_VER_PATCH: return globalZorbaVersionPatch;
+      // should never hit this code but still ...
+      default: return globalOSName;
+      }
+  }
 
   SystemFunction::SystemFunction(const ExternalModule* aModule)
     : theModule(aModule), theFactory(Zorba::getInstance(0)->getItemFactory())
@@ -291,7 +374,7 @@
         nodeNameC[i] = static_cast<char>(nodeName[i]);
       }
       nodeNameC[nodeNameLength] = NULL;  // Terminate string
-      theProperties.insert(std::make_pair("os.node.name", nodeNameC));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_NODE_NAME).getStringValue(), nodeNameC));
     }
 
     {
@@ -325,13 +408,13 @@
         minor = sMinor.str();
         build = sBuild.str();
       }
-      theProperties.insert(std::make_pair("os.version.major", major));
-      theProperties.insert(std::make_pair("os.version.minor", minor));
-      theProperties.insert(std::make_pair("os.version.build", build));
-      theProperties.insert(std::make_pair("os.version", major + "." + minor + "." + build));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER_MAJOR).getStringValue(), major));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER_MINOR).getStringValue(), minor));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER_BUILD).getStringValue(), build));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER).getString(), major + "." + minor + "." + build));
       // http://msdn.microsoft.com/en-us/library/ms724832(v=VS.85).aspx
       std::string operativeSystem;
-      theProperties.insert(std::make_pair("os.name", "Windows"));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_NAME).getStringValue(), "Windows"));
       {
         countProcessors();
         std::stringstream logicalProcessors;
@@ -340,9 +423,9 @@
         physicalProcessors << logicalProcessorCount;
         std::stringstream logicalPerPhysicalProcessors;
         logicalPerPhysicalProcessors << (logicalProcessorCount / processorPackageCount );
-        theProperties.insert(std::make_pair("hardware.physical.cpu", logicalProcessors.str() ));
-        theProperties.insert(std::make_pair("hardware.logical.cpu", physicalProcessors.str() ));
-        theProperties.insert(std::make_pair("hardware.logical.per.physical.cpu", logicalPerPhysicalProcessors.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_CPU).getStringValue(), logicalProcessors.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_lOGICAL_CPU).getStringValue(), physicalProcessors.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_LOGICAL_PER_PHYSICAL_CPU).getStringValue(), logicalPerPhysicalProcessors.str() ));
       }
       {
         MEMORYSTATUSEX statex;
@@ -352,8 +435,8 @@
         virtualMemory << statex.ullTotalVirtual;
         std::stringstream physicalMemory;
         physicalMemory << statex.ullTotalPhys;
-        theProperties.insert(std::make_pair("hardware.virtual.memory", virtualMemory.str() ));
-        theProperties.insert(std::make_pair("hardware.physical.memory", physicalMemory.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_VIRTUAL_MEMORY).getStringValue(), virtualMemory.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_MEMORY).getStringValue(), physicalMemory.str() ));
       }
 
     }
@@ -365,20 +448,20 @@
       for (DWORD i = 0; i < userNameLength; ++i) {
         userNameC[i] = static_cast<char>(userName[i]);
       }
-      theProperties.insert(std::make_pair("user.name", userNameC));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::USER_NAME).getStringValue(), userNameC));
     }
     {
       SYSTEM_INFO info;
       GetSystemInfo(&info);
       if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
-        theProperties.insert(std::make_pair("os.arch", "x86_64"));
-        theProperties.insert(std::make_pair("os.is64", "true"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_ARCH).getStringValue(), "x86_64"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_IS64).getStringValue(), "true"));
       } else if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {
-        theProperties.insert(std::make_pair("os.arch", "ia64"));
-        theProperties.insert(std::make_pair("os.is64", "true"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_ARCH).getStringValue(), "ia64"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_IS64).getStringValue(), "true"));
       } else if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
-        theProperties.insert(std::make_pair("os.arch", "i386"));
-        theProperties.insert(std::make_pair("os.is64", "false"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_ARCH).getStringValue(), "i386"));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_IS64).getStringValue(), "false"));
       }
     }
 
@@ -395,7 +478,7 @@
           valueC[i] = static_cast<char>(value[i]);
         }
         if (size > 0)
-          theProperties.insert(std::make_pair("hardware.manufacturer", valueC));
+          theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_MANUFACTURER).getStringValue(), valueC));
       }
       RegCloseKey(keyHandle);
     }
@@ -405,19 +488,19 @@
     struct utsname osname;
     if (uname(&osname) == 0)
     {
-      theProperties.insert(std::make_pair("os.name", osname.sysname));
-      theProperties.insert(std::make_pair("os.node.name", osname.nodename));
-      theProperties.insert(std::make_pair("os.version.release", osname.release));
-      theProperties.insert(std::make_pair("os.version.version", osname.version));
-      theProperties.insert(std::make_pair("os.version", osname.release));
-      theProperties.insert(std::make_pair("os.arch", osname.machine));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_NAME).getStringValue(), osname.sysname));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_NODE_NAME).getStringValue(), osname.nodename));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER_RELEASE).getStringValue(), osname.release));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER_VERSION).getStringValue(), osname.version));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_VER).getStringValue(), osname.release));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_ARCH).getStringValue(), osname.machine));
     }
     char* lUser = getenv("USER");
     if (lUser)
     {
-      theProperties.insert(std::make_pair("user.name", lUser));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::USER_NAME).getStringValue(), lUser));
     }
-    theProperties.insert(std::make_pair("os.is64", "false"));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::OS_IS64).getStringValue(), "false"));
     {
 #ifdef __APPLE__
       int mib[2];
@@ -429,7 +512,7 @@
       sysctl(mib, 2, &res, &len, NULL, NULL);
       std::stringstream lStream;
       lStream << res;
-      theProperties.insert(std::make_pair("hardware.physical.cpu", lStream.str()));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_CPU).getStringValue(), lStream.str()));
 #else
       countProcessors();
       std::stringstream logicalProcessor;
@@ -438,9 +521,9 @@
       logicalProcessor << logical;
       physicalProcessor << physical;
       logicalPerPhysicalProcessors << cores;
-      theProperties.insert(std::make_pair("hardware.logical.per.physical.cpu", logicalPerPhysicalProcessors.str() ));
-      theProperties.insert(std::make_pair("hardware.physical.cpu", physicalProcessor.str() ));
-      theProperties.insert(std::make_pair("hardware.logical.cpu", logicalProcessor.str() ));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_LOGICAL_PER_PHYSICAL_CPU).getStringValue(), logicalPerPhysicalProcessors.str() ));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_CPU).getStringValue(), physicalProcessor.str() ));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_lOGICAL_CPU).getStringValue(), logicalProcessor.str() ));
 #endif
     }
     {
@@ -451,8 +534,8 @@
         memory << sys_info.totalram;
         std::stringstream swap;
         swap << sys_info.totalswap;
-        theProperties.insert(std::make_pair("hardware.virtual.memory", swap.str() ));
-        theProperties.insert(std::make_pair("hardware.physical.memory", memory.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_VIRTUAL_MEMORY).getStringValue(), swap.str() ));
+        theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_MEMORY).getStringValue(), memory.str() ));
       }
 # elif defined __APPLE__
       int mib[2];
@@ -464,19 +547,19 @@
       sysctl(mib, 2, &res, &len, NULL, NULL);
       std::stringstream lStream;
       lStream << res;
-      theProperties.insert(std::make_pair("hardware.physical.memory", lStream.str()));
+      theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::HARDWARE_PHYSICAL_MEMORY).getStringValue(), lStream.str()));
 # endif
     }
 
 #endif
 #ifdef LINUX
-    theProperties.insert(std::make_pair("linux.distributor", ""));
-    theProperties.insert(std::make_pair("linux.distributor.version", ""));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::LINUX_DISTRIBUTOR).getStringValue(), ""));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::LINUX_DISTRIBUTOR_VERSION).getStringValue(), ""));
 #endif
-    theProperties.insert(std::make_pair("zorba.version", Zorba::version().getVersion()));
-    theProperties.insert(std::make_pair("zorba.version.major", intToString(Zorba::version().getMajorVersion())));
-    theProperties.insert(std::make_pair("zorba.version.minor", intToString(Zorba::version().getMinorVersion())));
-    theProperties.insert(std::make_pair("zorba.version.patch", intToString(Zorba::version().getPatchVersion())));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::ZORBA_VER).getStringValue(), Zorba::version().getVersion()));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::ZORBA_VER_MAJOR).getStringValue(), intToString(Zorba::version().getMajorVersion())));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::ZORBA_VER_MINOR).getStringValue(), intToString(Zorba::version().getMinorVersion())));
+    theProperties.insert(std::make_pair(SystemModule::getGlobalKey(SystemModule::ZORBA_VER_PATCH).getStringValue(), intToString(Zorba::version().getPatchVersion())));
   }
 
   String SystemFunction::intToString(int v) {
@@ -552,7 +635,7 @@
       lRes.push_back(lItem);
     }
     // insert the zorba module path
-    lRes.push_back(theFactory->createString("zorba.module.path"));
+    lRes.push_back(SystemModule::getGlobalKey(SystemModule::ZORBA_MODULE_PATH));
     return ItemSequence_t(new VectorItemSequence(lRes));
   }
 
@@ -567,7 +650,7 @@
     arg0_iter->close();
     String envS = item.getStringValue();
     String lRes;
-    if (envS == "zorba.module.path") {
+    if (envS == SystemModule::getGlobalKey(SystemModule::ZORBA_MODULE_PATH).getStringValue().str()) {
       std::vector<String> lModulePaths;
       sctx->getFullModulePaths(lModulePaths);
       if (lModulePaths.size() == 0)
@@ -587,9 +670,9 @@
         return ItemSequence_t(new EmptySequence());
       }
 #ifdef LINUX
-    } else if (envS == "linux.distributor") {
+    } else if (envS == SystemModule::getGlobalKey(SystemModule::LINUX_DISTRIBUTOR).getStringValue().str()) {
       lRes = getDistribution().first;
-    } else if (envS == "linux.distributor.version") {
+    } else if (envS == SystemModule::getGlobalKey(SystemModule::LINUX_DISTRIBUTOR_VERSION).getStringValue().str()) {
       lRes = getDistribution().second;
 #endif
     } else {

=== modified file 'src/system.xq.src/system.h'
--- src/com/zorba-xquery/www/modules/system.xq.src/system.h	2011-08-05 02:22:28 +0000
+++ src/system.xq.src/system.h	2013-08-08 20:52:48 +0000
@@ -25,19 +25,54 @@
 
 namespace zorba { namespace system {
   class SystemModule : public ExternalModule {
+    protected:
+      static zorba::Item globalOSName;
+      static zorba::Item globalOSNodeName;
+      static zorba::Item globalOSVersionMajor;
+      static zorba::Item globalOSVersionMinor;
+      static zorba::Item globalOSVersionBuild;
+      static zorba::Item globalOSVersionRelease;
+      static zorba::Item globalOSVersionVersion;
+      static zorba::Item globalOSVersion;
+      static zorba::Item globalOSArch;
+      static zorba::Item globalOSis64;
+      static zorba::Item globalHWLogicalCPU;
+      static zorba::Item globalHWPhysicalCPU;
+      static zorba::Item globalHWLogicalPerPhysicalCPU;
+      static zorba::Item globalHWPhysicalMemory;
+      static zorba::Item globalHWVirtualMemory;
+      static zorba::Item globalHWManufacturer;
+      static zorba::Item globalLinuxDistributor;
+      static zorba::Item globalLinuxDistributorVersion;
+      static zorba::Item globalUserName;
+      static zorba::Item globalZorbaModulePath;
+      static zorba::Item globalZorbaVersion;
+      static zorba::Item globalZorbaVersionMajor;
+      static zorba::Item globalZorbaVersionMinor;
+      static zorba::Item globalZorbaVersionPatch;
     private:
       ExternalFunction* thePropertyFunction;
       ExternalFunction* thePropertiesFunction;
       const static String SYSTEM_MODULE_NAMESPACE;
     public:
+      enum GLOBAL_KEY { OS_NAME, OS_NODE_NAME, OS_VER_MAJOR, OS_VER_MINOR,
+                        OS_VER_BUILD, OS_VER_RELEASE, OS_VER_VERSION, OS_VER,
+                        OS_ARCH, OS_IS64, HARDWARE_lOGICAL_CPU, HARDWARE_PHYSICAL_CPU,
+                        HARDWARE_LOGICAL_PER_PHYSICAL_CPU, HARDWARE_PHYSICAL_MEMORY,
+                        HARDWARE_VIRTUAL_MEMORY, HARDWARE_MANUFACTURER, LINUX_DISTRIBUTOR,
+                        LINUX_DISTRIBUTOR_VERSION, USER_NAME, ZORBA_MODULE_PATH, ZORBA_VER, ZORBA_VER_MAJOR,
+                        ZORBA_VER_MINOR, ZORBA_VER_PATCH };
+                        
       SystemModule();
       virtual ~SystemModule();
-    public:
+      
       virtual String getURI() const { return SYSTEM_MODULE_NAMESPACE; }
 
       virtual ExternalFunction* getExternalFunction(const String& localName);
 
       virtual void destroy();
+      
+      static zorba::Item& getGlobalKey(enum GLOBAL_KEY g);
   };
 
   class SystemFunction {