zorba-coders team mailing list archive
-
zorba-coders team
-
Mailing list archive
-
Message #14913
[Merge] lp:~zorba-coders/zorba/system_doc into lp:zorba/process-module
William Candillon has proposed merging lp:~zorba-coders/zorba/system_doc into lp:zorba/process-module.
Commit message:
Minor documentation improvement
Requested reviews:
William Candillon (wcandillon)
Matthias Brantner (matthias-brantner)
For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/system_doc/+merge/126739
Minor documentation improvement
--
https://code.launchpad.net/~zorba-coders/zorba/system_doc/+merge/126739
Your team Zorba Coders is subscribed to branch lp:zorba/process-module.
=== 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__
Follow ups
