\hypertarget{group__misc__functions}{}\section{Miscellaneous Functions}
\label{group__misc__functions}\index{Miscellaneous Functions@{Miscellaneous Functions}}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item 
string \hyperlink{group__misc__functions_gaf1f9e78591e0726d73eaf1639efa2611}{Qore\+::backquote} (string cmd, \+\_\+\+\_\+7\+\_\+ reference rc)
\begin{DoxyCompactList}\small\item\em Executes a process and returns a string of the output (stdout only) \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga1d71fa075b5fd841df08e05cfdfc95c6}{Qore\+::backquote} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_ga763747610a3546dd2340c703ced15bd6}{Qore\+::call\+\_\+builtin\+\_\+function} (string name,...)
\begin{DoxyCompactList}\small\item\em Calls a function and returns the return value, passing the remaining arguments after the function name to the builtin function. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_ga8a09a722bcccf27139640bde318310a7}{Qore\+::call\+\_\+builtin\+\_\+function\+\_\+args} (string name, \+\_\+\+\_\+7\+\_\+ softlist vargs)
\begin{DoxyCompactList}\small\item\em Calls a function and returns the return value, using the optional second argument as a list of arguments for the function. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_gadb60673dad0c6cd7ec4fe1eec8c5dab8}{Qore\+::call\+\_\+function} (string name,...)
\begin{DoxyCompactList}\small\item\em Calls a function and returns the return value, passing the remaining arguments after the function name to the function. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_gad84bc65c4a73c9a46b6481d3865a91ee}{Qore\+::call\+\_\+function} (code f,...)
\begin{DoxyCompactList}\small\item\em Calls the given \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} and returns the result, passing the remaining arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_ga6d920ba42e07061721bd201ce2564bb8}{Qore\+::call\+\_\+function\+\_\+args} (string name, \+\_\+\+\_\+7\+\_\+ softlist vargs)
\begin{DoxyCompactList}\small\item\em Calls a function and returns the return value, using the optional second argument as a list of arguments for the function. \end{DoxyCompactList}\item 
any \hyperlink{group__misc__functions_gae1d16b3c77aa2f8b8433d9b75600370c}{Qore\+::call\+\_\+function\+\_\+args} (code f, \+\_\+\+\_\+7\+\_\+ softlist vargs)
\begin{DoxyCompactList}\small\item\em Calls the given \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} and returns the result, using the optional second argument as a list of arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga51b949c2d20900fdc2e1b8e46988d2b1}{Qore\+::decode\+\_\+url} (string url)
\begin{DoxyCompactList}\small\item\em Decodes percent numeric codes in a U\+R\+L string and returns the decoded string in U\+T\+F-\/8 encoding. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga2f5349505d3d2563ef31f4d8b5c5f1b3}{Qore\+::decode\+\_\+url} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{Qore\+::encode\+\_\+url} (string url, softbool encode\+\_\+all=False)
\begin{DoxyCompactList}\small\item\em Encodes U\+R\+Ls by substituting {\ttfamily '\%'} characters with {\ttfamily '\%25'}, spaces ({\ttfamily '} ') with {\ttfamily '\%20'}, and non-\/ascii characters by percent-\/encoded representations. \end{DoxyCompactList}\item 
bool \hyperlink{group__misc__functions_gad1e87cdb4aded090b1801d952e018a50}{Qore\+::exists} (...)
\begin{DoxyCompactList}\small\item\em A function performing the same role as the \hyperlink{operators_exists}{exists operator}. \end{DoxyCompactList}\item 
bool \hyperlink{group__misc__functions_ga83615e15094fca9ffe868ee0d80cd002}{Qore\+::exists\+Function} (string name)
\begin{DoxyCompactList}\small\item\em Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the function exists in the current program's function name space. \end{DoxyCompactList}\item 
bool \hyperlink{group__misc__functions_gaa3aa518a4c17e2593c2773bc6b71af3c}{Qore\+::exists\+Function} (code c)
\begin{DoxyCompactList}\small\item\em Always returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gac6b3861f291cf4c2f62742fc8ec9b717}{Qore\+::exists\+Function} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ string \hyperlink{group__misc__functions_ga5ae2be041abe7d02be8a2ccc67c0032f}{Qore\+::function\+Type} (string name)
\begin{DoxyCompactList}\small\item\em Returns {\ttfamily \char`\"{}builtin\char`\"{}} (for a builtin function), {\ttfamily \char`\"{}user\char`\"{}} (for a user function), or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} (if the function cannot be found) according to the function name passed. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gaf46dfa4dc44e9e7091e981c87ebbe438}{Qore\+::function\+Type} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga3a6b906bee63eb28d20610da64fd5417}{Qore\+::get\+Byte} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gadfbef79c0c3442d2d7857f6ba1d56049}{Qore\+::get\+Byte} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gad79fe036448819f5e392ef443b60b97d}{Qore\+::get\+Byte} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga46b9c2df48897cb68e765cb6d66728ac}{Qore\+::get\+Class\+Name} (object obj)
\begin{DoxyCompactList}\small\item\em Returns the class name of the object passed. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga69cdaa7f57458a60221fbed9ac2feb38}{Qore\+::get\+Class\+Name} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_gaa1e2c9fc19fe68b7fe55e1004fadea31}{Qore\+::get\+Feature\+List} ()
\begin{DoxyCompactList}\small\item\em Returns a list of strings of the builtin and module-\/supplied features of \hyperlink{namespace_qore}{Qore}. \end{DoxyCompactList}\item 
hash \hyperlink{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}{Qore\+::get\+Module\+Hash} ()
\begin{DoxyCompactList}\small\item\em Returns a hash of hashes describing the currently-\/loaded Qore modules; the top-\/level hash keys are the module names. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_gac0f41a0baf9a10b14442be26403fe733}{Qore\+::get\+Module\+List} ()
\begin{DoxyCompactList}\small\item\em Returns a list of hashes describing the currently-\/loaded Qore modules. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{Qore\+::get\+Word32} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga771e2f1f122ccd8574354abdff42c192}{Qore\+::get\+Word32} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga11bb1ea838d7c14802f3810ed0cbfdb2}{Qore\+::get\+Word32} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{Qore\+::get\+\_\+byte} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga8a7ea9de612741d9bb26bf926d211c71}{Qore\+::get\+\_\+byte} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga8f800bec17c55a15ec7255dedfa25c6d}{Qore\+::get\+\_\+default\+\_\+encoding} ()
\begin{DoxyCompactList}\small\item\em Returns the name of the \hyperlink{character_encoding_default_encoding}{default character encoding}. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_gafadcbf214ccffbde013894b330b7c7ae}{Qore\+::get\+\_\+ex\+\_\+pos} (hash ex)
\begin{DoxyCompactList}\small\item\em returns a descriptive string for an exception location; the {\ttfamily source} and {\ttfamily offset} information will also be included in the string returned if present in the \hyperlink{exception_handling_exception_hash}{exception hash} argument \end{DoxyCompactList}\item 
int \hyperlink{group__misc__functions_ga6b1422bc842cbf53cf2bb53ef9322209}{Qore\+::get\+\_\+parse\+\_\+options} ()
\begin{DoxyCompactList}\small\item\em returns the current \hyperlink{group__parse__options}{parse options} for the current \hyperlink{class_qore_1_1_program}{Program} object \end{DoxyCompactList}\item 
hash \hyperlink{group__misc__functions_gaf67d7ded1719f761d52819469b40aebc}{Qore\+::get\+\_\+qore\+\_\+library\+\_\+info} ()
\begin{DoxyCompactList}\small\item\em Returns a hash of library build and version info. \end{DoxyCompactList}\item 
hash \hyperlink{group__misc__functions_gaa1c1e9b47829b8139adb60a3f85947cf}{Qore\+::get\+\_\+qore\+\_\+option\+\_\+hash} ()
\begin{DoxyCompactList}\small\item\em Returns a hash of hashes giving information about Qore library options for the current build. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_ga46b20ef171a0c0af8d5760f46ebc7894}{Qore\+::get\+\_\+qore\+\_\+option\+\_\+list} ()
\begin{DoxyCompactList}\small\item\em Returns a list of hashes giving information about Qore library options for the current build. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ string \hyperlink{group__misc__functions_ga4730f5a695996be26efbfa9760417b1b}{Qore\+::get\+\_\+script\+\_\+dir} ()
\begin{DoxyCompactList}\small\item\em Returns the name of the directory from which the current script was executed or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ string \hyperlink{group__misc__functions_gade1f45f4d12597822362d920c84695a5}{Qore\+::get\+\_\+script\+\_\+name} ()
\begin{DoxyCompactList}\small\item\em Returns the filename of the current script if known or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ string \hyperlink{group__misc__functions_ga3ebc5d7d350677395e4b89686ca335b4}{Qore\+::get\+\_\+script\+\_\+path} ()
\begin{DoxyCompactList}\small\item\em Returns the path (directory and filename) of the current script or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{Qore\+::get\+\_\+word\+\_\+16} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gad19c4c14c864af9759effecbfef6d68a}{Qore\+::get\+\_\+word\+\_\+16} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{Qore\+::get\+\_\+word\+\_\+16\+\_\+lsb} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga28d6b93d58fb1df8615a9701fa10fe52}{Qore\+::get\+\_\+word\+\_\+16\+\_\+lsb} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{Qore\+::get\+\_\+word\+\_\+32} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga1124c85d897be618a9e61c1fbccd37d9}{Qore\+::get\+\_\+word\+\_\+32} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{Qore\+::get\+\_\+word\+\_\+32\+\_\+lsb} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga2269ca395fdfe9214039952c4cacf730}{Qore\+::get\+\_\+word\+\_\+32\+\_\+lsb} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{Qore\+::get\+\_\+word\+\_\+64} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga6fbc2c59ad0af1fe6a9e87b6f037d331}{Qore\+::get\+\_\+word\+\_\+64} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{Qore\+::get\+\_\+word\+\_\+64\+\_\+lsb} (string str, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ int \hyperlink{group__misc__functions_ga08294fc87d5f9d127cdd794085c59072}{Qore\+::get\+\_\+word\+\_\+64\+\_\+lsb} (binary b, softint offset=0)
\begin{DoxyCompactList}\small\item\em Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. \end{DoxyCompactList}\item 
bool \hyperlink{group__misc__functions_gae5e23d5903ee2b32bb4925b756607cf9}{Qore\+::has\+\_\+key} (hash h, string key)
\begin{DoxyCompactList}\small\item\em Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the given key exists in the hash (does not necessarily have to have a value assigned); exceptions are only raised if string encoding errors are encountered. \end{DoxyCompactList}\item 
bool \hyperlink{group__misc__functions_ga5cf258d64631c0422ee15e0796361b28}{Qore\+::has\+\_\+key} (object obj, string key)
\begin{DoxyCompactList}\small\item\em Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the given key exists in the object (does not necessarily have to have a value assigned); exceptions are only raised if string encoding errors are encountered or in case of object access errors. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_ga4fdc10fe7c8f77e24432ae2e435f9211}{Qore\+::hash\+\_\+values} (hash h)
\begin{DoxyCompactList}\small\item\em Returns a list of all the values in the hash argument passed. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga6f07280e7c9ab676913b6fcb84588610}{Qore\+::hash\+\_\+values} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
int \hyperlink{group__misc__functions_ga635c21b4901af8accbf5729682b90f20}{Qore\+::hextoint} (string str)
\begin{DoxyCompactList}\small\item\em Returns an integer for a hexadecimal string value; throws an exception if non-\/hex digits are found. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga54d9807bf59a9e97284b12542a4c3ec6}{Qore\+::hextoint} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_gac6f51f8c4de37bc139346d6059961148}{Qore\+::html\+\_\+decode} (string str)
\begin{DoxyCompactList}\small\item\em Returns a string with any H\+T\+M\+L escape codes translated to the original characters. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gad95ece28621404a42cf5e3f80193c84d}{Qore\+::html\+\_\+decode} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga98e1d9690329e8c94f88b833af36ef72}{Qore\+::html\+\_\+encode} (string str)
\begin{DoxyCompactList}\small\item\em Returns a string with characters needing H\+T\+M\+L escaping translated to H\+T\+M\+L escape codes. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga26f2cfc2d0d972642e82eedc09d097cc}{Qore\+::html\+\_\+encode} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gae8e72e38355f6fcd037ca65945377c96}{Qore\+::load\+\_\+module} (string name)
\begin{DoxyCompactList}\small\item\em Loads in a Qore module at run-\/time. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga366da9b19ed9b6fb4936f5e5a2ff3663}{Qore\+::load\+\_\+module} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga302de285f031c3dd4b059df3494bd21c}{Qore\+::make\+Base64\+String} (string str, softint maxlinelen=-\/1)
\begin{DoxyCompactList}\small\item\em Returns a base64-\/encoded representation of a string. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga511ce458d13dfbea8c22ece63c315bb7}{Qore\+::make\+Base64\+String} (binary bin, softint maxlinelen=-\/1)
\begin{DoxyCompactList}\small\item\em Returns a base64-\/encoded representation of a binary object. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga1d5d34fd58d766f2eacde5701f5a99ae}{Qore\+::make\+Base64\+String} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{Qore\+::make\+Hex\+String} (string str)
\begin{DoxyCompactList}\small\item\em Returns a hex-\/encoded representation of a string. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_gaafe286db27d58cea75749c1bdabb5ad0}{Qore\+::make\+Hex\+String} (binary bin)
\begin{DoxyCompactList}\small\item\em Returns a hex-\/encoded representation of a binary object. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gacb04ca5bd37d873b867186c4da295f0c}{Qore\+::make\+Hex\+String} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ hash \hyperlink{group__misc__functions_ga17bc2cdb62ca121ae990e497e609349d}{Qore\+::parse} (string code, string label, \+\_\+\+\_\+7\+\_\+ softint warning\+\_\+mask, \+\_\+\+\_\+7\+\_\+ string source, \+\_\+\+\_\+7\+\_\+ softint offset, softbool format\+\_\+label=True)
\begin{DoxyCompactList}\small\item\em Adds the text passed to the current program's code, tagged with the given label. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga6c7d460b97c3c862717b052355985ded}{Qore\+::parse} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
binary \hyperlink{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{Qore\+::parse\+Base64\+String} (string str)
\begin{DoxyCompactList}\small\item\em Parses a base64 encoded string and returns a binary object of the decoded data. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga0c3bdfd8fb3a29af0d3bcd0ed3a05eb0}{Qore\+::parse\+Base64\+String} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga1f1a63790a7c60a3a61c5d1569fe4e4c}{Qore\+::parse\+Base64\+String\+To\+String} (string str, \+\_\+\+\_\+7\+\_\+ string encoding)
\begin{DoxyCompactList}\small\item\em Parses a base64 encoded string and returns a string of the decoded data. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga8851e308445e0388408b8b2cca344088}{Qore\+::parse\+Base64\+String\+To\+String} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
binary \hyperlink{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{Qore\+::parse\+Hex\+String} (string hexstr)
\begin{DoxyCompactList}\small\item\em Parses a hex-\/encoded string and returns the binary object. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga64ee3ae01383697ae0174fd0cf6cbc5e}{Qore\+::parse\+Hex\+String} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
\+\_\+\+\_\+7\+\_\+ hash \hyperlink{group__misc__functions_ga6acb2a9487067027a3bdb0d19e2af5fb}{Qore\+::parse\+U\+R\+L} (string url, bool keep\+\_\+brackets=False)
\begin{DoxyCompactList}\small\item\em Parses a U\+R\+L string and returns a hash of the components; if the U\+R\+L cannot be parsed then \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} is returned. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_gad2514f74637e1955648b867103aea595}{Qore\+::parse\+U\+R\+L} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
hash \hyperlink{group__misc__functions_ga622e19abea9bd621927bce830b5df09d}{Qore\+::parse\+\_\+url} (string url, bool keep\+\_\+brackets=False)
\begin{DoxyCompactList}\small\item\em Parses a U\+R\+L string and returns a hash of the components; throws an exception if the string cannot be parsed as a U\+R\+L. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{Qore\+::splice} (string str)
\begin{DoxyCompactList}\small\item\em This function always returns an empty string {\ttfamily \char`\"{}\char`\"{}}. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_ga2d484582db42dcb4752812d3243552bc}{Qore\+::splice} (string str, softint start)
\begin{DoxyCompactList}\small\item\em Returns a string based on the argument string but with characters removed from a certain character index. \end{DoxyCompactList}\item 
string \hyperlink{group__misc__functions_gaaf2f11a128064b10de5cd2ce1fec72d3}{Qore\+::splice} (string str, softint start, softint len, \+\_\+\+\_\+7\+\_\+ string nstr)
\begin{DoxyCompactList}\small\item\em Returns a string based on the argument string but optionally with characters removed and/or added from a certain character index. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_ga88ec0c57f38fb9b7f1a3858fc2e307e8}{Qore\+::splice} (list l, softint start)
\begin{DoxyCompactList}\small\item\em Returns a list based on the argument list but with elements removed from the given index to the end of the list. \end{DoxyCompactList}\item 
list \hyperlink{group__misc__functions_gacec3f65cab29f5f51e4555b823e13d6c}{Qore\+::splice} (list l, softint start, softint len, \+\_\+\+\_\+7\+\_\+ softlist nlist)
\begin{DoxyCompactList}\small\item\em Returns a list based on the argument list but optionally with elements removed and/or added from a certain index. \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga7434c1e84c31c32b816312e7a846e876}{Qore\+::splice} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\item 
int \hyperlink{group__misc__functions_ga868cb227993d254a65afb9d21ccba9fe}{Qore\+::strtoint} (string num, softint base=10)
\begin{DoxyCompactList}\small\item\em parses a string representing a number in a configurable base and returns the integer \end{DoxyCompactList}\item 
nothing \hyperlink{group__misc__functions_ga25647de5f63580b7d3af4b33c4f35702}{Qore\+::strtoint} ()
\begin{DoxyCompactList}\small\item\em This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. \end{DoxyCompactList}\end{DoxyCompactItemize}


\subsection{Detailed Description}
Miscellaneous functions 

\subsection{Function Documentation}
\hypertarget{group__misc__functions_gaf1f9e78591e0726d73eaf1639efa2611}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!backquote@{backquote}}
\index{backquote@{backquote}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{backquote}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::backquote (
\begin{DoxyParamCaption}
\item[{string}]{cmd, }
\item[{\+\_\+\+\_\+7\+\_\+ reference}]{rc}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaf1f9e78591e0726d73eaf1639efa2611}


Executes a process and returns a string of the output (stdout only) 

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gaab2d8faa88f066837e100152187e6368}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+E\+X\+T\+E\+R\+N\+A\+L\+\_\+\+P\+R\+O\+C\+E\+S\+S}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em cmd} & The shell command to executed as a subprocess \\
\hline
{\em rc} & an optional reference to an integer to return the return code of the process\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The stdout of the shell command that was executed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{int} $rc;
my \textcolor{keywordtype}{string} $files = $files = \hyperlink{group__misc__functions_gaf1f9e78591e0726d73eaf1639efa2611}{backquote}(\textcolor{stringliteral}{"ls"}, \(\backslash\)$rc);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em B\+A\+C\+K\+Q\+U\+O\+T\+E-\/\+E\+R\+R\+O\+R} & An error occurred with the \hyperlink{group__library__functions_ga38309c0ab1c849afc031dd8547b1ac65}{fork()} or opening the stdout pipe\\
\hline
\end{DoxyExceptions}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{group__library__functions_gab480d27a192337309e6497158df8e54c}{system()}
\item \hyperlink{operators_backquote_operator}{the backquote operator}
\end{DoxyItemize}
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+8 the {\itshape rc} argument was added 
\end{DoxySince}
\hypertarget{group__misc__functions_ga1d71fa075b5fd841df08e05cfdfc95c6}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!backquote@{backquote}}
\index{backquote@{backquote}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{backquote}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::backquote (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga1d71fa075b5fd841df08e05cfdfc95c6}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gaab2d8faa88f066837e100152187e6368}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+E\+X\+T\+E\+R\+N\+A\+L\+\_\+\+P\+R\+O\+C\+E\+S\+S}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga763747610a3546dd2340c703ced15bd6}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+builtin\+\_\+function@{call\+\_\+builtin\+\_\+function}}
\index{call\+\_\+builtin\+\_\+function@{call\+\_\+builtin\+\_\+function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+builtin\+\_\+function}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+builtin\+\_\+function (
\begin{DoxyParamCaption}
\item[{string}]{name, }
\item[{}]{...}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga763747610a3546dd2340c703ced15bd6}


Calls a function and returns the return value, passing the remaining arguments after the function name to the builtin function. 


\begin{DoxyParams}{Parameters}
{\em name} & The name of the builtin function to call \\
\hline
{\em ...} & Any optional arguments to the function\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The value returned by the called function
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_ga763747610a3546dd2340c703ced15bd6}{call\_builtin\_function}(\textcolor{stringliteral}{"func\_name"}, $arg1, $arg2);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em I\+N\+V\+A\+L\+I\+D-\/\+F\+U\+N\+C\+T\+I\+O\+N-\/\+A\+C\+C\+E\+S\+S} & Parse options do not allow access to the function \\
\hline
{\em N\+O-\/\+F\+U\+N\+C\+T\+I\+O\+N} & The function does not exist\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
The function called could also throw other exceptions
\end{DoxyNote}
\begin{DoxySince}{Since}
0.\+8.\+4 this function no longer restricts its search to builtin functions as as of \hyperlink{namespace_qore}{Qore} 0.\+8.\+4 builtin and user functions are stored identically internally; there is only one function implementation which can contain both builtin and user variants 
\end{DoxySince}
\hypertarget{group__misc__functions_ga8a09a722bcccf27139640bde318310a7}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+builtin\+\_\+function\+\_\+args@{call\+\_\+builtin\+\_\+function\+\_\+args}}
\index{call\+\_\+builtin\+\_\+function\+\_\+args@{call\+\_\+builtin\+\_\+function\+\_\+args}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+builtin\+\_\+function\+\_\+args}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+builtin\+\_\+function\+\_\+args (
\begin{DoxyParamCaption}
\item[{string}]{name, }
\item[{\+\_\+\+\_\+7\+\_\+ softlist}]{vargs}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8a09a722bcccf27139640bde318310a7}


Calls a function and returns the return value, using the optional second argument as a list of arguments for the function. 


\begin{DoxyParams}{Parameters}
{\em name} & The name of the builtin function to call \\
\hline
{\em vargs} & Optionally a single argument to the function or a list of arguments to the function\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The value returned by the called function
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_ga8a09a722bcccf27139640bde318310a7}{call\_builtin\_function\_args}(\textcolor{stringliteral}{"func\_name"}, ($arg1, $arg2));
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em I\+N\+V\+A\+L\+I\+D-\/\+F\+U\+N\+C\+T\+I\+O\+N-\/\+A\+C\+C\+E\+S\+S} & Parse options do not allow access to the function \\
\hline
{\em N\+O-\/\+F\+U\+N\+C\+T\+I\+O\+N} & The function does not exist\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
The function called could also throw other exceptions
\end{DoxyNote}
\begin{DoxySince}{Since}
0.\+8.\+4 this function no longer restricts its search to builtin functions as as of \hyperlink{namespace_qore}{Qore} 0.\+8.\+4 builtin and user functions are stored identically internally; there is only one function implementation which can contain both builtin and user variants 
\end{DoxySince}
\hypertarget{group__misc__functions_gadb60673dad0c6cd7ec4fe1eec8c5dab8}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+function@{call\+\_\+function}}
\index{call\+\_\+function@{call\+\_\+function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+function}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+function (
\begin{DoxyParamCaption}
\item[{string}]{name, }
\item[{}]{...}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gadb60673dad0c6cd7ec4fe1eec8c5dab8}


Calls a function and returns the return value, passing the remaining arguments after the function name to the function. 


\begin{DoxyParams}{Parameters}
{\em name} & The name of the function to call \\
\hline
{\em ...} & Any optional arguments to the function\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The value returned by the called function
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_gadb60673dad0c6cd7ec4fe1eec8c5dab8}{call\_function}(\textcolor{stringliteral}{"func\_name"}, $arg1, $arg2);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em I\+N\+V\+A\+L\+I\+D-\/\+F\+U\+N\+C\+T\+I\+O\+N-\/\+A\+C\+C\+E\+S\+S} & Parse options do not allow access to the function \\
\hline
{\em N\+O-\/\+F\+U\+N\+C\+T\+I\+O\+N} & The function does not exist\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
The function called could also throw other exceptions 
\end{DoxyNote}
\hypertarget{group__misc__functions_gad84bc65c4a73c9a46b6481d3865a91ee}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+function@{call\+\_\+function}}
\index{call\+\_\+function@{call\+\_\+function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+function}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+function (
\begin{DoxyParamCaption}
\item[{code}]{f, }
\item[{}]{...}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad84bc65c4a73c9a46b6481d3865a91ee}


Calls the given \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} and returns the result, passing the remaining arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}. 


\begin{DoxyParams}{Parameters}
{\em f} & The \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} \\
\hline
{\em ...} & Any optional arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}\\
\hline
\end{DoxyParams}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_gadb60673dad0c6cd7ec4fe1eec8c5dab8}{call\_function}($call\_ref, $arg1, $arg2);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
The \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} called could also throw other exceptions 
\end{DoxyNote}
\hypertarget{group__misc__functions_ga6d920ba42e07061721bd201ce2564bb8}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+function\+\_\+args@{call\+\_\+function\+\_\+args}}
\index{call\+\_\+function\+\_\+args@{call\+\_\+function\+\_\+args}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+function\+\_\+args}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+function\+\_\+args (
\begin{DoxyParamCaption}
\item[{string}]{name, }
\item[{\+\_\+\+\_\+7\+\_\+ softlist}]{vargs}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6d920ba42e07061721bd201ce2564bb8}


Calls a function and returns the return value, using the optional second argument as a list of arguments for the function. 


\begin{DoxyParams}{Parameters}
{\em name} & The name of the function to call \\
\hline
{\em vargs} & Optionally a single argument to the function or a list of arguments to the function\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
The value returned by the called function
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_ga6d920ba42e07061721bd201ce2564bb8}{call\_function\_args}(\textcolor{stringliteral}{"func\_name"}, ($arg1, $arg2));
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em I\+N\+V\+A\+L\+I\+D-\/\+F\+U\+N\+C\+T\+I\+O\+N-\/\+A\+C\+C\+E\+S\+S} & Parse options do not allow access to the function \\
\hline
{\em N\+O-\/\+F\+U\+N\+C\+T\+I\+O\+N} & The function does not exist\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
The function called could also throw other exceptions 
\end{DoxyNote}
\hypertarget{group__misc__functions_gae1d16b3c77aa2f8b8433d9b75600370c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!call\+\_\+function\+\_\+args@{call\+\_\+function\+\_\+args}}
\index{call\+\_\+function\+\_\+args@{call\+\_\+function\+\_\+args}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{call\+\_\+function\+\_\+args}]{\setlength{\rightskip}{0pt plus 5cm}any Qore\+::call\+\_\+function\+\_\+args (
\begin{DoxyParamCaption}
\item[{code}]{f, }
\item[{\+\_\+\+\_\+7\+\_\+ softlist}]{vargs}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gae1d16b3c77aa2f8b8433d9b75600370c}


Calls the given \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} and returns the result, using the optional second argument as a list of arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}. 


\begin{DoxyParams}{Parameters}
{\em f} & The \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} \\
\hline
{\em vargs} & Optionally a single argument to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} or a list of arguments to the \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}\\
\hline
\end{DoxyParams}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my any $result = \hyperlink{group__misc__functions_ga6d920ba42e07061721bd201ce2564bb8}{call\_function\_args}($call\_ref, ($arg1, $arg2));
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
The \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure} called could also throw other exceptions 
\end{DoxyNote}
\hypertarget{group__misc__functions_ga51b949c2d20900fdc2e1b8e46988d2b1}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!decode\+\_\+url@{decode\+\_\+url}}
\index{decode\+\_\+url@{decode\+\_\+url}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{decode\+\_\+url}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::decode\+\_\+url (
\begin{DoxyParamCaption}
\item[{string}]{url}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga51b949c2d20900fdc2e1b8e46988d2b1}


Decodes percent numeric codes in a U\+R\+L string and returns the decoded string in U\+T\+F-\/8 encoding. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em url} & a U\+R\+L string with percent-\/encodings to decode\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the U\+R\+L string in U\+T\+F-\/8 encoding with all percent-\/encodings decoded
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $decoded\_url = \hyperlink{group__misc__functions_ga51b949c2d20900fdc2e1b8e46988d2b1}{decode\_url}($encoded\_url);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
percent decoding is made according to \href{http://tools.ietf.org/html/rfc3986#section-2.1}{\tt R\+F\+C 3986}
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{encode\+\_\+url()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga2f5349505d3d2563ef31f4d8b5c5f1b3}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!decode\+\_\+url@{decode\+\_\+url}}
\index{decode\+\_\+url@{decode\+\_\+url}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{decode\+\_\+url}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::decode\+\_\+url (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga2f5349505d3d2563ef31f4d8b5c5f1b3}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!encode\+\_\+url@{encode\+\_\+url}}
\index{encode\+\_\+url@{encode\+\_\+url}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{encode\+\_\+url}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::encode\+\_\+url (
\begin{DoxyParamCaption}
\item[{string}]{url, }
\item[{softbool}]{encode\+\_\+all = {\ttfamily False}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}


Encodes U\+R\+Ls by substituting {\ttfamily '\%'} characters with {\ttfamily '\%25'}, spaces ({\ttfamily '} ') with {\ttfamily '\%20'}, and non-\/ascii characters by percent-\/encoded representations. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em url} & a U\+R\+L string to encode \\
\hline
{\em encode\+\_\+all} & if \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}, then in addition to {\ttfamily '\%'}, spaces ({\ttfamily '} '), and non-\/ascii characters the following reserved characters (according to \href{http://tools.ietf.org/html/rfc3986}{\tt R\+F\+C 3986} are also encoded\+: {\ttfamily '!'}, {\ttfamily '$\ast$'}, {\ttfamily '\textbackslash{}''}, {\ttfamily '}(', {\ttfamily '})', {\ttfamily '};', {\ttfamily '}\+:', {\ttfamily '@'}, {\ttfamily '\&'}, {\ttfamily '='}, {\ttfamily '+'}, {\ttfamily '\$'}, {\ttfamily '},', {\ttfamily '/'}, {\ttfamily '}?', {\ttfamily '\#'}, {\ttfamily '}\mbox{[}', {\ttfamily '}\mbox{]}'\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the U\+R\+L string with encoded according to the arguments
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $encoded\_url = \hyperlink{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{encode\_url}($url);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga51b949c2d20900fdc2e1b8e46988d2b1}{decode\+\_\+url()}
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+9 
\end{DoxySince}
\hypertarget{group__misc__functions_gad1e87cdb4aded090b1801d952e018a50}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!exists@{exists}}
\index{exists@{exists}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{exists}]{\setlength{\rightskip}{0pt plus 5cm}bool Qore\+::exists (
\begin{DoxyParamCaption}
\item[{}]{...}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad1e87cdb4aded090b1801d952e018a50}


A function performing the same role as the \hyperlink{operators_exists}{exists operator}. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em ...} & if only a single argument is passed, then this function returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the single argument exists, \hyperlink{group__boolean__constants_ga9da2b9a8003cd3788e48305f8a00540f}{False} if not; otherwise is multiple arguments are passed to the function, it always returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}; this is to emulate the behavior of the \hyperlink{operators_exists}{exists operator}\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
if only a single argument is passed, then this function returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the single argument exists, \hyperlink{group__boolean__constants_ga9da2b9a8003cd3788e48305f8a00540f}{False} if not; otherwise is multiple arguments are passed to the function, it always returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}; this is to emulate the behavior of the \hyperlink{operators_exists}{exists operator}
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{bool} $b = \hyperlink{group__misc__functions_gad1e87cdb4aded090b1801d952e018a50}{exists}($val);
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga83615e15094fca9ffe868ee0d80cd002}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!exists\+Function@{exists\+Function}}
\index{exists\+Function@{exists\+Function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{exists\+Function}]{\setlength{\rightskip}{0pt plus 5cm}bool Qore\+::exists\+Function (
\begin{DoxyParamCaption}
\item[{string}]{name}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga83615e15094fca9ffe868ee0d80cd002}


Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the function exists in the current program's function name space. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em name} & the name of the function to check\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
\hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the function exists in the current program's function name space, \hyperlink{group__boolean__constants_ga9da2b9a8003cd3788e48305f8a00540f}{False} if not
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{bool} $b = \hyperlink{group__misc__functions_ga83615e15094fca9ffe868ee0d80cd002}{existsFunction}(\textcolor{stringliteral}{"func\_name"});
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gaa3aa518a4c17e2593c2773bc6b71af3c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!exists\+Function@{exists\+Function}}
\index{exists\+Function@{exists\+Function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{exists\+Function}]{\setlength{\rightskip}{0pt plus 5cm}bool Qore\+::exists\+Function (
\begin{DoxyParamCaption}
\item[{code}]{c}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaa3aa518a4c17e2593c2773bc6b71af3c}


Always returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}. 

This function variant is included for backwards-\/compatibility

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_NOOP}{N\+O\+O\+P}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em c} & a \hyperlink{expressions_call_reference}{call reference} or \hyperlink{expressions_closure}{closure}\+:\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
always returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} 
\end{DoxyReturn}
\hypertarget{group__misc__functions_gac6b3861f291cf4c2f62742fc8ec9b717}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!exists\+Function@{exists\+Function}}
\index{exists\+Function@{exists\+Function}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{exists\+Function}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::exists\+Function (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gac6b3861f291cf4c2f62742fc8ec9b717}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga5ae2be041abe7d02be8a2ccc67c0032f}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!function\+Type@{function\+Type}}
\index{function\+Type@{function\+Type}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{function\+Type}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ string Qore\+::function\+Type (
\begin{DoxyParamCaption}
\item[{string}]{name}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga5ae2be041abe7d02be8a2ccc67c0032f}


Returns {\ttfamily \char`\"{}builtin\char`\"{}} (for a builtin function), {\ttfamily \char`\"{}user\char`\"{}} (for a user function), or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} (if the function cannot be found) according to the function name passed. 


\begin{DoxyParams}{Parameters}
{\em name} & The function name to check \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
{\ttfamily \char`\"{}builtin\char`\"{}} (for a builtin function), {\ttfamily \char`\"{}user\char`\"{}} (for a user function), or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} (if the function cannot be found) according to the function name passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{string} $type = \hyperlink{group__misc__functions_ga5ae2be041abe7d02be8a2ccc67c0032f}{functionType}(\textcolor{stringliteral}{"print"});
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gaf46dfa4dc44e9e7091e981c87ebbe438}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!function\+Type@{function\+Type}}
\index{function\+Type@{function\+Type}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{function\+Type}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::function\+Type (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaf46dfa4dc44e9e7091e981c87ebbe438}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+byte@{get\+\_\+byte}}
\index{get\+\_\+byte@{get\+\_\+byte}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+byte}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+byte (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}


Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $byte = \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\_byte}($str, 2); # returns the third byte of the \textcolor{keywordtype}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
that for strings this function is not equivalent to the \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} for multi-\/byte character encodings, as this function works purely on bytes and the \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} operates on characters~\newline
~\newline
 Furthermore this function is identical to \hyperlink{group__misc__functions_ga3a6b906bee63eb28d20610da64fd5417}{get\+Byte()}, except this function has no \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant 
\end{DoxyNote}
\hypertarget{group__misc__functions_ga8a7ea9de612741d9bb26bf926d211c71}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+byte@{get\+\_\+byte}}
\index{get\+\_\+byte@{get\+\_\+byte}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+byte}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+byte (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8a7ea9de612741d9bb26bf926d211c71}


Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $byte = \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\_byte}($bin, 2); # returns the third byte of the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} \textcolor{keywordtype}{object}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
this function is equivalent to the more efficient \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} when used with a binary argument~\newline
~\newline
 Furthermore this function is identical to \hyperlink{group__misc__functions_ga3a6b906bee63eb28d20610da64fd5417}{get\+Byte()}, except this function has no \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant 
\end{DoxyNote}
\hypertarget{group__misc__functions_ga8f800bec17c55a15ec7255dedfa25c6d}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+default\+\_\+encoding@{get\+\_\+default\+\_\+encoding}}
\index{get\+\_\+default\+\_\+encoding@{get\+\_\+default\+\_\+encoding}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+default\+\_\+encoding}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::get\+\_\+default\+\_\+encoding (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8f800bec17c55a15ec7255dedfa25c6d}


Returns the name of the \hyperlink{character_encoding_default_encoding}{default character encoding}. 

\begin{DoxyReturn}{Returns}
the name of the \hyperlink{character_encoding_default_encoding}{default character encoding}
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $encoding = \hyperlink{group__misc__functions_ga8f800bec17c55a15ec7255dedfa25c6d}{get\_default\_encoding}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gafadcbf214ccffbde013894b330b7c7ae}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+ex\+\_\+pos@{get\+\_\+ex\+\_\+pos}}
\index{get\+\_\+ex\+\_\+pos@{get\+\_\+ex\+\_\+pos}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+ex\+\_\+pos}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::get\+\_\+ex\+\_\+pos (
\begin{DoxyParamCaption}
\item[{hash}]{ex}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gafadcbf214ccffbde013894b330b7c7ae}


returns a descriptive string for an exception location; the {\ttfamily source} and {\ttfamily offset} information will also be included in the string returned if present in the \hyperlink{exception_handling_exception_hash}{exception hash} argument 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
\textcolor{keywordflow}{try} \{
    \textcolor{keywordflow}{throw} \textcolor{stringliteral}{"oops"}, \hyperlink{group__string__functions_ga7a74be141f814ef286046c367b21091c}{sprintf}(\textcolor{stringliteral}{"arg %y is invalid"}, $arg);
\}
\textcolor{keywordflow}{catch} (\hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $ex) \{
    log(\textcolor{stringliteral}{"%s: %s: %s"}, \hyperlink{group__misc__functions_gafadcbf214ccffbde013894b330b7c7ae}{get\_ex\_pos}($ex), $ex.err, $ex.desc);
\}
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em ex} & an \hyperlink{exception_handling_exception_hash}{exception hash}\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a string describing the exception location (ex\+: {\ttfamily \char`\"{}sftp-\/poller.\+q\+:140\char`\"{}})
\end{DoxyReturn}
\begin{DoxySince}{Since}
Qore 0.\+8.\+7 
\end{DoxySince}
\hypertarget{group__misc__functions_ga6b1422bc842cbf53cf2bb53ef9322209}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+parse\+\_\+options@{get\+\_\+parse\+\_\+options}}
\index{get\+\_\+parse\+\_\+options@{get\+\_\+parse\+\_\+options}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+parse\+\_\+options}]{\setlength{\rightskip}{0pt plus 5cm}int Qore\+::get\+\_\+parse\+\_\+options (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6b1422bc842cbf53cf2bb53ef9322209}


returns the current \hyperlink{group__parse__options}{parse options} for the current \hyperlink{class_qore_1_1_program}{Program} object 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{int} $i = \hyperlink{group__misc__functions_ga6b1422bc842cbf53cf2bb53ef9322209}{get\_parse\_options}();
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyReturn}{Returns}
the current \hyperlink{group__parse__options}{parse options} for the current \hyperlink{class_qore_1_1_program}{Program} object
\end{DoxyReturn}
\begin{DoxySince}{Since}
Qore 0.\+8.\+7 
\end{DoxySince}
\hypertarget{group__misc__functions_gaf67d7ded1719f761d52819469b40aebc}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+qore\+\_\+library\+\_\+info@{get\+\_\+qore\+\_\+library\+\_\+info}}
\index{get\+\_\+qore\+\_\+library\+\_\+info@{get\+\_\+qore\+\_\+library\+\_\+info}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+qore\+\_\+library\+\_\+info}]{\setlength{\rightskip}{0pt plus 5cm}hash Qore\+::get\+\_\+qore\+\_\+library\+\_\+info (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaf67d7ded1719f761d52819469b40aebc}


Returns a hash of library build and version info. 

\begin{DoxyReturn}{Returns}
a hash of library build and version info with the following keys\+:
\begin{DoxyItemize}
\item {\ttfamily Platform\+O\+S\+:} The operating system used to build the Qore library
\item {\ttfamily Platform\+C\+P\+U\+:} The C\+P\+U used as a target for the Qore library build
\item {\ttfamily Version\+String\+:} The full version string for this version of the Qore library
\item {\ttfamily Version\+Major\+:} An integer giving the Qore library's major version number
\item {\ttfamily Version\+Minor\+:} An integer giving the Qore library's minor version number
\item {\ttfamily Version\+Sub\+:} An integer giving the Qore library's release version number
\item {\ttfamily Build\+:} An integer giving the Qore library's subversion revision number
\item {\ttfamily Build\+Host\+:} A string giving information about the host used to compile the Qore library
\item {\ttfamily Compiler\+:} The compiler used to build the Qore library
\item {\ttfamily Module\+Dir\+:} The module directory assumed by default in the Qore library
\item {\ttfamily C\+F\+L\+A\+G\+S\+:} The compiler flags used to compile the Qore library
\item {\ttfamily L\+D\+F\+L\+A\+G\+S\+:} The linker flags used to link the Qore library
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $h = \hyperlink{group__misc__functions_gaf67d7ded1719f761d52819469b40aebc}{get\_qore\_library\_info}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gaa1c1e9b47829b8139adb60a3f85947cf}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+qore\+\_\+option\+\_\+hash@{get\+\_\+qore\+\_\+option\+\_\+hash}}
\index{get\+\_\+qore\+\_\+option\+\_\+hash@{get\+\_\+qore\+\_\+option\+\_\+hash}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+qore\+\_\+option\+\_\+hash}]{\setlength{\rightskip}{0pt plus 5cm}hash Qore\+::get\+\_\+qore\+\_\+option\+\_\+hash (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaa1c1e9b47829b8139adb60a3f85947cf}


Returns a hash of hashes giving information about Qore library options for the current build. 

\begin{DoxyReturn}{Returns}
a hash of hashes giving information about Qore library options for the current build; the hash keys are the constant names and the values are hashes with the following keys\+:
\begin{DoxyItemize}
\item {\ttfamily option\+:} The string description of the option
\item {\ttfamily constant\+:} A string giving the name of the constant that has the boolean value for this option (equal to the hash key name)
\item {\ttfamily type\+:} The type of option
\item {\ttfamily value\+:} The boolean value of the option
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $h = \hyperlink{group__misc__functions_gaa1c1e9b47829b8139adb60a3f85947cf}{get\_qore\_option\_hash}();
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga46b20ef171a0c0af8d5760f46ebc7894}{get\+\_\+qore\+\_\+option\+\_\+list()}
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+4 
\end{DoxySince}
\hypertarget{group__misc__functions_ga46b20ef171a0c0af8d5760f46ebc7894}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+qore\+\_\+option\+\_\+list@{get\+\_\+qore\+\_\+option\+\_\+list}}
\index{get\+\_\+qore\+\_\+option\+\_\+list@{get\+\_\+qore\+\_\+option\+\_\+list}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+qore\+\_\+option\+\_\+list}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::get\+\_\+qore\+\_\+option\+\_\+list (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga46b20ef171a0c0af8d5760f46ebc7894}


Returns a list of hashes giving information about Qore library options for the current build. 

\begin{DoxyReturn}{Returns}
a list of hashes giving information about Qore library options for the current build; each hash will have the following keys\+:
\begin{DoxyItemize}
\item {\ttfamily option\+:} The string description of the option
\item {\ttfamily constant\+:} A string giving the name of the constant that has the boolean value for this option
\item {\ttfamily type\+:} The type of option
\item {\ttfamily value\+:} The boolean value of the option
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $l = \hyperlink{group__misc__functions_ga46b20ef171a0c0af8d5760f46ebc7894}{get\_qore\_option\_list}();
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gaa1c1e9b47829b8139adb60a3f85947cf}{get\+\_\+qore\+\_\+option\+\_\+hash()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga4730f5a695996be26efbfa9760417b1b}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+script\+\_\+dir@{get\+\_\+script\+\_\+dir}}
\index{get\+\_\+script\+\_\+dir@{get\+\_\+script\+\_\+dir}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+script\+\_\+dir}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ string Qore\+::get\+\_\+script\+\_\+dir (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga4730f5a695996be26efbfa9760417b1b}


Returns the name of the directory from which the current script was executed or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) 

\begin{DoxyReturn}{Returns}
the name of the directory from which the current script was executed or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc)
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga4730f5a695996be26efbfa9760417b1b}{get\_script\_dir}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gade1f45f4d12597822362d920c84695a5}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+script\+\_\+name@{get\+\_\+script\+\_\+name}}
\index{get\+\_\+script\+\_\+name@{get\+\_\+script\+\_\+name}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+script\+\_\+name}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ string Qore\+::get\+\_\+script\+\_\+name (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gade1f45f4d12597822362d920c84695a5}


Returns the filename of the current script if known or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) 

\begin{DoxyReturn}{Returns}
the filename of the current script if known or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc)
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_gade1f45f4d12597822362d920c84695a5}{get\_script\_name}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga3ebc5d7d350677395e4b89686ca335b4}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+script\+\_\+path@{get\+\_\+script\+\_\+path}}
\index{get\+\_\+script\+\_\+path@{get\+\_\+script\+\_\+path}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+script\+\_\+path}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ string Qore\+::get\+\_\+script\+\_\+path (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga3ebc5d7d350677395e4b89686ca335b4}


Returns the path (directory and filename) of the current script or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc) 

\begin{DoxyReturn}{Returns}
the path (directory and filename) of the current script or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if unknown (i.\+e. no parent script, script read from stdin, etc)
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga3ebc5d7d350677395e4b89686ca335b4}{get\_script\_path}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+16@{get\+\_\+word\+\_\+16}}
\index{get\+\_\+word\+\_\+16@{get\+\_\+word\+\_\+16}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+16}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+16 (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}


Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 2-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{get\_word\_16}($str, 2); # returns the third 2-byte (16-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{get\+\_\+word\+\_\+16\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gad19c4c14c864af9759effecbfef6d68a}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+16@{get\+\_\+word\+\_\+16}}
\index{get\+\_\+word\+\_\+16@{get\+\_\+word\+\_\+16}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+16}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+16 (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad19c4c14c864af9759effecbfef6d68a}


Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 2-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{get\_word\_16}($bin, 2); # returns the third 2-byte (16-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{get\+\_\+word\+\_\+16\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+16\+\_\+lsb@{get\+\_\+word\+\_\+16\+\_\+lsb}}
\index{get\+\_\+word\+\_\+16\+\_\+lsb@{get\+\_\+word\+\_\+16\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+16\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+16\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}


Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 2-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{get\_word\_16\_lsb}($str, 2); # returns the third 2-byte (16-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{get\+\_\+word\+\_\+16()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga28d6b93d58fb1df8615a9701fa10fe52}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+16\+\_\+lsb@{get\+\_\+word\+\_\+16\+\_\+lsb}}
\index{get\+\_\+word\+\_\+16\+\_\+lsb@{get\+\_\+word\+\_\+16\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+16\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+16\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga28d6b93d58fb1df8615a9701fa10fe52}


Returns the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 2-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 16-\/bit integer value at the given 2-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga8d9d7eb06b650954226a82502dcaa838}{get\_word\_16\_lsb}($bin, 2); # returns the third 2-byte (16-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga5802a4f147d02009947401dd92e3b197}{get\+\_\+word\+\_\+16()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+32@{get\+\_\+word\+\_\+32}}
\index{get\+\_\+word\+\_\+32@{get\+\_\+word\+\_\+32}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+32}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+32 (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\_word\_32}($str, 4); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function is identical to \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{get\+Word32()}, except this function has no \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{get\+\_\+word\+\_\+32\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga1124c85d897be618a9e61c1fbccd37d9}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+32@{get\+\_\+word\+\_\+32}}
\index{get\+\_\+word\+\_\+32@{get\+\_\+word\+\_\+32}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+32}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+32 (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga1124c85d897be618a9e61c1fbccd37d9}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\_word\_32}($bin, 2); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function is identical to \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{get\+Word32()}, except this function has no \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{get\+\_\+word\+\_\+32\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+32\+\_\+lsb@{get\+\_\+word\+\_\+32\+\_\+lsb}}
\index{get\+\_\+word\+\_\+32\+\_\+lsb@{get\+\_\+word\+\_\+32\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+32\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+32\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{get\_word\_32\_lsb}($str, 4); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function is identical to \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{get\+Word32()}, except this function has no \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga2269ca395fdfe9214039952c4cacf730}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+32\+\_\+lsb@{get\+\_\+word\+\_\+32\+\_\+lsb}}
\index{get\+\_\+word\+\_\+32\+\_\+lsb@{get\+\_\+word\+\_\+32\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+32\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+32\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga2269ca395fdfe9214039952c4cacf730}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_ga29b56ac9ee5c55bf8243b3060388be02}{get\_word\_32\_lsb}($bin, 2); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+64@{get\+\_\+word\+\_\+64}}
\index{get\+\_\+word\+\_\+64@{get\+\_\+word\+\_\+64}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+64}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+64 (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}


Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 8-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{get\_word\_64}($str, 4); # returns the third 8-byte (64-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{get\+\_\+word\+\_\+64\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga6fbc2c59ad0af1fe6a9e87b6f037d331}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+64@{get\+\_\+word\+\_\+64}}
\index{get\+\_\+word\+\_\+64@{get\+\_\+word\+\_\+64}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+64}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+64 (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6fbc2c59ad0af1fe6a9e87b6f037d331}


Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 8-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{get\_word\_64}($bin, 2); # returns the third 8-byte (64-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{get\+\_\+word\+\_\+64\+\_\+lsb()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+64\+\_\+lsb@{get\+\_\+word\+\_\+64\+\_\+lsb}}
\index{get\+\_\+word\+\_\+64\+\_\+lsb@{get\+\_\+word\+\_\+64\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+64\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+64\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}


Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 8-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{get\_word\_64\_lsb}($str, 4); # returns the third 8-byte (64-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{get\+\_\+word\+\_\+64()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga08294fc87d5f9d127cdd794085c59072}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+\_\+word\+\_\+64\+\_\+lsb@{get\+\_\+word\+\_\+64\+\_\+lsb}}
\index{get\+\_\+word\+\_\+64\+\_\+lsb@{get\+\_\+word\+\_\+64\+\_\+lsb}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+\_\+word\+\_\+64\+\_\+lsb}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+\_\+word\+\_\+64\+\_\+lsb (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga08294fc87d5f9d127cdd794085c59072}


Returns the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Least_significant_bit}{\tt L\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 8-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 64-\/bit integer value at the given 8-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gac260e3cfffb2c9ac8e69a1428183de01}{get\_word\_64\_lsb}($bin, 2); # returns the third 8-byte (64-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_gadf53ee1d46382bf4cb2c4fd12816a5c8}{get\+\_\+word\+\_\+64()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga3a6b906bee63eb28d20610da64fd5417}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Byte@{get\+Byte}}
\index{get\+Byte@{get\+Byte}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Byte}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+Byte (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga3a6b906bee63eb28d20610da64fd5417}


Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}, \hyperlink{code_flags_DEPRECATED}{D\+E\+P\+R\+E\+C\+A\+T\+E\+D}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $byte = \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\_byte}($str, 2); # returns the third byte of the \textcolor{keywordtype}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
that for strings this function is not equivalent to the \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} for multi-\/byte character encodings, as this function works purely on bytes and the \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} operates on characters~\newline
~\newline
 Furthermore this function is identical to \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\+\_\+byte()}, except this function has a \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySince}{Since}
Qore 0.\+8.\+4 marked as deprecated; use the \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\+\_\+byte()} function instead 
\end{DoxySince}
\hypertarget{group__misc__functions_gadfbef79c0c3442d2d7857f6ba1d56049}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Byte@{get\+Byte}}
\index{get\+Byte@{get\+Byte}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Byte}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::get\+Byte (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gadfbef79c0c3442d2d7857f6ba1d56049}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P}, \hyperlink{code_flags_DEPRECATED}{D\+E\+P\+R\+E\+C\+A\+T\+E\+D} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gad79fe036448819f5e392ef443b60b97d}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Byte@{get\+Byte}}
\index{get\+Byte@{get\+Byte}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Byte}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+Byte (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad79fe036448819f5e392ef443b60b97d}


Returns the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}, \hyperlink{code_flags_DEPRECATED}{D\+E\+P\+R\+E\+C\+A\+T\+E\+D}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the byte value at the given byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $byte = \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\_byte}($bin, 2); # returns the third byte of the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} \textcolor{keywordtype}{object}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
this function is equivalent to the more efficient \hyperlink{operators_list_element_operator}{\mbox{[}\mbox{]} operator} when used with a binary argument~\newline
~\newline
 Furthermore this function is identical to \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\+\_\+byte()}, except this function has a \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySince}{Since}
Qore 0.\+8.\+4 marked as deprecated; use the \hyperlink{group__misc__functions_ga24aed47f45573187b6644d5ec1a3aeb5}{get\+\_\+byte()} function instead 
\end{DoxySince}
\hypertarget{group__misc__functions_ga46b9c2df48897cb68e765cb6d66728ac}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Class\+Name@{get\+Class\+Name}}
\index{get\+Class\+Name@{get\+Class\+Name}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Class\+Name}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::get\+Class\+Name (
\begin{DoxyParamCaption}
\item[{object}]{obj}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga46b9c2df48897cb68e765cb6d66728ac}


Returns the class name of the object passed. 


\begin{DoxyParams}{Parameters}
{\em obj} & the object to get the class name of \\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the class name of the object passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $name = \hyperlink{group__misc__functions_ga46b9c2df48897cb68e765cb6d66728ac}{getClassName}($obj);
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga69cdaa7f57458a60221fbed9ac2feb38}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Class\+Name@{get\+Class\+Name}}
\index{get\+Class\+Name@{get\+Class\+Name}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Class\+Name}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::get\+Class\+Name (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga69cdaa7f57458a60221fbed9ac2feb38}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gaa1e2c9fc19fe68b7fe55e1004fadea31}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Feature\+List@{get\+Feature\+List}}
\index{get\+Feature\+List@{get\+Feature\+List}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Feature\+List}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::get\+Feature\+List (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaa1e2c9fc19fe68b7fe55e1004fadea31}


Returns a list of strings of the builtin and module-\/supplied features of \hyperlink{namespace_qore}{Qore}. 

\begin{DoxyReturn}{Returns}
a list of strings of the builtin and module-\/supplied features of \hyperlink{namespace_qore}{Qore}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $list = \hyperlink{group__misc__functions_gaa1e2c9fc19fe68b7fe55e1004fadea31}{getFeatureList}();
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Module\+Hash@{get\+Module\+Hash}}
\index{get\+Module\+Hash@{get\+Module\+Hash}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Module\+Hash}]{\setlength{\rightskip}{0pt plus 5cm}hash Qore\+::get\+Module\+Hash (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}


Returns a hash of hashes describing the currently-\/loaded Qore modules; the top-\/level hash keys are the module names. 

\begin{DoxyReturn}{Returns}
a hash of hashes describing the currently-\/loaded Qore modules; the top-\/level hash keys are the module names; the values are hashes with the following keys\+:
\begin{DoxyItemize}
\item {\ttfamily filename\+:} the path to the module
\item {\ttfamily name\+:} the name of the module
\item {\ttfamily desc\+:} the description of the module
\item {\ttfamily version\+:} the version of the module
\item {\ttfamily author\+:} the author of the module
\item {\ttfamily api\+\_\+major\+:} the major number of the Qore module A\+P\+I version the module support
\item {\ttfamily api\+\_\+minor\+:} the minor number of the Qore module A\+P\+I version the module support
\item {\ttfamily url\+:} the module's U\+R\+L
\item {\ttfamily license\+:} the module's license
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $mh = \hyperlink{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}{getModuleHash}();
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySince}{Since}
Qore 0.\+8.\+1 
\end{DoxySince}
\hypertarget{group__misc__functions_gac0f41a0baf9a10b14442be26403fe733}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Module\+List@{get\+Module\+List}}
\index{get\+Module\+List@{get\+Module\+List}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Module\+List}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::get\+Module\+List (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gac0f41a0baf9a10b14442be26403fe733}


Returns a list of hashes describing the currently-\/loaded Qore modules. 

\begin{DoxyReturn}{Returns}
a list of hashes describing the currently-\/loaded Qore modules; each element in the list is a hash with the following keys\+:
\begin{DoxyItemize}
\item {\ttfamily filename\+:} the path to the module
\item {\ttfamily name\+:} the name of the module
\item {\ttfamily desc\+:} the description of the module
\item {\ttfamily version\+:} the version of the module
\item {\ttfamily author\+:} the author of the module
\item {\ttfamily api\+\_\+major\+:} the major number of the Qore module A\+P\+I version the module support
\item {\ttfamily api\+\_\+minor\+:} the minor number of the Qore module A\+P\+I version the module support
\item {\ttfamily url\+:} the module's U\+R\+L
\item {\ttfamily license\+:} the module's license
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $list = \hyperlink{group__misc__functions_gac0f41a0baf9a10b14442be26403fe733}{getModuleList}();
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}{get\+Module\+Hash()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Word32@{get\+Word32}}
\index{get\+Word32@{get\+Word32}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Word32}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+Word32 (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}, \hyperlink{code_flags_DEPRECATED}{D\+E\+P\+R\+E\+C\+A\+T\+E\+D}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{getWord32}($str, 4); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_ga4f2b4292a08b8533d6425a1368258cf2}{string}
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function is identical to \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()}, except this function has a \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySince}{Since}
Qore 0.\+8.\+4 marked as deprecated; use the \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()} function instead 
\end{DoxySince}
\hypertarget{group__misc__functions_ga771e2f1f122ccd8574354abdff42c192}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Word32@{get\+Word32}}
\index{get\+Word32@{get\+Word32}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Word32}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ int Qore\+::get\+Word32 (
\begin{DoxyParamCaption}
\item[{binary}]{b, }
\item[{softint}]{offset = {\ttfamily 0}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga771e2f1f122ccd8574354abdff42c192}


Returns the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data. 

This function assumes \href{http://en.wikipedia.org/wiki/Most_significant_bit}{\tt M\+S\+B byte order} when retrieving the value from the data

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}, \hyperlink{code_flags_DEPRECATED}{D\+E\+P\+R\+E\+C\+A\+T\+E\+D}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em b} & the data to process \\
\hline
{\em offset} & the 4-\/byte offset of the data to retrieve (the first value is at offset 0)\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the 32-\/bit integer value at the given 4-\/byte offset (the first value is at offset 0) or \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} if the offset is not legal for the given data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\textcolor{keywordtype}{int} $val = \hyperlink{group__misc__functions_gaed6fd3c7569dbd820cff0fc1e23db555}{getWord32}($bin, 2); # returns the third 4-byte (32-bit) value in the 
      \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} object
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function is identical to \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()}, except this function has a \hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} variant
\end{DoxyNote}
\begin{DoxySince}{Since}
Qore 0.\+8.\+4 marked as deprecated; use the \hyperlink{group__misc__functions_gae5d20bf535d84eee3ae17402b3ac4ec7}{get\+\_\+word\+\_\+32()} function instead 
\end{DoxySince}
\hypertarget{group__misc__functions_ga11bb1ea838d7c14802f3810ed0cbfdb2}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!get\+Word32@{get\+Word32}}
\index{get\+Word32@{get\+Word32}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{get\+Word32}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::get\+Word32 (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga11bb1ea838d7c14802f3810ed0cbfdb2}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gae5e23d5903ee2b32bb4925b756607cf9}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!has\+\_\+key@{has\+\_\+key}}
\index{has\+\_\+key@{has\+\_\+key}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{has\+\_\+key}]{\setlength{\rightskip}{0pt plus 5cm}bool Qore\+::has\+\_\+key (
\begin{DoxyParamCaption}
\item[{hash}]{h, }
\item[{string}]{key}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gae5e23d5903ee2b32bb4925b756607cf9}


Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the given key exists in the hash (does not necessarily have to have a value assigned); exceptions are only raised if string encoding errors are encountered. 


\begin{DoxyParams}{Parameters}
{\em h} & the hash to check \\
\hline
{\em key} & the key name to check; this value will be converted to the \hyperlink{character_encoding_default_encoding}{default character encoding} to check the hash\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
\hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the given key exists in the hash (does not necessarily have to have a value assigned), \hyperlink{group__boolean__constants_ga9da2b9a8003cd3788e48305f8a00540f}{False} if the key is not present at all
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{bool} $b = \hyperlink{group__misc__functions_gae5e23d5903ee2b32bb4925b756607cf9}{has\_key}($hash, \textcolor{stringliteral}{"key"});
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em E\+N\+C\+O\+D\+I\+N\+G-\/\+C\+O\+N\+V\+E\+R\+S\+I\+O\+N-\/\+E\+R\+R\+O\+R} & this error is thrown if the given key cannot be converted to the \hyperlink{character_encoding_default_encoding}{default character encoding} \\
\hline
\end{DoxyExceptions}
\hypertarget{group__misc__functions_ga5cf258d64631c0422ee15e0796361b28}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!has\+\_\+key@{has\+\_\+key}}
\index{has\+\_\+key@{has\+\_\+key}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{has\+\_\+key}]{\setlength{\rightskip}{0pt plus 5cm}bool Qore\+::has\+\_\+key (
\begin{DoxyParamCaption}
\item[{object}]{obj, }
\item[{string}]{key}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga5cf258d64631c0422ee15e0796361b28}


Returns \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True} if the given key exists in the object (does not necessarily have to have a value assigned); exceptions are only raised if string encoding errors are encountered or in case of object access errors. 

\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{bool} $b = \hyperlink{group__misc__functions_gae5e23d5903ee2b32bb4925b756607cf9}{has\_key}($obj, \textcolor{stringliteral}{"key"});
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em E\+N\+C\+O\+D\+I\+N\+G-\/\+C\+O\+N\+V\+E\+R\+S\+I\+O\+N-\/\+E\+R\+R\+O\+R} & this error is thrown if the given key cannot be converted to the \hyperlink{character_encoding_default_encoding}{default character encoding}\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
object access exceptions could also be raised 
\end{DoxyNote}
\hypertarget{group__misc__functions_ga4fdc10fe7c8f77e24432ae2e435f9211}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!hash\+\_\+values@{hash\+\_\+values}}
\index{hash\+\_\+values@{hash\+\_\+values}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{hash\+\_\+values}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::hash\+\_\+values (
\begin{DoxyParamCaption}
\item[{hash}]{h}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga4fdc10fe7c8f77e24432ae2e435f9211}


Returns a list of all the values in the hash argument passed. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em h} & a hash to get all the values of\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a list of all the values in the hash argument passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $vl = \hyperlink{group__misc__functions_ga4fdc10fe7c8f77e24432ae2e435f9211}{hash\_values}($vl);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
equivalent to \hyperlink{class_qore_1_1zzz8hashzzz9_acba59a98364e7bb083557449d8c5e689}{Qore\+::zzz8hashzzz9\+::values()}
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{class_qore_1_1zzz8hashzzz9_a4490151663b186b98f31cd99d45f5f8a}{Qore\+::zzz8hashzzz9\+::keys()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga6f07280e7c9ab676913b6fcb84588610}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!hash\+\_\+values@{hash\+\_\+values}}
\index{hash\+\_\+values@{hash\+\_\+values}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{hash\+\_\+values}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::hash\+\_\+values (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6f07280e7c9ab676913b6fcb84588610}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga635c21b4901af8accbf5729682b90f20}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!hextoint@{hextoint}}
\index{hextoint@{hextoint}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{hextoint}]{\setlength{\rightskip}{0pt plus 5cm}int Qore\+::hextoint (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga635c21b4901af8accbf5729682b90f20}


Returns an integer for a hexadecimal string value; throws an exception if non-\/hex digits are found. 


\begin{DoxyParams}{Parameters}
{\em str} & a string of hexadecimal digits (like {\ttfamily \char`\"{}6d4f84e0\char`\"{}}; with or without leading {\ttfamily \char`\"{}x\char`\"{}} or {\ttfamily \char`\"{}0x\char`\"{}})\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the base-\/10 integer corresponding to the argument
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{int} $i = \hyperlink{group__misc__functions_ga635c21b4901af8accbf5729682b90f20}{hextoint}(\textcolor{stringliteral}{"ab3d4e0f12"});
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em P\+A\+R\+S\+E-\/\+H\+E\+X-\/\+E\+R\+R\+O\+R} & invalid hex digit found \\
\hline
\end{DoxyExceptions}
\hypertarget{group__misc__functions_ga54d9807bf59a9e97284b12542a4c3ec6}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!hextoint@{hextoint}}
\index{hextoint@{hextoint}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{hextoint}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::hextoint (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga54d9807bf59a9e97284b12542a4c3ec6}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gac6f51f8c4de37bc139346d6059961148}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!html\+\_\+decode@{html\+\_\+decode}}
\index{html\+\_\+decode@{html\+\_\+decode}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{html\+\_\+decode}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::html\+\_\+decode (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gac6f51f8c4de37bc139346d6059961148}


Returns a string with any H\+T\+M\+L escape codes translated to the original characters. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the argument to decode\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the string passed as an argument with any H\+T\+M\+L escape codes translated to the original characters
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_gac6f51f8c4de37bc139346d6059961148}{html\_decode}(\textcolor{stringliteral}{"&lt;hello&gt;"}); # returns \textcolor{stringliteral}{"<hello>"}
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gad95ece28621404a42cf5e3f80193c84d}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!html\+\_\+decode@{html\+\_\+decode}}
\index{html\+\_\+decode@{html\+\_\+decode}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{html\+\_\+decode}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::html\+\_\+decode (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad95ece28621404a42cf5e3f80193c84d}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga98e1d9690329e8c94f88b833af36ef72}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!html\+\_\+encode@{html\+\_\+encode}}
\index{html\+\_\+encode@{html\+\_\+encode}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{html\+\_\+encode}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::html\+\_\+encode (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga98e1d9690329e8c94f88b833af36ef72}


Returns a string with characters needing H\+T\+M\+L escaping translated to H\+T\+M\+L escape codes. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the argument to process\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the string passed as an argument with characters needing H\+T\+M\+L escaping translated to H\+T\+M\+L escape codes
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga98e1d9690329e8c94f88b833af36ef72}{html\_encode}(\textcolor{stringliteral}{"<hello>"}); # returns \textcolor{stringliteral}{"&lt;hello&gt;"}
\end{DoxyCode}
 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga26f2cfc2d0d972642e82eedc09d097cc}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!html\+\_\+encode@{html\+\_\+encode}}
\index{html\+\_\+encode@{html\+\_\+encode}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{html\+\_\+encode}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::html\+\_\+encode (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga26f2cfc2d0d972642e82eedc09d097cc}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gae8e72e38355f6fcd037ca65945377c96}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!load\+\_\+module@{load\+\_\+module}}
\index{load\+\_\+module@{load\+\_\+module}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{load\+\_\+module}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::load\+\_\+module (
\begin{DoxyParamCaption}
\item[{string}]{name}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gae8e72e38355f6fcd037ca65945377c96}


Loads in a Qore module at run-\/time. 

If a feature with the same name already exists, then this feature's code is imported into the current \hyperlink{class_qore_1_1_program}{Program} object if necessary and no further action is taken.

Note that modules providing objects resolved at parse time (classes, constants, functions, etc) must be loaded with the \hyperlink{parse_directives_requires}{\%requires directive} instead, unless all references to the objects provided by the module will be made in code embedded in child \hyperlink{class_qore_1_1_program}{Program} objects.

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gaccf9af08f7acb25e66b777dcb4c4563b}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+M\+O\+D\+U\+L\+E\+S}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em name} & either a feature name (a module will be searched with this feature name) or a path to a module to load\\
\hline
\end{DoxyParams}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
\hyperlink{group__misc__functions_gae8e72e38355f6fcd037ca65945377c96}{load\_module}(\textcolor{stringliteral}{"mysql"});
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em L\+O\+A\+D-\/\+M\+O\+D\+U\+L\+E-\/\+E\+R\+R\+O\+R} & module cannot be loaded\+: A\+P\+I incompatibility, module defines symbols already defined in the target object, etc\\
\hline
\end{DoxyExceptions}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga8403cfbf9de02c113a9f0dcfb58f4314}{get\+Module\+Hash()}, \hyperlink{group__misc__functions_gaa1e2c9fc19fe68b7fe55e1004fadea31}{get\+Feature\+List()}
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+7 this function can also be used in user module code 
\end{DoxySince}
\hypertarget{group__misc__functions_ga366da9b19ed9b6fb4936f5e5a2ff3663}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!load\+\_\+module@{load\+\_\+module}}
\index{load\+\_\+module@{load\+\_\+module}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{load\+\_\+module}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::load\+\_\+module (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga366da9b19ed9b6fb4936f5e5a2ff3663}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gaccf9af08f7acb25e66b777dcb4c4563b}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+M\+O\+D\+U\+L\+E\+S}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga302de285f031c3dd4b059df3494bd21c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Base64\+String@{make\+Base64\+String}}
\index{make\+Base64\+String@{make\+Base64\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Base64\+String}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::make\+Base64\+String (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{maxlinelen = {\ttfamily -\/1}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga302de285f031c3dd4b059df3494bd21c}


Returns a base64-\/encoded representation of a string. 

Implementation based on \href{http://www.ietf.org/rfc/rfc1421.txt}{\tt R\+F\+C-\/1421} and \href{http://www.ietf.org/rfc/rfc2045.txt}{\tt R\+F\+C-\/2045}

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string to encode \\
\hline
{\em maxlinelen} & the maximum length of a line in the resulting output string in bytes; if this value is $>$ 0 then output lines will be separated by C\+R\+L\+F characters\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the base64-\/encoded string of the data passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $base64 = \hyperlink{group__misc__functions_ga302de285f031c3dd4b059df3494bd21c}{makeBase64String}($data, 64);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySince}{Since}
the maxlinelen parameter was added in Qore 0.\+8.\+4
\end{DoxySince}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{class_qore_1_1zzz8stringzzz9_a13b13f9681a94272d0e16371d2f22d90}{Qore\+::zzz8stringzzz9\+::to\+Base64()}
\item \hyperlink{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{make\+Hex\+String(string)} 
\end{DoxyItemize}
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga511ce458d13dfbea8c22ece63c315bb7}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Base64\+String@{make\+Base64\+String}}
\index{make\+Base64\+String@{make\+Base64\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Base64\+String}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::make\+Base64\+String (
\begin{DoxyParamCaption}
\item[{binary}]{bin, }
\item[{softint}]{maxlinelen = {\ttfamily -\/1}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga511ce458d13dfbea8c22ece63c315bb7}


Returns a base64-\/encoded representation of a binary object. 

Implementation based on \href{http://www.ietf.org/rfc/rfc1421.txt}{\tt R\+F\+C-\/1421} and \href{http://www.ietf.org/rfc/rfc2045.txt}{\tt R\+F\+C-\/2045}

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em bin} & the data to encode \\
\hline
{\em maxlinelen} & the maximum length of a line in the resulting output string in bytes; if this value is $>$ 0 then output lines will be separated by C\+R\+L\+F characters\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the base64-\/encoded string of the data passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $base64 = \hyperlink{group__misc__functions_ga302de285f031c3dd4b059df3494bd21c}{makeBase64String}($data, 64);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySince}{Since}
the maxlinelen parameter was added in Qore 0.\+8.\+4
\end{DoxySince}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{class_qore_1_1zzz8binaryzzz9_ab30735fae927ea3be3e3a710574ff486}{Qore\+::zzz8binaryzzz9\+::to\+Base64()}
\item \hyperlink{group__misc__functions_gaafe286db27d58cea75749c1bdabb5ad0}{make\+Hex\+String(binary)} 
\end{DoxyItemize}
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga1d5d34fd58d766f2eacde5701f5a99ae}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Base64\+String@{make\+Base64\+String}}
\index{make\+Base64\+String@{make\+Base64\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Base64\+String}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::make\+Base64\+String (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga1d5d34fd58d766f2eacde5701f5a99ae}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Hex\+String@{make\+Hex\+String}}
\index{make\+Hex\+String@{make\+Hex\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Hex\+String}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::make\+Hex\+String (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}


Returns a hex-\/encoded representation of a string. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_CONSTANT}{C\+O\+N\+S\+T\+A\+N\+T}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & the string to encode\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a string of hex digits repsenting the bytes of the argument passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{makeHexString}($str2);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{class_qore_1_1zzz8stringzzz9_af4a4f62237f079383098441132967527}{Qore\+::zzz8stringzzz9\+::to\+Hex()}
\item make\+Base64\+String(string)
\item \hyperlink{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{parse\+Hex\+String()} 
\end{DoxyItemize}
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gaafe286db27d58cea75749c1bdabb5ad0}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Hex\+String@{make\+Hex\+String}}
\index{make\+Hex\+String@{make\+Hex\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Hex\+String}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::make\+Hex\+String (
\begin{DoxyParamCaption}
\item[{binary}]{bin}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaafe286db27d58cea75749c1bdabb5ad0}


Returns a hex-\/encoded representation of a binary object. 


\begin{DoxyParams}{Parameters}
{\em bin} & the binary object to encode\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a string of hex digits repsenting the bytes of the argument passed
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{makeHexString}($bin);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{class_qore_1_1zzz8binaryzzz9_ada0665f689a4787b2697c1ff399b7cac}{Qore\+::zzz8binaryzzz9\+::to\+Hex()}
\item make\+Base64\+String(binary)
\item \hyperlink{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{parse\+Hex\+String()} 
\end{DoxyItemize}
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gacb04ca5bd37d873b867186c4da295f0c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!make\+Hex\+String@{make\+Hex\+String}}
\index{make\+Hex\+String@{make\+Hex\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{make\+Hex\+String}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::make\+Hex\+String (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gacb04ca5bd37d873b867186c4da295f0c}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga17bc2cdb62ca121ae990e497e609349d}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse@{parse}}
\index{parse@{parse}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ hash Qore\+::parse (
\begin{DoxyParamCaption}
\item[{string}]{code, }
\item[{string}]{label, }
\item[{\+\_\+\+\_\+7\+\_\+ softint}]{warning\+\_\+mask, }
\item[{\+\_\+\+\_\+7\+\_\+ string}]{source, }
\item[{\+\_\+\+\_\+7\+\_\+ softint}]{offset, }
\item[{softbool}]{format\+\_\+label = {\ttfamily True}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga17bc2cdb62ca121ae990e497e609349d}


Adds the text passed to the current program's code, tagged with the given label. 

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gab1337f461ab4a90df9b39a7f1b6cc2b0}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+E\+M\+B\+E\+D\+D\+E\+D\+\_\+\+L\+O\+G\+I\+C}, \hyperlink{group__parse__options_ga094a2d1f503a2b1e9abbe11b0d47cc6e}{Qore\+::\+P\+O\+\_\+\+I\+N\+\_\+\+M\+O\+D\+U\+L\+E}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em code} & the string of Qore source code to parse; the parsed code will be added to the current program \\
\hline
{\em label} & a label identifying the code or the code's source \\
\hline
{\em warning\+\_\+mask} & An optional warning mask; see \hyperlink{group__warning__constants}{Warning Constants} for values to combine by binary-\/or; if this arguments is 0 or not given then no warnings will be checked or issued and the return value will always be \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} \\
\hline
{\em source} & An optional source file name for the code being parsed; this is useful if sections of a file are parsed \\
\hline
{\em offset} & An optional line offset for use with the {\itshape source} parameter; this gives the line offset in the file to the code being parsed \\
\hline
{\em format\+\_\+label} & If this argument is \hyperlink{group__boolean__constants_ga3ba2df91713a6249449347131ea526c3}{True}, then the label is formatted as {\ttfamily \char`\"{}$<$run-\/time-\/loaded\+: label$>$\char`\"{}}; if \hyperlink{group__boolean__constants_ga9da2b9a8003cd3788e48305f8a00540f}{False}, then it is passed as-\/is\\
\hline
\end{DoxyParams}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
\hyperlink{group__misc__functions_ga17bc2cdb62ca121ae990e497e609349d}{parse}($code, $filename);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
This function could throw many parse exceptions which are not enumerated here; any parse errors will result in an appropriate exception.
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}

\begin{DoxyItemize}
\item \hyperlink{class_qore_1_1_program_a0715fb41ec36cd5648d6ec2baeb79f43}{Qore\+::\+Program\+::parse()}
\item \hyperlink{class_qore_1_1_program_a9afe5b8571dae845c49cd1f5f40c3722}{Qore\+::\+Program\+::parse\+Pending()}
\end{DoxyItemize}
\end{DoxySeeAlso}
\begin{DoxySince}{Since}
Qore 0.\+8.\+7 the optional {\itshape warning\+\_\+mask}, {\itshape source}, {\itshape offset}, and {\itshape format\+\_\+label} arguments were added; also label formatting was added; these changes were made to align the functionality of this function with the \hyperlink{class_qore_1_1_program_a0715fb41ec36cd5648d6ec2baeb79f43}{Program\+:\+:parse()} and \hyperlink{class_qore_1_1_program_a9afe5b8571dae845c49cd1f5f40c3722}{Program\+:\+:parse\+Pending()} methods 
\end{DoxySince}
\hypertarget{group__misc__functions_ga6c7d460b97c3c862717b052355985ded}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse@{parse}}
\index{parse@{parse}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::parse (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6c7d460b97c3c862717b052355985ded}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Restrictions\+:}
\hyperlink{group__parse__options_gab1337f461ab4a90df9b39a7f1b6cc2b0}{Qore\+::\+P\+O\+\_\+\+N\+O\+\_\+\+E\+M\+B\+E\+D\+D\+E\+D\+\_\+\+L\+O\+G\+I\+C}, \hyperlink{group__parse__options_ga094a2d1f503a2b1e9abbe11b0d47cc6e}{Qore\+::\+P\+O\+\_\+\+I\+N\+\_\+\+M\+O\+D\+U\+L\+E}
\end{DoxyParagraph}
\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga622e19abea9bd621927bce830b5df09d}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+\_\+url@{parse\+\_\+url}}
\index{parse\+\_\+url@{parse\+\_\+url}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+\_\+url}]{\setlength{\rightskip}{0pt plus 5cm}hash Qore\+::parse\+\_\+url (
\begin{DoxyParamCaption}
\item[{string}]{url, }
\item[{bool}]{keep\+\_\+brackets = {\ttfamily False}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga622e19abea9bd621927bce830b5df09d}


Parses a U\+R\+L string and returns a hash of the components; throws an exception if the string cannot be parsed as a U\+R\+L. 


\begin{DoxyParams}{Parameters}
{\em url} & the U\+R\+L to parse (ex\+: {\ttfamily \char`\"{}https\+://user\+:pass@host\+:8080/path\char`\"{}}); either a hostname or path is required at a minimum or a {\ttfamily P\+A\+R\+S\+E-\/\+U\+R\+L-\/\+E\+R\+R\+O\+R} exception is raised \\
\hline
{\em keep\+\_\+brackets} & if this argument is true then if the hostname or address is enclosed in square brackets, then the brackets will be included in the {\ttfamily \char`\"{}host\char`\"{}} key output as well; square brackets are used by some Qore methods to denote I\+Pv6 addresses; for example see \hyperlink{class_qore_1_1_socket_a7e0dc386a95c3c6a0e1cc12269d4374b}{Socket\+:\+:connect()}\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a hash of the components of the U\+R\+L with the following keys (if data in the U\+R\+L is present; note that at least either the {\ttfamily \char`\"{}host\char`\"{}} or the {\ttfamily \char`\"{}path\char`\"{}} keys will always be returned if no {\ttfamily P\+A\+R\+S\+E-\/\+U\+R\+L-\/\+E\+R\+R\+O\+R} is raised)\+:
\begin{DoxyItemize}
\item {\ttfamily protocol\+:} the scheme in the U\+R\+L (ex\+: {\ttfamily \char`\"{}http\char`\"{}})
\item {\ttfamily path\+:} any path given in the U\+R\+L; the path will be prefixed by {\ttfamily \char`\"{}/\char`\"{}} if a hostname is found in the U\+R\+L argument string, otherwise it will not if it was not given as such in the argument string
\item {\ttfamily username\+:} any username given in the U\+R\+L
\item {\ttfamily password\+:} any password given in the U\+R\+L
\item {\ttfamily host\+:} any hostname given in the U\+R\+L; note that this key will be given if no other information can be found in the U\+R\+L argument and the U\+R\+L argument string has no {\ttfamily \char`\"{}/\char`\"{}} characters; depending on the usage context for this function, this may actually be a filename
\item {\ttfamily port\+:} any port number given in the U\+R\+L
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $hash = \hyperlink{group__misc__functions_ga622e19abea9bd621927bce830b5df09d}{parse\_url}($url\_string);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em P\+A\+R\+S\+E-\/\+U\+R\+L-\/\+E\+R\+R\+O\+R} & The U\+R\+L string given could not be parsed\\
\hline
\end{DoxyExceptions}
\begin{DoxyNote}{Note}
U\+R\+Ls with U\+N\+I\+X sockets are generally supported in \hyperlink{namespace_qore}{Qore} with the following syntax\+: {\ttfamily scheme\+://socket=$<$url\+\_\+encoded\+\_\+path$>$/path}, where {\ttfamily url\+\_\+encoded\+\_\+path} is a path with U\+R\+L-\/encoding as performed by \hyperlink{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{encode\+\_\+url()}; for example\+: {\ttfamily \char`\"{}http\+://socket=\%2ftmp\%socket-\/dir\%2fsocket-\/file-\/1/url/path\char`\"{}}; this allows a filesystem path to be used in the host portion of the U\+R\+L and for the U\+R\+L to include a U\+R\+L path as well.
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga6acb2a9487067027a3bdb0d19e2af5fb}{parse\+U\+R\+L()} for a version of this function that does not throw exceptions if the U\+R\+L cannot be parsed 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Base64\+String@{parse\+Base64\+String}}
\index{parse\+Base64\+String@{parse\+Base64\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Base64\+String}]{\setlength{\rightskip}{0pt plus 5cm}binary Qore\+::parse\+Base64\+String (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}


Parses a base64 encoded string and returns a binary object of the decoded data. 

Implementation based on \href{http://www.ietf.org/rfc/rfc1421.txt}{\tt R\+F\+C-\/1421} and \href{http://www.ietf.org/rfc/rfc2045.txt}{\tt R\+F\+C-\/2045}


\begin{DoxyParams}{Parameters}
{\em str} & the base64-\/encoded input data to decode\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a binary object of the decoded data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} $bin = \hyperlink{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{parseBase64String}($base64\_string);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em B\+A\+S\+E64-\/\+P\+A\+R\+S\+E-\/\+E\+R\+R\+O\+R} & A syntax error occurred parsing the base64 string (invalid character, etc)\\
\hline
\end{DoxyExceptions}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{parse\+Hex\+String()}, \hyperlink{group__misc__functions_ga1f1a63790a7c60a3a61c5d1569fe4e4c}{parse\+Base64\+String\+To\+String()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga0c3bdfd8fb3a29af0d3bcd0ed3a05eb0}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Base64\+String@{parse\+Base64\+String}}
\index{parse\+Base64\+String@{parse\+Base64\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Base64\+String}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::parse\+Base64\+String (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga0c3bdfd8fb3a29af0d3bcd0ed3a05eb0}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga1f1a63790a7c60a3a61c5d1569fe4e4c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Base64\+String\+To\+String@{parse\+Base64\+String\+To\+String}}
\index{parse\+Base64\+String\+To\+String@{parse\+Base64\+String\+To\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Base64\+String\+To\+String}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::parse\+Base64\+String\+To\+String (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{\+\_\+\+\_\+7\+\_\+ string}]{encoding}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga1f1a63790a7c60a3a61c5d1569fe4e4c}


Parses a base64 encoded string and returns a string of the decoded data. 

Implementation based on \href{http://www.ietf.org/rfc/rfc1421.txt}{\tt R\+F\+C-\/1421} and \href{http://www.ietf.org/rfc/rfc2045.txt}{\tt R\+F\+C-\/2045}


\begin{DoxyParams}{Parameters}
{\em str} & the base64-\/encoded input data to decode \\
\hline
{\em encoding} & the character encoding tag for the string return value; if not present, the \hyperlink{character_encoding_default_encoding}{default character encoding} is assumed.\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a string of the decoded data tagged with the given encoding
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{parseBase64String}($base64\_string);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em B\+A\+S\+E64-\/\+P\+A\+R\+S\+E-\/\+E\+R\+R\+O\+R} & A syntax error occurred parsing the base64 string (invalid character, etc)\\
\hline
\end{DoxyExceptions}
\begin{DoxySince}{Since}
the encoding parameter was added in Qore 0.\+8.\+4
\end{DoxySince}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{parse\+Base64\+String()} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga8851e308445e0388408b8b2cca344088}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Base64\+String\+To\+String@{parse\+Base64\+String\+To\+String}}
\index{parse\+Base64\+String\+To\+String@{parse\+Base64\+String\+To\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Base64\+String\+To\+String}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::parse\+Base64\+String\+To\+String (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga8851e308445e0388408b8b2cca344088}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Hex\+String@{parse\+Hex\+String}}
\index{parse\+Hex\+String@{parse\+Hex\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Hex\+String}]{\setlength{\rightskip}{0pt plus 5cm}binary Qore\+::parse\+Hex\+String (
\begin{DoxyParamCaption}
\item[{string}]{hexstr}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}


Parses a hex-\/encoded string and returns the binary object. 


\begin{DoxyParams}{Parameters}
{\em hexstr} & a string of an even-\/number of only hexadecimal digits\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a binary object of the decoded data
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \hyperlink{group__type__conversion__functions_gaf11c7f5c43ced1e9b95bd2270ee87ed9}{binary} $bin = \hyperlink{group__misc__functions_ga74fed7603d2176dd5d433d3fae02ad9f}{parseHexString}($hex\_string);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em P\+A\+R\+S\+E-\/\+H\+E\+X-\/\+E\+R\+R\+O\+R} & A syntax error occurred parsing the hex string (odd number of digits, invalid hex character, etc)\\
\hline
\end{DoxyExceptions}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga1e6e24f780713c4d10cb9b98fa45cd35}{parse\+Base64\+String()} 

\hyperlink{group__misc__functions_gae4ca24e1000d327df636f75c7bf4f00c}{make\+Hex\+String()}; 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga64ee3ae01383697ae0174fd0cf6cbc5e}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+Hex\+String@{parse\+Hex\+String}}
\index{parse\+Hex\+String@{parse\+Hex\+String}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+Hex\+String}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::parse\+Hex\+String (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga64ee3ae01383697ae0174fd0cf6cbc5e}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga6acb2a9487067027a3bdb0d19e2af5fb}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+U\+R\+L@{parse\+U\+R\+L}}
\index{parse\+U\+R\+L@{parse\+U\+R\+L}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+U\+R\+L}]{\setlength{\rightskip}{0pt plus 5cm}\+\_\+\+\_\+7\+\_\+ hash Qore\+::parse\+U\+R\+L (
\begin{DoxyParamCaption}
\item[{string}]{url, }
\item[{bool}]{keep\+\_\+brackets = {\ttfamily False}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga6acb2a9487067027a3bdb0d19e2af5fb}


Parses a U\+R\+L string and returns a hash of the components; if the U\+R\+L cannot be parsed then \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} is returned. 


\begin{DoxyParams}{Parameters}
{\em url} & the U\+R\+L to parse (ex\+: {\ttfamily \char`\"{}https\+://user\+:pass@host\+:8080/path\char`\"{}}); either a hostname or path is required at a minimum or the function will return \hyperlink{basic_data_types_nothing}{N\+O\+T\+H\+I\+N\+G} \\
\hline
{\em keep\+\_\+brackets} & if this argument is true then if the hostname or address is enclosed in square brackets, then the brackets will be included in the {\ttfamily \char`\"{}host\char`\"{}} key output as well; square brackets are used by some Qore methods to denote I\+Pv6 addresses; for example see \hyperlink{class_qore_1_1_socket_a7e0dc386a95c3c6a0e1cc12269d4374b}{Socket\+:\+:connect()}\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
a hash of the components of the U\+R\+L with the following keys (if data in the U\+R\+L is present; note that at least either the {\ttfamily \char`\"{}host\char`\"{}} or the {\ttfamily \char`\"{}path\char`\"{}} keys will always be returned if a hash is returned)\+:
\begin{DoxyItemize}
\item {\ttfamily protocol\+:} the scheme in the U\+R\+L (ex\+: {\ttfamily \char`\"{}http\char`\"{}})
\item {\ttfamily path\+:} any path given in the U\+R\+L; the path will be prefixed by {\ttfamily \char`\"{}/\char`\"{}} if a hostname is found in the U\+R\+L argument string, otherwise it will not if it was not given as such in the argument string
\item {\ttfamily username\+:} any username given in the U\+R\+L
\item {\ttfamily password\+:} any password given in the U\+R\+L
\item {\ttfamily host\+:} any hostname given in the U\+R\+L; note that this key will be given if no other information can be found in the U\+R\+L argument and the U\+R\+L argument string has no {\ttfamily \char`\"{}/\char`\"{}} characters; depending on the usage context for this function, this may actually be a filename
\item {\ttfamily port\+:} any port number given in the U\+R\+L
\end{DoxyItemize}
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my *\hyperlink{group__type__conversion__functions_ga5182bb860e3837e1eb337e85a9b3ebd6}{hash} $hash = \hyperlink{group__misc__functions_ga6acb2a9487067027a3bdb0d19e2af5fb}{parseURL}($url\_string);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxyNote}{Note}
U\+R\+Ls with U\+N\+I\+X sockets are generally supported in \hyperlink{namespace_qore}{Qore} with the following syntax\+: {\ttfamily scheme\+://socket=$<$url\+\_\+encoded\+\_\+path$>$/path}, where {\ttfamily url\+\_\+encoded\+\_\+path} is a path with U\+R\+L-\/encoding as performed by \hyperlink{group__misc__functions_ga639fba8c278c69ac4d4190ca1db19235}{encode\+\_\+url()}; for example\+: {\ttfamily \char`\"{}http\+://socket=\%2ftmp\%socket-\/dir\%2fsocket-\/file-\/1/url/path\char`\"{}}; this allows a filesystem path to be used in the host portion of the U\+R\+L and for the U\+R\+L to include a U\+R\+L path as well.
\end{DoxyNote}
\begin{DoxySeeAlso}{See also}
\hyperlink{group__misc__functions_ga622e19abea9bd621927bce830b5df09d}{parse\+\_\+url()} for a version of this function that throws exceptions if the U\+R\+L cannot be parsed 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gad2514f74637e1955648b867103aea595}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!parse\+U\+R\+L@{parse\+U\+R\+L}}
\index{parse\+U\+R\+L@{parse\+U\+R\+L}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{parse\+U\+R\+L}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::parse\+U\+R\+L (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gad2514f74637e1955648b867103aea595}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::splice (
\begin{DoxyParamCaption}
\item[{string}]{str}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}


This function always returns an empty string {\ttfamily \char`\"{}\char`\"{}}. 

This function variant is included for backwards-\/compatibility

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_NOOP}{N\+O\+O\+P}
\end{DoxyParagraph}

\begin{DoxyParams}{Parameters}
{\em str} & no action is taken on the argument\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
always returns an empty string {\ttfamily \char`\"{}\char`\"{}} 
\end{DoxyReturn}
\hypertarget{group__misc__functions_ga2d484582db42dcb4752812d3243552bc}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::splice (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{start}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga2d484582db42dcb4752812d3243552bc}


Returns a string based on the argument string but with characters removed from a certain character index. 

An exception can only be thrown here if an invalid multi-\/byte encoding is found


\begin{DoxyParams}{Parameters}
{\em str} & the string to process \\
\hline
{\em start} & the character index (where the first character is 0) to start removing characters; if this value is negative, it gives the offset from the end of the string\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the processed string
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{splice}($str2, 5);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
the \hyperlink{operators_splice}{splice operator} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gaaf2f11a128064b10de5cd2ce1fec72d3}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}string Qore\+::splice (
\begin{DoxyParamCaption}
\item[{string}]{str, }
\item[{softint}]{start, }
\item[{softint}]{len, }
\item[{\+\_\+\+\_\+7\+\_\+ string}]{nstr}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gaaf2f11a128064b10de5cd2ce1fec72d3}


Returns a string based on the argument string but optionally with characters removed and/or added from a certain character index. 

An exception can only be thrown here if an invalid multi-\/byte encoding is found


\begin{DoxyParams}{Parameters}
{\em str} & the string to process \\
\hline
{\em start} & the character index (where the first character is 0) to start removing (and/or adding) characters; if this value is negative, it gives the offset from the end of the string \\
\hline
{\em len} & the number of characters to remove; if this argument is 0 then no characters are removed; if this value is negative, then it gives an offset from the end of the string (ie -\/2 means remove all characters up to but not including the two last characters) \\
\hline
{\em nstr} & the optional string for inserting new characters\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the processed string with characters removed and/or added according to the arguments
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{string} $str = \hyperlink{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{splice}($str2, 5, 7, \textcolor{stringliteral}{"hello"});
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
the \hyperlink{operators_splice}{splice operator} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga88ec0c57f38fb9b7f1a3858fc2e307e8}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::splice (
\begin{DoxyParamCaption}
\item[{list}]{l, }
\item[{softint}]{start}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga88ec0c57f38fb9b7f1a3858fc2e307e8}


Returns a list based on the argument list but with elements removed from the given index to the end of the list. 

Exceptions can only be thrown here if objects are removed from the list and this causes them to go out of scope and an exception is thrown in one of the destructors


\begin{DoxyParams}{Parameters}
{\em l} & the list to process \\
\hline
{\em start} & the starting element (where the first element is 0) to start removing elements; if this value is negative, it gives the offset from the end of the list\\
\hline
\end{DoxyParams}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $l = \hyperlink{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{splice}($l2, 5);
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
the \hyperlink{operators_splice}{splice operator} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_gacec3f65cab29f5f51e4555b823e13d6c}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}list Qore\+::splice (
\begin{DoxyParamCaption}
\item[{list}]{l, }
\item[{softint}]{start, }
\item[{softint}]{len, }
\item[{\+\_\+\+\_\+7\+\_\+ softlist}]{nlist}
\end{DoxyParamCaption}
)}\label{group__misc__functions_gacec3f65cab29f5f51e4555b823e13d6c}


Returns a list based on the argument list but optionally with elements removed and/or added from a certain index. 

Exceptions can only be thrown here if objects are removed from the list and this causes them to go out of scope and an exception is thrown in one of the destructors


\begin{DoxyParams}{Parameters}
{\em l} & the list to process \\
\hline
{\em start} & the starting element (where the first element is 0) to start removing (and/or adding) elements; if this value is negative, it gives the offset from the end of the list \\
\hline
{\em len} & the number of list elements to remove; if this argument is 0 then no elements are removed; if this value is negative, then it gives an offset from the end of the list (ie -\/2 means remove all elements up to but not including the two last elements) \\
\hline
{\em nlist} & the optional list for inserting new elements\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the processed list with elements removed and/or added according to the arguments
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my list $l = \hyperlink{group__misc__functions_ga3b0fa637025e8fbacdf4e43c33e37dc8}{splice}($l2, 5, 7, \textcolor{stringliteral}{"hello"});
\end{DoxyCode}

\end{DoxyParagraph}
\begin{DoxySeeAlso}{See also}
the \hyperlink{operators_splice}{splice operator} 
\end{DoxySeeAlso}
\hypertarget{group__misc__functions_ga7434c1e84c31c32b816312e7a846e876}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!splice@{splice}}
\index{splice@{splice}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{splice}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::splice (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga7434c1e84c31c32b816312e7a846e876}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
\hypertarget{group__misc__functions_ga868cb227993d254a65afb9d21ccba9fe}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!strtoint@{strtoint}}
\index{strtoint@{strtoint}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{strtoint}]{\setlength{\rightskip}{0pt plus 5cm}int Qore\+::strtoint (
\begin{DoxyParamCaption}
\item[{string}]{num, }
\item[{softint}]{base = {\ttfamily 10}}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga868cb227993d254a65afb9d21ccba9fe}


parses a string representing a number in a configurable base and returns the integer 


\begin{DoxyParams}{Parameters}
{\em num} & a string representing a number \\
\hline
{\em base} & the base of the number\\
\hline
\end{DoxyParams}
\begin{DoxyReturn}{Returns}
the integer represented by the string and the base
\end{DoxyReturn}
\begin{DoxyParagraph}{Example\+:}

\begin{DoxyCode}
my \textcolor{keywordtype}{int} $i = \hyperlink{group__misc__functions_ga868cb227993d254a65afb9d21ccba9fe}{strtoint}(\textcolor{stringliteral}{"41"}, 8);
\end{DoxyCode}

\end{DoxyParagraph}

\begin{DoxyExceptions}{Exceptions}
{\em S\+T\+R\+T\+O\+I\+N\+T-\/\+E\+R\+R\+O\+R} & cannot parse string; unsupported base, etc \\
\hline
\end{DoxyExceptions}
\hypertarget{group__misc__functions_ga25647de5f63580b7d3af4b33c4f35702}{}\index{Miscellaneous Functions@{Miscellaneous Functions}!strtoint@{strtoint}}
\index{strtoint@{strtoint}!Miscellaneous Functions@{Miscellaneous Functions}}
\subsubsection[{strtoint}]{\setlength{\rightskip}{0pt plus 5cm}nothing Qore\+::strtoint (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}\label{group__misc__functions_ga25647de5f63580b7d3af4b33c4f35702}


This function variant does nothing at all; it is only included for backwards-\/compatibility with qore prior to version 0.\+8.\+0 for functions that would ignore type errors in arguments. 

\begin{DoxyParagraph}{Code Flags\+:}
\hyperlink{code_flags_RUNTIME_NOOP}{R\+U\+N\+T\+I\+M\+E\+\_\+\+N\+O\+O\+P} 
\end{DoxyParagraph}
