public static function getInstance() { if (is_null(self::$config)) { self::$base = ''; self::$urlBase = '//pc4u.nu'; self::$engine_base = '//pc4u.nu/engine'; self::$admin_base = '//admin.pc4u.nu/'; self::$config = (require __DIR__ . '/config/config.php'); self::$language = 'en'; self::$mail = '*****@*****.**'; self::$mail_end = 'Kind regards, <br/>PC4U'; if (!empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest') { self::$isAjax = true; } else { self::$isAjax = false; } } }
<?php /* * Main class Engine * Build By T.Nijborg A.K.A Mentimjojo */ // Global Variable Errors require __DIR__ . '/constants.php'; cons::getInstance(); // Class class Engine { // Public Engine public $errors; public $config; public $database; public $users; public $lang; public $mailer; public $categories; public $subcategories; public $products; public $tickets; public $orders; /* * construct Function */ public function __construct() { // Start session session_start();
function yolisp($swag, array &$env = []) { static $OP_CACHE = []; // HAH! Take that Zend! if (!$swag instanceof cons) { // implicitly quote non-strings if (!is_string($swag)) { return $swag; } // lookup in environment if (array_key_exists($swag, $env)) { return $env[$swag]; } else { if (isset($OP_CACHE[$swag])) { return $OP_CACHE[$swag]; } else { if (array_key_exists($swag, DEFAULT_ENV)) { $callable = DEFAULT_ENV[$swag]; if (is_array($callable)) { return $OP_CACHE[$swag] = (new \ReflectionMethod(...$callable))->getClosure(); } else { if (is_string($callable)) { return $OP_CACHE[$swag] = (new \ReflectionFunction($callable))->getClosure(); } else { return $callable; } } } else { if (function_exists($swag)) { return $OP_CACHE[$swag] = (new \ReflectionFunction($swag))->getClosure(); // we do class lookup after function lookup because everyone knows functional programming is superior // what did you expect? this is yolisp, not yojava } else { if (class_exists($swag)) { return $swag; } else { if (array_key_exists($swag, OPS)) { $format = OPS[$swag]; $ops = substr_count($format, '$'); $ops += $optional_ops = substr_count($format, '?'); if ($ops === 0) { throw new \Exception("Invalid operator format string: \"{$format}\""); } $param_names = []; for ($i = 0; $i < $ops; $i++) { $param_names[] = '$op' . $i; } $param_list = ''; for ($i = 0; $i < $ops; $i++) { if ($i !== 0) { $param_list .= ', '; } $param_list .= $param_names[$i]; if ($i >= $ops - $optional_ops) { $param_list .= ' = NULL'; } } $parts = explode(' ', $format); if ($optional_ops) { $optionless_expr = ''; $i = 0; foreach ($parts as $part) { if ($part === '?') { $optionless_expr .= ' '; } else { if ($part === '$') { $optionless_expr .= ' ' . $param_names[$i]; $i++; } else { $optionless_expr .= ' ' . $part; } } } } $expr = ''; $i = 0; foreach ($parts as $part) { if ($part === '?' || $part === '$') { $expr .= ' ' . $param_names[$i]; $i++; } else { $expr .= ' ' . $part; } } if ($optional_ops) { $body = "if (func_num_args() < {$ops}) { return {$optionless_expr}; } else { return {$expr}; }"; } else { $body = "return {$expr};"; } // And people said eval() and create_function() were evil! return $OP_CACHE[$swag] = create_function($param_list, $body); } else { throw new \Exception("Could not find {$swag} in environment"); } } } } } } } $eval = function ($swag) use(&$env) { return yolisp($swag, $env); }; $command = cons::car($swag); $args = cons::cdr($swag); switch ($command) { case 'quote': return cons::car($args); case 'lambda': $arg_names = x(cons::car($args)); $body = cons::car(cons::cdr($args)); return function (...$args) use($arg_names, $body, &$env) { $new_env = $env; // copies rather than references foreach ($arg_names as $i => $arg_name) { $new_env[$arg_name] = $args[$i]; } return yolisp($body, $new_env); }; case 'let': $pairs = cons::car($args); $body = cons::car(cons::cdr($args)); $new_env = $env; // copies rather than references while (!is_null($pairs)) { $pair = cons::car($pairs); // (name value) 2-element list $new_env[cons::car($pair)] = yolisp(cons::car(cons::cdr($pair)), $new_env); $pairs = cons::cdr($pairs); } return yolisp($body, $new_env); case 'if': $expr = cons::car($args); $results = cons::cdr($args); $on_true = cons::car($results); $on_false = cons::car(cons::cdr($results)); if ($eval($expr)) { return $eval($on_true); } else { return $eval($on_false); } break; // -> and :: aren't normal ops as property name is implicitly quoted // -> and :: aren't normal ops as property name is implicitly quoted case '->': case '::': $obj = $eval(cons::car($args)); $prop = cons::car(cons::cdr($args)); if (property_exists($obj, $prop)) { if ($command === '->') { return $obj->{$prop}; } else { // this is really ugly syntax for a variable static property access // luckily yolo users don't need to deal with it return $obj::${$prop}; } // PHP has separate symbol tables for methods and properties // NOT IN YOLISP! } else { if (method_exists($obj, $prop)) { $method = new \ReflectionMethod($obj, $prop); if ($command === '->') { return $method->getClosure($obj); } else { return $method->getClosure(); } } else { throw new \Exception("No property/method {$command}{$prop} in {$obj}"); } } break; case 'new': $class = cons::car($args); $constructor_args = cons::cdr($args); $class_name = $eval($class); $evaluated_args = array_map($eval, x($constructor_args)); return new $class_name(...$evaluated_args); default: $func = $eval($command); $evaluated_args = array_map($eval, x($args)); return $func(...$evaluated_args); } }
public function checkLoggedIn() { if (empty($_SESSION['user_id'])) { return false; } else { // Get data $sql = "SELECT * FROM " . $this->table . " WHERE user_id = '" . $_SESSION['user_id'] . "'"; // Return cons::$user = (object) $this->database->query($sql)->fetch(); } }