Merge lp:~zorba-coders/zorba/system_doc into lp:zorba/process-module

[William Candillon]

Minor documentation improvement

Minor documentation improvement

[Matthias Brantner (matthias-brantner)]

You were trying to merge the system into the process module.

Is that on purpose?

review: Needs Information

Unmerged revisions

35. By William Candillon on 2012-09-27

Minor documentation improvement.

34. By Dennis Knochenwefel on 2012-07-21

fixed crash with signal 8: SIGFPE (division by zero). bug #1026594. Approved: Dennis Knochenwefel, Chris Hillery

33. By Matthias Brantner on 2012-04-12

fix for bug #978722 (change annotation prefix from "ann" to "an") Approved: William Candillon, Matthias Brantner

32. By Chris Hillery on 2011-10-06

Converted all files to correct native EOLs.

31. By cezarfx on 2011-10-05

Fix bug when USER is not available as a environment var.
Fix if uname return with error.

30. By mbrantner on 2011-08-16

fixed typo in the system module

29. By mbrantner on 2011-08-12

documentation for system module (provided by William)

28. By spungi on 2011-08-10

- improved the speed of "make xqdoc" such that we can add xqdoc as a test
- fixed SF bug #3375604 "Built target cxxdocs" hangs
- make xqdoc does not search the filesystem, instead creates the documentation *only* for the modules that are compiled in the Zorba version used (based on the ZorbaManifest.xml in the build folder)
- implemented the 2 issues that Dana asked for in the email from @coders "core and non-core Zorba modules"
- fixed the link crawler issues in XQDoc reported by Daniel (except the link to xqdoc.org)

27. By mbrantner on 2011-08-05

added missing license headers

26. By spungi on 2011-08-01

XQuery version changes:
- Added XQuery version declarations for all the modules (part of the Zorba core or not).
- fixed the test "moduleDocumentation" that checks if all the modules are well documented:
  - this test used to check only the Zorba core modules: now it also checks the external modules.
  - added a new rule that makes sure all modules have a XQuery version declarations.

XQDoc changes:
- documented some XQDoc variables, params and return values that were missing.
- added support for XQuery version and Encoding in the Zorba XQDoc.
- added a new part called "XQuery version and Encoding for this module:" as the last lines in the module description of the XQDoc documentation.

=== added file 'CMakeLists.txt'
--- CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,29 @@
+# Copyright 2006-2010 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.
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+PROJECT (zorba_system_module)
+ENABLE_TESTING ()
+INCLUDE (CTest)
+
+LIST (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake_modules")
+
+FIND_PACKAGE (Zorba REQUIRED HINTS "${ZORBA_BUILD_DIR}")
+INCLUDE ("${Zorba_USE_FILE}")
+
+ADD_TEST_DIRECTORY("${PROJECT_SOURCE_DIR}/test")
+ADD_SUBDIRECTORY("src")
+
+DONE_DECLARING_ZORBA_URIS()

=== renamed file 'CMakeLists.txt' => 'CMakeLists.txt.moved'
=== added directory 'src'
=== renamed directory 'src' => 'src.moved'
=== added file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,19 @@
+# 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.
+
+# 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")

=== added directory 'src/com'
=== added file 'src/com/CMakeLists.txt'
--- src/com/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/com/CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,14 @@
+# 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)

=== added directory 'src/com/zorba-xquery'
=== added file 'src/com/zorba-xquery/CMakeLists.txt'
--- src/com/zorba-xquery/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,14 @@
+# 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)

=== added directory 'src/com/zorba-xquery/www'
=== added file 'src/com/zorba-xquery/www/CMakeLists.txt'
--- src/com/zorba-xquery/www/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/www/CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,14 @@
+# 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)

=== added directory 'src/com/zorba-xquery/www/modules'
=== added file 'src/com/zorba-xquery/www/modules/CMakeLists.txt'
--- src/com/zorba-xquery/www/modules/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/www/modules/CMakeLists.txt	2012-09-27 16:59:25 +0000
@@ -0,0 +1,14 @@
+# 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")

=== added file 'src/com/zorba-xquery/www/modules/system.xq'
--- src/com/zorba-xquery/www/modules/system.xq	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/www/modules/system.xq	2012-09-27 16:59:25 +0000
@@ -0,0 +1,211 @@
+xquery version "3.0";
+
+(:
+ : Copyright 2006-2009 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.
+:)
+(:~
+ : 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 />
+ : 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 />
+ : <pre class="ace-static">
+ : import module namespace system = "http://www.zorba-xquery.com/modules/system";
+ : 
+ : for $prop in system:properties()
+ : return concat($prop, ": ", system:property($prop), "
+ : ")
+ : </pre>
+ : <br />
+ : 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.
+ :
+ : @author Markus Pilman
+ : @project Zorba/IO/System
+ :)
+module namespace system = 'http://www.zorba-xquery.com/modules/system';
+
+declare namespace an = "http://www.zorba-xquery.com/annotations";
+
+declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
+declare option ver:module-version "1.0";
+
+(:~
+ : The name of the operating system (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";
+
+(:~
+ : The major version number of the Windows installation or
+ : an empty string if the process does not run on a Windows installation
+ : (os.version.major).
+ : <b>Works on Windows only.</b>
+ :)
+declare variable $system:os-version-major as xs:string := "os.version.major";
+
+(:~
+ : The minor version number of the Windows installation or
+ : an empty string if the process does not run on a Windows installation
+ : (os.version.minor).
+ : <b>Works on Windows only.</b>
+ :)
+declare variable $system:os-version-minor as xs:string := "os.version.minor";
+
+(:~
+ : The build number of the Windows installation or
+ : an empty string if the process does not run on a Windows installation
+ : (os.version.build).
+ : <b>Works on Windows only.</b>
+ :)
+declare variable $system:os-version-build as xs:string := "os.version.build";
+
+(:~
+ : The release of this UNIX installation or
+ : an empty string if the process does not run on a UNIX/Linux installation
+ : (os.version.release).
+ : <b>Works on UNIX based operating systems only.</b>
+ :)
+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";
+
+(:~
+ : The version of the Operating System.
+ :)
+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";
+
+(:~
+ : True if system architecture is 64bits (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";
+
+(:~
+ : Number of physical processors in the system (hardware.logical.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";
+
+(:~
+ : Physical memory available (hardware.physical.memory).
+ :)
+declare variable $system:hardware-physical-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";
+(:~
+ : Gets the hardware manufacturer (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";
+
+(:~
+ : 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";
+
+(:~
+ : 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";
+
+(:~
+ : 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";
+
+(:~
+ : Zorba version in the format Major.Minor.Patch (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";
+
+(:~
+ : Zorba minor version (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";
+
+(:~
+ : Gets the system property indicated by the specified key.
+ :
+ : @param $key The name of the system property.
+ : @return The string value of the system property, or an empty sequence if there is no property with that key.
+ :)
+declare %an:nondeterministic function system:property($key as xs:string) as xs:string? external;
+
+(:~
+ : 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 />
+ : 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.
+ :)
+declare %an:nondeterministic function system:properties() as xs:string* external;
+

=== added directory 'src/com/zorba-xquery/www/modules/system.xq.src'
=== added file 'src/com/zorba-xquery/www/modules/system.xq.src/system.cpp'
--- src/com/zorba-xquery/www/modules/system.xq.src/system.cpp	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/www/modules/system.xq.src/system.cpp	2012-09-27 16:59:25 +0000
@@ -0,0 +1,606 @@
+/*
+ * 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 <cstdlib>
+#include <cstdio>
+#include <sstream>
+
+#ifdef WIN32
+# include <Windows.h>
+# include <malloc.h>
+# include <stdio.h>
+# include <tchar.h>
+# include <winreg.h>
+#else
+#include <sys/utsname.h>
+# ifndef __APPLE__
+#   include <sys/sysinfo.h>
+# else
+#   include <sys/param.h>
+#   include <sys/sysctl.h>
+# endif
+#endif
+
+#include <zorba/zorba_string.h>
+#include <zorba/singleton_item_sequence.h>
+#include <zorba/vector_item_sequence.h>
+#include <zorba/empty_sequence.h>
+#include <zorba/item_factory.h>
+
+
+#ifdef LINUX
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <unistd.h>
+extern char** environ;
+#elif defined APPLE
+# include <crt_externs.h>
+#endif
+
+#include "system.h"
+
+
+namespace zorba { namespace system {
+
+  const String SystemModule::SYSTEM_MODULE_NAMESPACE = "http://www.zorba-xquery.com/modules/system";
+
+#ifdef WIN32
+  typedef BOOL (WINAPI *LPFN_GLPI)(
+      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
+      PDWORD);
+
+  // Helper function to count set bits in the processor mask.
+  DWORD CountSetBits(ULONG_PTR bitMask)
+  {
+    DWORD LSHIFT = sizeof(ULONG_PTR)*8 - 1;
+    DWORD bitSetCount = 0;
+    ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;
+    DWORD i;
+    for (i = 0; i <= LSHIFT; ++i)
+    {
+      bitSetCount += ((bitMask & bitTest)?1:0);
+      bitTest/=2;
+    }
+
+    return bitSetCount;
+  }
+
+  DWORD numaNodeCount = 0;
+  DWORD processorPackageCount = 0;
+  DWORD logicalProcessorCount = 0;
+  DWORD processorCoreCount = 0;
+  DWORD processorL1CacheCount = 0;
+  DWORD processorL2CacheCount = 0;
+  DWORD processorL3CacheCount = 0;
+  static void countProcessors() {
+    LPFN_GLPI glpi;
+    BOOL done = FALSE;
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
+    DWORD returnLength = 0;
+    DWORD byteOffset = 0;
+    PCACHE_DESCRIPTOR Cache;
+
+    glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")), "GetLogicalProcessorInformation");
+    if (NULL == glpi) {
+      // GetLogicalProcessorInformation is not supported.
+      return;
+    }
+
+    while (!done)
+    {
+      DWORD rc = glpi(buffer, &returnLength);
+      if (FALSE == rc)
+      {
+        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+          if (buffer)
+            free(buffer);
+          buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(returnLength);
+          if (NULL == buffer)
+          {
+            // Error: Allocation failure
+            return;
+          }
+        } else {
+          // Error %d, GetLastError()
+          return;
+        }
+      } else {
+        done = TRUE;
+      }
+    }
+    ptr = buffer;
+    while (byteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= returnLength)
+    {
+      switch (ptr->Relationship)
+      {
+        case RelationNumaNode:
+          // Non-NUMA systems report a single record of this type.
+          numaNodeCount++;
+          break;
+        case RelationProcessorCore:
+          processorCoreCount++;
+          // A hyperthreaded core supplies more than one logical processor.
+          logicalProcessorCount += CountSetBits(ptr->ProcessorMask);
+          break;
+
+        case RelationCache:
+          // Cache data is in ptr->Cache, one CACHE_DESCRIPTOR structure for each cache.
+          Cache = &ptr->Cache;
+          if (Cache->Level == 1)
+          {
+            processorL1CacheCount++;
+          }
+          else if (Cache->Level == 2)
+          {
+            processorL2CacheCount++;
+          }
+          else if (Cache->Level == 3)
+          {
+            processorL3CacheCount++;
+          }
+          break;
+        case RelationProcessorPackage:
+          // Logical processors share a physical package.
+          processorPackageCount++;
+          break;
+        default:
+          // Error: Unsupported LOGICAL_PROCESSOR_RELATIONSHIP value.
+          break;
+      }
+      byteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+      ptr++;
+    }
+    free(buffer);
+    return;
+  }
+
+#endif
+
+#ifdef LINUX
+  static void trim(std::string& str, char delim)
+  {
+    std::string::size_type pos = str.find_last_not_of(delim);
+    if(pos != std::string::npos) {
+      str.erase(pos + 1);
+      pos = str.find_first_not_of(delim);
+      if(pos != std::string::npos) str.erase(0, pos);
+    }
+    else str.erase(str.begin(), str.end());
+  }
+
+
+  int logical=0;
+  int cores=0;
+  int physical=0;
+
+
+  static void countProcessors() {
+    logical=0;
+    cores=1; // per default: single core processor
+    physical=0;
+
+    std::ifstream in("/proc/cpuinfo");
+    if(in) {
+      std::string name;
+      std::string value;
+
+      while(in) {
+        getline(in, name, ':');
+        trim (name, ' ');
+        trim (name, '\t');
+        trim (name, '\n');
+        getline(in, value);
+        trim (value, ' ');
+        trim (value, '\t');
+        if (name == "processor") {
+          logical++;
+        }
+
+        if (name == "cpu cores") {
+          cores = atoi(value.c_str());
+        }
+      }
+      physical = logical/cores;
+      in.close();
+    }
+  }
+
+
+
+  static std::pair<std::string, std::string> getDistribution() {
+    std::pair<std::string, std::string> lRes;
+    FILE *pipe;
+    const char* command = "lsb_release -r -i";
+    pipe = (FILE*) popen(command, "r");
+
+    char line[1024];
+    while (fgets(line, sizeof(line), pipe)) {
+      std::stringstream s(line);
+      std::string name, value;
+      getline(s, name, ':');
+      trim(name, ' ');
+      trim(name, '\t');
+      getline(s, value, ':');
+      trim(value, ' ');
+      trim(value, '\t');
+      trim(value, '\n');
+      if (name == "Distributor ID") {
+        lRes.first = value;
+      } else {
+        lRes.second = value;
+      }
+    }
+    return lRes;
+  }
+#endif
+
+  SystemModule::SystemModule()
+    : thePropertyFunction(0), thePropertiesFunction(0)
+  {
+  }
+
+  ExternalFunction* SystemModule::getExternalFunction(const String& localName) {
+    if (localName == "properties") {
+      if (!thePropertiesFunction)
+        thePropertiesFunction = new PropertiesFunction(this);
+      return thePropertiesFunction;
+    } else if (localName == "property") {
+      if (!thePropertyFunction)
+        thePropertyFunction = new PropertyFunction(this);
+      return thePropertyFunction;
+    }
+    return 0;
+  }
+
+  void SystemModule::destroy() {
+    delete this;
+  }
+
+  SystemModule::~SystemModule() {
+    delete thePropertyFunction;
+    delete thePropertiesFunction;
+  }
+
+
+  SystemFunction::SystemFunction(const ExternalModule* aModule)
+    : theModule(aModule), theFactory(Zorba::getInstance(0)->getItemFactory())
+  {
+#ifdef WIN32
+
+    {
+      DWORD nodeNameLength = MAX_COMPUTERNAME_LENGTH + 1;
+      TCHAR nodeName[MAX_COMPUTERNAME_LENGTH + 1];
+      char nodeNameC[MAX_COMPUTERNAME_LENGTH + 1];
+      GetComputerName(nodeName, &nodeNameLength);
+      for (DWORD i = 0; i < nodeNameLength; ++i) {
+        nodeNameC[i] = static_cast<char>(nodeName[i]);
+      }
+      nodeNameC[nodeNameLength] = NULL;  // Terminate string
+      theProperties.insert(std::make_pair("os.node.name", nodeNameC));
+    }
+
+    {
+      DWORD dwVersion = 0;
+      DWORD dwMajorVersion = 0;
+      DWORD dwMinorVersion = 0;
+      DWORD dwBuild = 0;
+
+      dwVersion = GetVersion();
+
+      // Get the Windows version.
+      dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
+      dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
+
+      // Get the build number.
+      if (dwVersion < 0x80000000)
+        dwBuild = (DWORD)(HIWORD(dwVersion));
+
+      std::string major;
+      std::string minor;
+      std::string build;
+      {
+        std::stringstream sMajor;
+        sMajor << dwMajorVersion;
+        std::stringstream sMinor;
+        sMinor << dwMinorVersion;
+        std::stringstream sBuild;
+        sBuild << dwBuild;
+
+        major = sMajor.str();
+        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));
+      // http://msdn.microsoft.com/en-us/library/ms724832(v=VS.85).aspx
+      std::string operativeSystem;
+      theProperties.insert(std::make_pair("os.name", "Windows"));
+      {
+        countProcessors();
+        std::stringstream logicalProcessors;
+        logicalProcessors << processorPackageCount;
+        std::stringstream physicalProcessors;
+        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() ));
+      }
+      {
+        MEMORYSTATUSEX statex;
+        statex.dwLength = sizeof (statex);
+        GlobalMemoryStatusEx (&statex);
+        std::stringstream virtualMemory;
+        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() ));
+      }
+
+    }
+    {
+      DWORD userNameLength = 1023;
+      TCHAR userName[1024];
+      char userNameC[1024];
+      GetUserName(userName, &userNameLength);
+      for (DWORD i = 0; i < userNameLength; ++i) {
+        userNameC[i] = static_cast<char>(userName[i]);
+      }
+      theProperties.insert(std::make_pair("user.name", 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"));
+      } else if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {
+        theProperties.insert(std::make_pair("os.arch", "ia64"));
+        theProperties.insert(std::make_pair("os.is64", "true"));
+      } else if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
+        theProperties.insert(std::make_pair("os.arch", "i386"));
+        theProperties.insert(std::make_pair("os.is64", "false"));
+      }
+    }
+
+    {
+      HKEY keyHandle;
+      TCHAR value [1024];
+      char valueC [1024];
+      DWORD size = 0;
+      DWORD Type;
+      if( RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"HARDWARE\\DESCRIPTION\\System\\BIOS", 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS)
+      {
+        RegQueryValueEx( keyHandle, L"SystemManufacturer", NULL, &Type, (LPBYTE)value, &size);
+        for (DWORD i = 0; i < size; ++i) {
+          valueC[i] = static_cast<char>(value[i]);
+        }
+        if (size > 0)
+          theProperties.insert(std::make_pair("hardware.manufacturer", valueC));
+      }
+      RegCloseKey(keyHandle);
+    }
+
+
+#else
+    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));
+    }
+    char* lUser = getenv("USER");
+    if (lUser)
+    {
+      theProperties.insert(std::make_pair("user.name", lUser));
+    }
+    theProperties.insert(std::make_pair("os.is64", "false"));
+    {
+#ifdef __APPLE__
+      int mib[2];
+      size_t len = 4;
+      uint32_t res = 0;
+
+      mib[0] = CTL_HW;
+      mib[1] = HW_NCPU;
+      sysctl(mib, 2, &res, &len, NULL, NULL);
+      std::stringstream lStream;
+      lStream << res;
+      theProperties.insert(std::make_pair("hardware.physical.cpu", lStream.str()));
+#else
+      countProcessors();
+      std::stringstream logicalProcessor;
+      std::stringstream physicalProcessor;
+      std::stringstream logicalPerPhysicalProcessors;
+      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() ));
+#endif
+    }
+    {
+# ifdef LINUX
+      struct sysinfo sys_info;
+      if(sysinfo(&sys_info) == 0) {
+        std::stringstream memory;
+        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() ));
+      }
+# elif defined __APPLE__
+      int mib[2];
+      size_t len = 8;
+      uint64_t res = 0;
+
+      mib[0] = CTL_HW;
+      mib[1] = HW_MEMSIZE;
+      sysctl(mib, 2, &res, &len, NULL, NULL);
+      std::stringstream lStream;
+      lStream << res;
+      theProperties.insert(std::make_pair("hardware.physical.memory", lStream.str()));
+# endif
+    }
+
+#endif
+#ifdef LINUX
+    theProperties.insert(std::make_pair("linux.distributor", ""));
+    theProperties.insert(std::make_pair("linux.distributor.version", ""));
+#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())));
+  }
+
+  String SystemFunction::intToString(int v) {
+    std::stringstream ss;
+    ss << v;
+    return ss.str();
+  }
+
+  bool SystemFunction::getEnv(const String& name, String& value) const
+  {
+    char* v = getenv(name.c_str());
+    if (v == NULL) return false;
+    value = v;
+    return true;
+  }
+
+  void SystemFunction::getEnvNames(std::vector<Item>& names) const
+  {
+#ifdef WIN32
+    // put in the environment variables
+    TCHAR *l_EnvStr;
+    l_EnvStr = GetEnvironmentStrings();
+
+    LPTSTR l_str = l_EnvStr;
+
+    int count = 0;
+    while (true)
+    {
+      if (*l_str == 0) break;
+      while (*l_str != 0) l_str++;
+      l_str++;
+      count++;
+    }
+
+    for (int i = 0; i < count; i++)
+    {
+      char lStr[1024];
+      memset(lStr, 0, 1024);
+      for (int i =0; i<1023 && l_EnvStr[i]; ++i) {
+        lStr[i] = (char) l_EnvStr[i];
+      }
+      std::string e(lStr);
+      std::string name("env.");
+      name += e.substr(0, e.find('='));
+      String value = e.substr(e.find('=') + 1);
+      if (name != "env.")
+        names.push_back(theFactory->createString(name));
+      while(*l_EnvStr != '\0')
+        l_EnvStr++;
+      l_EnvStr++;
+    }
+    //FreeEnvironmentStrings(l_EnvStr);
+#else
+# ifdef APPLE
+    char** environ = *_NSGetEnviron();
+# endif // APPLE
+    for (int i = 0; environ[i] != NULL; ++i) {
+      std::string e(environ[i]);
+      String name("env.");
+      name += e.substr(0, e.find('='));
+      names.push_back(theFactory->createString(name));
+    }
+#endif
+  }
+
+  ItemSequence_t PropertiesFunction::evaluate(
+      const ExternalFunction::Arguments_t& args) const {
+    std::vector<Item> lRes;
+    getEnvNames(lRes);
+    for (std::map<String, String>::const_iterator i = theProperties.begin();
+        i != theProperties.end(); ++i) {
+      Item lItem = theFactory->createString(i->first.c_str());
+      lRes.push_back(lItem);
+    }
+    // insert the zorba module path
+    lRes.push_back(theFactory->createString("zorba.module.path"));
+    return ItemSequence_t(new VectorItemSequence(lRes));
+  }
+
+  ItemSequence_t PropertyFunction::evaluate(
+      const ExternalFunction::Arguments_t& args,
+      const StaticContext* sctx,
+      const DynamicContext* dctx) const {
+    Item item;
+    Iterator_t arg0_iter = args[0]->getIterator();
+    arg0_iter->open();
+    arg0_iter->next(item);
+    arg0_iter->close();
+    String envS = item.getStringValue();
+    String lRes;
+    if (envS == "zorba.module.path") {
+      std::vector<String> lModulePaths;
+      sctx->getFullModulePaths(lModulePaths);
+      if (lModulePaths.size() == 0)
+        return ItemSequence_t(new SingletonItemSequence(theFactory->createString("")));
+      lRes = lModulePaths[0];
+      for (std::vector<String>::iterator i = lModulePaths.begin() + 1; i != lModulePaths.end(); ++i) {
+#ifdef WIN32
+        lRes += ";";
+#else
+        lRes += ":";
+#endif
+        lRes += *i;
+      }
+    } else if (envS.substr(0,4) == "env.") {
+      //Sleep(5000);
+      if (!getEnv(envS.substr(4), lRes)) {
+        return ItemSequence_t(new EmptySequence());
+      }
+#ifdef LINUX
+    } else if (envS == "linux.distributor") {
+      lRes = getDistribution().first;
+    } else if (envS == "linux.distributor.version") {
+      lRes = getDistribution().second;
+#endif
+    } else {
+      std::map<String, String>::const_iterator i;
+      if ((i = theProperties.find(envS.c_str())) != theProperties.end()) {
+        lRes = i->second;
+      } else {
+        return ItemSequence_t(new EmptySequence());
+      }
+    }
+    return ItemSequence_t(new SingletonItemSequence(theFactory->createString(lRes)));
+  }
+}} // namespace zorba, system
+

=== added file 'src/com/zorba-xquery/www/modules/system.xq.src/system.h'
--- src/com/zorba-xquery/www/modules/system.xq.src/system.h	1970-01-01 00:00:00 +0000
+++ src/com/zorba-xquery/www/modules/system.xq.src/system.h	2012-09-27 16:59:25 +0000
@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+#ifndef __COM_ZORBA_WWW_MODULES_SYSTEM_H__
+#define __COM_ZORBA_WWW_MODULES_SYSTEM_H__
+#include <vector>
+#include <map>
+
+#include <zorba/zorba.h>
+#include <zorba/external_module.h>
+#include <zorba/function.h>
+
+namespace zorba { namespace system {
+  class SystemModule : public ExternalModule {
+    private:
+      ExternalFunction* thePropertyFunction;
+      ExternalFunction* thePropertiesFunction;
+      const static String SYSTEM_MODULE_NAMESPACE;
+    public:
+      SystemModule();
+      virtual ~SystemModule();
+    public:
+      virtual String getURI() const { return SYSTEM_MODULE_NAMESPACE; }
+
+      virtual ExternalFunction* getExternalFunction(const String& localName);
+
+      virtual void destroy();
+  };
+
+  class SystemFunction {
+    protected:
+      const ExternalModule* theModule;
+      ItemFactory* theFactory;
+      std::map<String, String> theProperties;
+    public:
+      SystemFunction(const ExternalModule* aModule);
+    protected:
+      String getURI() const { return theModule->getURI(); }
+      bool getEnv(const String& name, String& value) const;
+      void getEnvNames(std::vector<Item>& names) const;
+      String intToString(int v);
+  };
+
+  class PropertiesFunction : public NonContextualExternalFunction, public SystemFunction {
+    public:
+      PropertiesFunction(const ExternalModule* mod) : SystemFunction(mod) {}
+
+      virtual String getLocalName() const { return "properties"; }
+
+      virtual ItemSequence_t 
+      evaluate(const ExternalFunction::Arguments_t& args) const;
+      virtual String getURI() const { return SystemFunction::getURI(); }
+  };
+
+  class PropertyFunction : public ContextualExternalFunction, public SystemFunction {
+    public:
+      PropertyFunction(const ExternalModule* mod) : SystemFunction(mod) {}
+
+      virtual String getLocalName() const { return "property"; }
+
+      virtual ItemSequence_t 
+      evaluate(const ExternalFunction::Arguments_t& args,
+               const StaticContext* sctx,
+               const DynamicContext* dctx) const;
+      virtual String getURI() const { return SystemFunction::getURI(); }
+  };
+
+} } // namespace zorba, namespace system
+
+#ifdef WIN32
+#  define DLL_EXPORT __declspec(dllexport)
+#else
+#  define DLL_EXPORT __attribute__ ((visibility("default")))
+#endif
+
+extern "C" DLL_EXPORT zorba::ExternalModule* createModule() {
+  return new zorba::system::SystemModule();
+}
+
+#endif // __COM_ZORBA_WWW_MODULES_SYSTEM_H__