ql_misc.dox.h

 
namespace Qore {
 
hashdecl UrlInfo {
    string host;
    string password;
    string path;
    int port;
    string protocol;
    string query;
    string username;
};
}
 
namespace Qore {
 
 
nothing remove_signal_handler(softint signal);
 
 
nothing set_signal_handler(softint signal, code f);
 
}
 
namespace Qore {
 
 
string backquote(string cmd, *reference<int> rc);
 
 
nothing backquote();
 
 
auto call_builtin_function(string name,  ...);
 
 
auto call_builtin_function_args(string name, *softlist<auto> vargs);
 
 
auto call_function(string name,  ...);
 
 
auto call_function(code f,  ...);
 
 
auto call_function_args(string name, *softlist<auto> vargs);
 
 
auto call_function_args(code f, *softlist<auto> vargs);
 
 
string decode_uri_request(string uri);
 
 
string decode_url(string url);
 
 
nothing decode_url();
 
 
string encode_uri_request(string url);
 
 
string encode_url(string url, softbool encode_all = False);
 
 
bool exists( ...);
 
 
bool existsFunction(string name);
 
 
bool existsFunction(code c);
 
 
nothing existsFunction();
 
 
bool exists_function(string name);
 
 
bool exists_function(code c);
 
 
*string functionType(string name);
 
 
nothing functionType();
 
 
*string function_type(string name);
 
 
*int getByte(string str, softint offset = 0);
 
 
nothing getByte();
 
 
*int getByte(binary b, softint offset = 0);
 
 
string getClassName(object obj);
 
 
nothing getClassName();
 
 
list<string> getFeatureList();
 
 
hash<string,hash<auto>> getModuleHash();
 
 
list<hash<auto>> getModuleList();
 
 
*int getWord32(string str, softint offset = 0);
 
 
*int getWord32(binary b, softint offset = 0);
 
 
nothing getWord32();
 
 
*int get_byte(string str, softint offset = 0);
 
 
*int get_byte(binary b, softint offset = 0);
 
 
code get_call_reference(string identifier);
 
 
string get_class_name(object obj);
 
 
string get_default_encoding();
 
 
string get_ex_pos(hash<auto> ex);
 
 
list<string> get_feature_list();
 
 
hash<auto> get_global_vars();
 
 
hash<auto> get_local_vars(int frame);
 
 
hash<string,hash<auto>> get_module_hash();
 
 
list<hash<auto>> get_module_list();
 
 
auto get_module_option(string module, string option);
 
 
int get_parse_options();
 
 
hash<auto> get_qore_library_info();
 
 
hash<string,hash<auto>> get_qore_option_hash();
 
 
list<hash<auto>> get_qore_option_list();
 
 
string get_safe_url(string url);
 
 
*string get_script_dir();
 
 
*string get_script_name();
 
 
*string get_script_path();
 
 
*int get_word_16(string str, softint offset = 0);
 
 
*int get_word_16(binary b, softint offset = 0);
 
 
*int get_word_16_lsb(string str, softint offset = 0);
 
 
*int get_word_16_lsb(binary b, softint offset = 0);
 
 
*int get_word_32(string str, softint offset = 0);
 
 
*int get_word_32(binary b, softint offset = 0);
 
 
*int get_word_32_lsb(string str, softint offset = 0);
 
 
*int get_word_32_lsb(binary b, softint offset = 0);
 
 
*int get_word_64(string str, softint offset = 0);
 
 
*int get_word_64(binary b, softint offset = 0);
 
 
*int get_word_64_lsb(string str, softint offset = 0);
 
 
*int get_word_64_lsb(binary b, softint offset = 0);
 
 
bool has_key(hash<auto> h, string key);
 
 
bool has_key(object obj, string key);
 
 
list<auto> hash_values(hash<auto> h);
 
 
nothing hash_values();
 
 
int hextoint(string str);
 
 
nothing hextoint();
 
 
string html_decode(string str);
 
 
nothing html_decode();
 
 
string html_encode(string str);
 
 
nothing html_encode();
 
 
nothing load_module(string name, int warning_mask = WARN_MODULES);
 
 
nothing load_module();
 
 
*hash<ExceptionInfo> load_module_warn(string name, int warning_mask = WARN_MODULES);
 
 
nothing load_user_module_with_program(string name, Qore::Program pgm);
 
 
string makeBase64String(string str, softint maxlinelen = -1);
 
 
string makeBase64String(binary bin, softint maxlinelen = -1);
 
 
nothing makeBase64String();
 
 
string makeHexString(string str);
 
 
string makeHexString(binary bin);
 
 
nothing makeHexString();
 
 
string make_base64_string(string str, softint maxlinelen = -1);
 
 
string make_base64_string(binary bin, softint maxlinelen = -1);
 
 
string make_hex_string(string str);
 
 
string make_hex_string(binary bin);
 
 
*hash<auto> parse(string code, string label, *softint warning_mask, *string source, *softint offset, softbool format_label = True);
 
 
nothing parse();
 
 
binary parseBase64String(string str);
 
 
nothing parseBase64String();
 
 
string parseBase64StringToString(string str, *string encoding);
 
 
nothing parseBase64StringToString();
 
 
binary parseHexString(string hexstr);
 
 
nothing parseHexString();
 
 
*hash<UrlInfo> parseURL(string url, bool keep_brackets = False);
 
 
nothing parseURL();
 
 
binary parse_base64_string(string str);
 
 
string parse_base64_string_to_string(string str, *string encoding);
 
 
binary parse_hex_string(string hexstr);
 
 
hash<UrlInfo> parse_url(string url, bool keep_brackets);
 
 
hash<UrlInfo> parse_url(string url, *int options);
 
 
nothing reload_module(string name);
 
 
nothing set_global_var_value(string name, auto value);
 
 
nothing set_local_var_value(int frame, string var, auto value);
 
 
nothing set_module_option(string module, string option, auto value);
 
 
 set_return_value(auto val);
 
 
string splice(string str);
 
 
string splice(string str, softint start);
 
 
string splice(string str, softint start, softint len, *string nstr);
 
 
list<auto> splice(list<auto> l, softint start);
 
 
list<auto> splice(list<auto> l, softint start, softint len);
 
 
list<auto> splice(list<auto> l, softint start, softint len, softlist<auto> nlist);
 
 
nothing splice();
 
 
int strtoint(string num, softint base = 10);
 
 
nothing strtoint();
 
}
 
namespace Qore {
 
    const QURL_DECODE = QURL_DECODE;
    const QURL_DECODE_PATH = QURL_DECODE_PATH;
 
    const QURL_KEEP_BRACKETS = QURL_KEEP_BRACKETS;
}
 
namespace Qore {
 
 
    const CE_ALL = CE_ALL;
 
    const CE_HTML = CE_HTML;
 
    const CE_NONASCII = CE_NONASCII;
 
    const CE_XHTML = CE_XHTML;
 
    const CE_XML = CE_XML;
}
 
namespace Qore {
 
 
    const CD_ALL = CD_ALL;
 
    const CD_HTML = CD_HTML;
 
    const CD_NUM_REF = CD_NUM_REF;
 
    const CD_XHTML = CD_XHTML;
 
    const CD_XML = CD_XML;
}
 
namespace Qore {
 
    const NameToSignal = (
   "SIGABRT": SIGABRT,
   "SIGALRM": SIGALRM,
   "SIGBUS": SIGBUS,
   "SIGCANCEL": SIGCANCEL,
   "SIGCHLD": SIGCHLD,
   "SIGCLD": SIGCLD,
   "SIGCONT": SIGCONT,
   "SIGEMT": SIGEMT,
   "SIGFPE": SIGFPE,
   "SIGFREEZE": SIGFREEZE,
   "SIGHUP": SIGHUP,
   "SIGILL": SIGILL,
   "SIGINFO": SIGINFO,
   "SIGINT": SIGINT,
   "SIGIO": SIGIO,
   "SIGIOT": SIGIOT,
   "SIGJVM1": SIGJVM1,
   "SIGJVM2": SIGJVM2,
   "SIGKILL": SIGKILL,
   "SIGLOST": SIGLOST,
   "SIGLWP": SIGLWP,
   "SIGPIPE": SIGPIPE,
   "SIGPOLL": SIGPOLL,
   "SIGPROF": SIGPROF,
   "SIGPWR": SIGPWR,
   "SIGQUIT": SIGQUIT,
   "SIGSEGV": SIGSEGV,
   "SIGSTKFLT": SIGSTKFLT,
   "SIGSTOP": SIGSTOP,
   "SIGSYS": SIGSYS,
   "SIGTERM": SIGTERM,
   "SIGTHAW": SIGTHAW,
   "SIGTRAP": SIGTRAP,
   "SIGTSTP": SIGTSTP,
   "SIGTTIN": SIGTTIN,
   "SIGTTOU": SIGTTOU,
   "SIGURG": SIGURG,
   "SIGUSR1": SIGUSR1,
   "SIGUSR2": SIGUSR2,
   "SIGVTALRM": SIGVTALRM,
   "SIGWAITING": SIGWAITING,
   "SIGWINCH": SIGWINCH,
   "SIGXCPU": SIGXCPU,
   "SIGXFSZ": SIGXFSZ,
   "SIGXRES": SIGXRES,
   );
    const SIGABRT = SIGABRT;
    const SIGALRM = SIGALRM;
    const SIGBUS = SIGBUS;
    const SIGCANCEL = SIGCANCEL;
    const SIGCHLD = SIGCHLD;
    const SIGCLD = SIGCLD;
    const SIGCONT = SIGCONT;
    const SIGEMT = SIGEMT;
    const SIGFPE = SIGFPE;
    const SIGFREEZE = SIGFREEZE;
    const SIGHUP = SIGHUP;
    const SIGILL = SIGILL;
    const SIGINFO = SIGINFO;
    const SIGINT = SIGINT;
    const SIGIO = SIGIO;
    const SIGIOT = SIGIOT;
    const SIGJVM1 = SIGJVM1;
    const SIGJVM2 = SIGJVM2;
    const SIGKILL = SIGKILL;
    const SIGLOST = SIGLOST;
    const SIGLWP = SIGLWP;
    const SIGPIPE = SIGPIPE;
    const SIGPOLL = SIGPOLL;
    const SIGPROF = SIGPROF;
    const SIGPWR = SIGPWR;
    const SIGQUIT = SIGQUIT;
    const SIGSEGV = SIGSEGV;
    const SIGSTKFLT = SIGSTKFLT;
    const SIGSTOP = SIGSTOP;
    const SIGSYS = SIGSYS;
    const SIGTERM = SIGTERM;
    const SIGTHAW = SIGTHAW;
    const SIGTRAP = SIGTRAP;
    const SIGTSTP = SIGTSTP;
    const SIGTTIN = SIGTTIN;
    const SIGTTOU = SIGTTOU;
    const SIGURG = SIGURG;
    const SIGUSR1 = SIGUSR1;
    const SIGUSR2 = SIGUSR2;
    const SIGVTALRM = SIGVTALRM;
    const SIGWAITING = SIGWAITING;
    const SIGWINCH = SIGWINCH;
    const SIGXCPU = SIGXCPU;
    const SIGXFSZ = SIGXFSZ;
    const SIGXRES = SIGXRES;
    const SignalToName = (
   SIGABRT: "SIGABRT",
   SIGALRM: "SIGALRM",
   SIGBUS: "SIGBUS",
   SIGCANCEL: "SIGCANCEL",
   SIGCHLD: "SIGCHLD",
   SIGCONT: "SIGCONT",
   SIGEMT: "SIGEMT",
   SIGFPE: "SIGFPE",
   SIGFREEZE: "SIGFREEZE",
   SIGHUP: "SIGHUP",
   SIGILL: "SIGILL",
   SIGINFO: "SIGINFO",
   SIGINT: "SIGINT",
   SIGIO: "SIGIO",
   SIGIOT: "SIGIOT",
   SIGJVM1: "SIGJVM1",
   SIGJVM2: "SIGJVM2",
   SIGKILL: "SIGKILL",
   SIGLOST: "SIGLOST",
   SIGLWP: "SIGLWP",
   SIGPIPE: "SIGPIPE",
   SIGPOLL: "SIGPOLL",
   SIGPROF: "SIGPROF",
   SIGPWR: "SIGPWR",
   SIGQUIT: "SIGQUIT",
   SIGSEGV: "SIGSEGV",
   SIGSTKSZ: "SIGSTKSZ",
   SIGSTOP: "SIGSTOP",
   SIGSYS: "SIGSYS",
   SIGTERM: "SIGTERM",
   SIGTHAW: "SIGTHAW",
   SIGTRAP: "SIGTRAP",
   SIGTSTP: "SIGTSTP",
   SIGTTIN: "SIGTTIN",
   SIGTTOU: "SIGTTOU",
   SIGURG: "SIGURG",
   SIGUSR1: "SIGUSR1",
   SIGUSR2: "SIGUSR2",
   SIGVTALRM: "SIGVTALRM",
   SIGWAITING: "SIGWAITING",
   SIGWINCH: "SIGWINCH",
   SIGXCPU: "SIGXCPU",
   SIGXFSZ: "SIGXFSZ",
   SIGXRES: "SIGXRES",
);
}