Beispiel #1
0
 public function parseReturn(Tokenizer $tokens)
 {
     if ($tokens->valid()) {
         $return = $this->parseExpression($tokens->next());
         dump("{$return}");
         if ($return->isScalar()) {
             switch ($return->type) {
                 case Types::BOOLEAN:
                     return $return->value ? "RETURN_TRUE;" : "RETURN_FALSE;";
                 case Types::DOUBLE:
                     return "RETURN_DOUBLE({$return->value});";
                 case Types::INT:
                     return "RETURN_LONG({$return->value});";
                 case Types::NIL:
                     return "RETURN_NULL();";
                 case Types::STRING:
                     return "RETURN_STRINGL(\"" . addslashes($return->value) . "\", " . strlen($return->value) . ");";
                 default:
                     drop("unknown type " . Types::getTypeCode($return->type));
             }
         } else {
             return "RETURN_ZVAL({$return}, 1);";
         }
     } else {
         return "return;";
     }
 }
Beispiel #2
0
 public function setScalar($value)
 {
     $this->type = Types::detectType($value);
     $this->value = $value;
     $this->is_const = true;
     $this->is_var = false;
     $this->is_mixed = false;
     return $this;
 }
Beispiel #3
0
 /**
  *
  * @param EntityFunction $callable
  * @param \ReflectionFunctionAbstract $reflection
  * @return $this
  */
 public static function parseCallable(EntityFunction $callable, \ReflectionFunctionAbstract $reflection)
 {
     $doc = $reflection->getDocComment();
     $params = [];
     if ($doc) {
         $info = ToolKit::parseDoc($doc);
         $callable->setDescription($info['desc']);
         $callable->setReturnInfo($info['return']['type'], $reflection->returnsReference(), $info['return']['desc']);
         $callable->setOptions($info['options']);
         $params = $info["params"];
     } else {
         $info = [];
     }
     /* @var \ReflectionParameter[] $params */
     foreach ($reflection->getParameters() as $param) {
         $argument = new EntityArgument($param->name);
         if (isset($params[$param->name]["desc"])) {
             $argument->description = $params[$param->name]["desc"];
         }
         if ($callable->getLine()) {
             $argument->setLine($callable->getLine());
         }
         $argument->setOptional($param->isOptional());
         $argument->setNullAllowed($param->allowsNull());
         $argument->setValue($param->isDefaultValueAvailable() ? $param->getDefaultValue() : null, $param->isPassedByReference());
         $argument->setByRef($param->isPassedByReference());
         /** @var \ReflectionParameter $param */
         if ($param->isArray()) {
             $argument->setCast(Types::ARR);
         }
         if ($c = $param->getClass()) {
             $argument->setCast(Types::OBJECT, $c->name);
         } elseif (isset($info['params'][$param->name])) {
             $_type = $info['params'][$param->name]["type"];
             if (strpos($_type, "|") || $_type === "mixed") {
                 // multiple types or mixed
                 $argument->setCast(Types::MIXED);
             } else {
                 if (strpos($_type, "[]")) {
                     $argument->setCast(Types::ARR, rtrim($_type, '[]'));
                 }
                 if (isset(Types::$codes[$_type])) {
                     $argument->setCast(Types::getType($_type));
                 } else {
                     $argument->setCast(Types::OBJECT, ltrim($_type, '\\'));
                 }
             }
         } else {
             $argument->warning("not documented");
         }
         $callable->pushArgument($argument);
     }
 }
 public function dump($tab = "")
 {
     $args = [];
     foreach ($this->arguments as $arg) {
         $args[] = $arg->dump();
     }
     return static::$entity_type . " {$this->name}(" . ($args ? implode(', ', $args) : '') . '):' . ($this->return_type == -1 ? 'void' : Types::getTypeCode($this->return_type));
 }
Beispiel #5
0
 /**
  * @param object $object
  * @return bool
  * @throws \InvalidArgumentException
  */
 public static function configure($object)
 {
     $options = self::_parse();
     $class = new \ReflectionClass(get_class($object));
     $ce = new EntityClass(get_class($object));
     if (isset($options['help'])) {
         echo "Usage: " . $_SERVER['argv'][0] . " [OPTIONS ...]\nOptions:\n";
         foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
             if (strpos($method->name, 'set') === 0) {
                 $name = substr($method->name, 3);
             } elseif (strpos($method->name, 'get') === 0) {
                 $name = substr($method->name, 3);
             } elseif (strpos($method->name, 'add') === 0) {
                 $name = $method->name;
             } else {
                 continue;
             }
             $name = self::toCLIName($name);
             //				$about = (new EntityMethod($ce->name.'::'.$method->name))->setClass($ce)->scan();
             $about = new EntityMethod($ce->name . '::' . $method->name);
             EntityFile::parseCallable($about, $about->setClass($ce)->getReflection());
             $req = [];
             if ($about->arguments) {
                 $first = true;
                 //					if($about->required == 0) {
                 //						printf("  --%-25s  %s\n", $name, $about->description);
                 //                        $req[] = $name;
                 //					}
                 foreach ($about->arguments as $argument) {
                     $description = $argument->description . ($req ? " (required --" . implode(", --", $req) . ")" : "");
                     /* @var EntityArgument $argument */
                     if ($argument->isOptional()) {
                         if ($first) {
                             $first = false;
                             $arg_name = $name . "[=" . strtoupper($argument->name) . "]";
                             $description = $about->description . sprintf("\n  %-27s  %s — %s", "", strtoupper($argument->name), $argument->description);
                         } else {
                             $arg_name = $name . "." . $argument->name . "=" . strtoupper(Types::getTypeCode($argument->type));
                         }
                         printf("  --%-25s  %s\n", $arg_name, $description);
                     } else {
                         //                            $arg_name = $name.".".$argument->name;
                         if ($first) {
                             $first = false;
                             $arg_name = $name . "=" . strtoupper($argument->name);
                             $description = $about->description . sprintf("\n  %-27s  %s — %s\n", "", strtoupper($argument->name), $argument->description);
                         } else {
                             $arg_name = $name . "." . $argument->name . "=" . strtoupper(Types::getTypeCode($argument->type));
                         }
                         $req[] = $arg_name;
                         printf("  --%-25s  %s\n", $arg_name, $description);
                     }
                 }
             } else {
                 printf("  --%-25s  %s\n", $name, $about->description);
             }
         }
         echo "\nKoda " . \Koda::VERSION_STRING . " by Ivan [Bzick] Shalganov\n";
         return false;
     }
     foreach ($options as $option => $values) {
         $method = str_replace('-', '', $option);
         if (strpos($method, 'add') === 0) {
             self::_call([$object, $method], $values, $option);
         } elseif (method_exists($object, 'set' . $method)) {
             self::_call([$object, 'set' . $method], $values, $option);
         } elseif (method_exists($object, 'get' . $method)) {
             echo self::_call([$object, 'get' . $method], $values, $option) . "\n";
             return false;
         } else {
             throw new \InvalidArgumentException("Unknown option --{$option}");
         }
     }
     return true;
 }
Beispiel #6
0
 /**
  * @param string $doc
  * @return array
  */
 public static function parseDoc($doc)
 {
     $doc = preg_replace('/^\\s*(\\*\\s*)+/mS', '', trim($doc, "*/ \t\n\r"));
     $info = ["desc" => "", "return" => ['type' => -1, 'desc' => ''], "options" => []];
     $params = [];
     if (strpos($doc, "@") !== false) {
         $doc = explode("@", $doc, 2);
         if ($doc[0] = trim($doc[0])) {
             $info["desc"] = $doc[0];
         }
         if ($doc[1]) {
             foreach (preg_split('/\\r?\\n@/Sm', $doc[1]) as $param) {
                 $param = preg_split('/\\s+/', $param, 2);
                 if (!isset($param[1])) {
                     $param[1] = "";
                 }
                 switch (strtolower($param[0])) {
                     case 'desc':
                     case 'description':
                         if (empty($info["desc"])) {
                             $info["desc"] = $param[1];
                         }
                         break;
                     case 'param':
                         if (preg_match('/^(.*?)\\s*\\$(\\w+)\\s*?/Sm', $param[1], $matches)) {
                             $params[$matches[2]] = array("type" => $matches[1], "desc" => trim(substr($param[1], strlen($matches[0]))));
                         }
                         break;
                     case 'return':
                         if (preg_match('/^(.*?)\\s*$/Sm', $param[1], $matches)) {
                             $info["return"]["type"] = Types::getType($matches[1]);
                             $info["return"]["desc"] = isset($matches[2]) ? $matches[2] : '';
                         }
                         break;
                     default:
                         if (isset($info["options"][$param[0]])) {
                             if (!is_array($params["options"][$param[0]])) {
                                 $info["options"][$param[0]] = array($info["options"][$param[0]]);
                             }
                             $info["options"][$param[0]][] = $param[1];
                         } else {
                             $info["options"][$param[0]] = $param[1];
                         }
                 }
             }
         }
     } else {
         $info["desc"] = $doc;
     }
     $info['params'] = $params;
     return $info;
 }