Start or continue tracing.

@param  string|NULL trace title
771074
public function start($title = null)
    {
        if (!$this->isError) {
            if ($this->state === self::STATE_RUN) {
                $this->pause();
            }

            if ($this->state === self::STATE_STOP) {
                $this->titles = [$title];
                \xdebug_start_trace($this->traceFile, XDEBUG_TRACE_COMPUTERIZED);
            } elseif ($this->state === self::STATE_PAUSE) {
                $this->titles[] = $title;
                \xdebug_start_trace($this->traceFile, XDEBUG_TRACE_COMPUTERIZED | XDEBUG_TRACE_APPEND);
            }

            $this->state = self::STATE_RUN;
        }
    }
186620
public function traceLog(string $key = null, $message = null)
    {
        if ($this->trace_log_enabled) {
            if (is_array($message) || is_object($message)) {
                $text = print_r($message, true);
            } elseif ($message === null) {
                $text = "[null]";
            } elseif ($message === false) {
                $text = "[false]";
            } elseif ($message === true) {
                $text = "[true]";
            } else {
                $text = $message;
            }
            error_log("=== " . ($key !== null ? "$key: " : '') . $text);
        }

        if ($key === null) {
            if ($this->trace_log_buffer === null) {
                $this->trace_log_buffer = array();
            }
            if (array_key_exists(self::MESSAGES_STACK, $this->trace_log_buffer)) {
                $this->trace_log_buffer[self::MESSAGES_STACK][] = $message;
            } else {
                $this->trace_log_buffer[self::MESSAGES_STACK] = array($message);
            }
        } else {
            $this->trace_log_buffer[$key] = $message;
        }
    }
1119860
public function start($max = null)
    {
        $this->max = (int) $max;
        $this->progress->start($this->output, $max);
    }
807092
public function start()
    {
        $data = Utility::get($this->params, "data", array());
        if ($data && count($data)>0) {
            switch($this->dataFormat)
            {
            case "table":
                $columnNames = $data[0];
                $metaData = array("columns"=>array());
                for ($i=0;$i<count($columnNames);$i++) {
                    $metaData["columns"][$columnNames[$i]] = array(
                        "type"=>(isset($data[1]))
                            ?$this->guessType($data[1][$i]):"unknown",
                    );;
                }
                $this->sendMeta($metaData, $this);
                $this->startInput(null);
                $rowNum = count($data);
                for ($i=1;$i<$rowNum;$i++) {
                    $this->next(array_combine($columnNames, $data[$i]), $this);
                }
                break;
            case "associate":
            default:
                $metaData = array("columns"=>array());
                foreach ($data[0] as $key=>$value) {
                    $metaData["columns"][$key]=array(
                        "type"=>$this->guessType($value),
                    );
                }
                $this->sendMeta($metaData, $this);
                $this->startInput(null);
                foreach ($data as $row) {
                    $this->next($row);
                }
                break;
            }
        }
        $this->endInput(null);
    }
706227
public static function route() :void {

		// marker
		Profiler::setMarker('Router.route', 'framework');
		// get the requested url
		$request_url = Request::getUrl();
		// get the requested method
		$request_method = Request::getMethod();
		// Loop over each route and test to see if they are valid
		foreach(self::$_routes as $route) {
			// if the route matches
			if(self::routeMatch($request_url, $request_method, $route)) {
				// get it
				$matching_route = $route;
				// stop trying
				break;
			}
		}
		// marker
		Profiler::releaseMarker('Router.route');
		// if no match is found and we don't have an error route to fallback on
		if(!isset($matching_route)) {
			// throw a native exception since there is no cleaner alternative
			Throw new Exception('Router::route() no matching route', 404);
		}
		// send the matching route to the dispatcher
		self::forward($matching_route);	
		
	}
762107
public void trace(String s) {

        if ((s != null) &&!s.equals("")) {
            tMessage.setText(s);

            if (TRACE) {
                System.out.println(s);
            }
        }
    }
97931
def trace_start(self):
        
        cmd = enums.JLinkTraceCommand.START
        res = self._dll.JLINKARM_TRACE_Control(cmd, 0)
        if (res == 1):
            raise errors.JLinkException('Failed to start trace.')
        return None
37362
static public function traceFiles()
    {
        $backtrace = debug_backtrace();
        array_shift($backtrace);
        $message = 'load files:' . PHP_EOL;
        if ($backtrace) foreach ($backtrace as $v) {
            $message .= sprintf('[%s] %s: %s', filesize($v['file']), $v['file'], $v['function']) . PHP_EOL;
        }
        Ioc::logger('trace')->debug(sprintf('[%s]%s', 'file', $message));
    }
967268
public static function trace($str)
    {
        $dbg = debug_backtrace();
        phpCAS :: log($str . ' [' . basename($dbg[0]['file']) . ':' . $dbg[0]['line'] . ']');
    }
487184
protected function getTrace($trace, $label) {
            ob_start();
            $trace = array_slice($trace, $this->config->traceDepth * -1);

            // @codeCoverageIgnoreStart
            if ($this->isCLI) {
                $this->traceCLI($trace, $label);
            } else {
                // @codeCoverageIgnoreEnd
                $this->traceHTML($trace);
            }

            return ob_get_clean();
        }
964310
def set_continue(self, frame):
        """"""
        self.state = Running(frame)
        if not self.tracing and not self.breakpoints:
            # If we were in a set_trace and there's no breakpoint to trace for
            # Run without trace
            self.stop_trace()
470399
protected function backtrace($string, $level = 1)
    {
        if (isset($this->trace[$string])) {
            return $this;
        }

        $info = [
            'position' => null,
            'called' => null,
            'args' => [],
        ];

        if (function_exists('debug_backtrace')) {
            $defaultTrace = [
                'file' => null,
                'line' => null,
                'function' => null,
                'class' => null,
                'object' => null,
                'type' => null,
                'args' => [],
            ];

            $trace = debug_backtrace();

            // Find where called this object
            if (isset($trace[$level])) {
                $traceData = array_merge($defaultTrace, $trace[$level]);

                $ref = null;

                if (method_exists($traceData['class'], $traceData['function'])) {
                    $ref = new \ReflectionMethod($traceData['class'], $traceData['function']);
                } elseif (function_exists($traceData['function'])) {
                    $ref = new \ReflectionFunction($traceData['function']);
                }

                $info['position'] = [
                    'file' => $ref ? $ref->getFileName() : $traceData['file'],
                    'class' => $traceData['class'],
                    'function' => $traceData['function'],
                    'line' => $ref ? $ref->getStartLine() : $traceData['line'],
                ];
            }

            if (isset($trace[$level - 1])) {
                $traceData = array_merge($defaultTrace, $trace[$level - 1]);

                $info['called'] = [
                    'file' => $traceData['file'],
                    'class' => $traceData['class'],
                    'function' => $traceData['function'],
                    'line' => $traceData['line'],
                    'args' => $traceData['args'],
                ];

                $info['args'] = $traceData['args'];
            }
        }

        return $info;
    }
1146675
public function startTracking($entity)
    {
        $hashId                      = $this->getHashId($entity);
        $this->originalData[$hashId] = clone $entity;
    }
560461
public final void trace(Object message) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
            log(SimpleLog.LOG_LEVEL_TRACE, message, null);
        }
    }
1037085
public void trace(String msg) {
        if (logger.isLoggable(Level.FINEST)) {
            log(SELF, Level.FINEST, msg, null);
        }
    }
1010396
public void trace(Object message) {
        doLog(Level.TRACE, FQCN, message, null, null);
    }
919060
public function traceClose(int $idx = null, int $errCode = null, string $errMessage = null): void
    {
        if (null === $idx) {
            $idx = count($this->buffTrace) - 1;
        }
        
        if (!array_key_exists($idx, $this->buffTrace)) {
            throw new DebugIndexNotExistsException();
        }
        
        $this->buffTrace[$idx]['time'] = microtime(true) - $this->buffTrace[$idx]['time'];
        $this->buffTrace[$idx]['result'] = (null === $errCode ? 'OK' : '(' . $errCode . ') ' . $errMessage);
    }