[std] fix some doc comment style inconsistencies

std/StringTools.hx

@@ -477,9 +477,9 @@ class StringTools {
 		#end
 	}
 
-	/*
+	/**
 		Tells if `c` represents the end-of-file (EOF) character.
-	*/
+	**/
 	@:noUsing public static inline function isEof( c : Int ) : Bool {
 		#if (flash || cpp || hl)
 		return c == 0;
@@ -502,7 +502,7 @@ class StringTools {
 		Returns a String that can be used as a single command line argument
 		on Unix.
 		The input will be quoted, or escaped if necessary.
-	*/
+	**/
 	public static function quoteUnixArg(argument:String):String {
 		// Based on cpython's shlex.quote().
 		// https://hg.python.org/cpython/file/a3f076d4f54f/Lib/shlex.py#l278
@@ -520,7 +520,7 @@ class StringTools {
 
 	/**
 		Character codes of the characters that will be escaped by `quoteWinArg(_, true)`.
-	*/
+	**/
 	public static var winMetaCharacters = [" ".code, "(".code, ")".code, "%".code, "!".code, "^".code, "\"".code, "<".code, ">".code, "&".code, "|".code, "\n".code, "\r".code, ",".code, ";".code];
 
 	/**
@@ -535,7 +535,7 @@ class StringTools {
 		quoteWinArg("abc") == "abc";
 		quoteWinArg("ab c") == '"ab c"';
 		```
-	*/
+	**/
 	public static function quoteWinArg(argument:String, escapeMetaCharacters:Bool):String {
 		// If there is no space, tab, back-slash, or double-quotes, and it is not an empty string.
 		if (!~/^[^ \t\\"]+$/.match(argument)) {

std/haxe/Int64.hx

@@ -446,10 +446,10 @@ abstract Int64(__Int64) from __Int64 to __Int64
 }
 
 /**
-  * This typedef will fool @:coreApi into thinking that we are using
-  * the same underlying type, even though it might be different on
-  * specific platforms.
-  */
+	This typedef will fool `@:coreApi` into thinking that we are using
+	the same underlying type, even though it might be different on
+	specific platforms.
+**/
 private typedef __Int64 = ___Int64;
 
 private class ___Int64 {
@@ -463,8 +463,8 @@ private class ___Int64 {
 
 	/**
 		We also define toString here to ensure we always get a pretty string
-		when tracing or calling Std.string. This tends not to happen when
-		toString is only in the abstract.
+		when tracing or calling `Std.string`. This tends not to happen when
+		`toString` is only in the abstract.
 	**/
 	public function toString() : String
 		return Int64.toStr( cast this );

std/haxe/crypto/Sha1.hx

@@ -133,14 +133,14 @@ class Sha1 {
 
 	/**
 		Bitwise rotate a 32-bit number to the left
-	 */
+	**/
 	inline function rol( num : Int, cnt : Int ) : Int {
 		return (num << cnt) | (num >>> (32 - cnt));
 	}
 
 	/**
 		Perform the appropriate triplet combination function for the current iteration
-	*/
+	**/
 	function ft( t : Int, b : Int, c : Int, d : Int ) : Int {
 		if ( t < 20 ) return (b & c) | ((~b) & d);
 		if ( t < 40 ) return b ^ c ^ d;
@@ -150,7 +150,7 @@ class Sha1 {
 
 	/**
 		Determine the appropriate additive constant for the current iteration
-	*/
+	**/
 	function kt( t : Int ) : Int {
 		if( t < 20)
 			return 0x5A827999;

std/haxe/macro/Compiler.hx

@@ -463,16 +463,16 @@ class Compiler {
 enum abstract IncludePosition(String) from String to String {
 	/**
 		Prepend the file content to the output file.
-	*/
+	**/
 	var Top = "top";
 	/**
 		Prepend the file content to the body of the top-level closure.
 
 		Since the closure is in strict-mode, there may be run-time error if the input is not strict-mode-compatible.
-	*/
+	**/
 	var Closure = "closure";
 	/**
 		Directly inject the file content at the call site.
-	*/
+	**/
 	var Inline = "inline";
 }

std/haxe/macro/Context.hx

@@ -229,7 +229,7 @@ class Context {
 		by calling `haxe.macro.Compiler.define`.
 
 		Modifying the returned map has no effect on the compiler.
-	 */
+	**/
 	public static function getDefines() : Map<String,String> {
 		return load("get_defines", 0)();
 	}

std/haxe/macro/ExprTools.hx

@@ -301,7 +301,7 @@ class ExprTools {
 /**
 	This class provides functions on expression arrays for convenience. For a
 	detailed reference on each method, see the documentation of ExprTools.
- */
+**/
 class ExprArrayTools {
 	static public function map( el : Array<Expr>, f : Expr -> Expr):Array<Expr> {
 		var ret = [];

std/haxe/xml/Parser.hx

@@ -48,28 +48,28 @@ private enum abstract S(Int) {
 class XmlParserException
 {
 	/**
-	 * the XML parsing error message
-	 */
+		the XML parsing error message
+	**/
 	public var message:String;
 
 	/**
-	 * the line number at which the XML parsing error occurred
-	 */
+		the line number at which the XML parsing error occurred
+	**/
 	public var lineNumber:Int;
 
 	/**
-	 * the character position in the reported line at which the parsing error occurred
-	 */
+		the character position in the reported line at which the parsing error occurred
+	**/
 	public var positionAtLine:Int;
 
 	/**
-	 * the character position in the XML string at which the parsing error occurred
-	 */
+		the character position in the XML string at which the parsing error occurred
+	**/
 	public var position:Int;
 
 	/**
-	 * the invalid XML string
-	 */
+		the invalid XML string
+	**/
 	public var xml:String;
 
 	public function new(message:String, xml:String, position:Int)
@@ -111,10 +111,10 @@ class Parser
 	}
 
 	/**
-	 * Parses the String into an XML Document. Set strict parsing to true in order to enable a strict check of XML attributes and entities.
-	 *
-	 * @throws haxe.xml.XmlParserException
-	 */
+		Parses the String into an XML Document. Set strict parsing to true in order to enable a strict check of XML attributes and entities.
+		
+		@throws haxe.xml.XmlParserException
+	**/
 	static public function parse(str:String, strict = false)
 	{
 		var doc = Xml.createDocument();

std/haxe/zip/Writer.hx

@@ -25,20 +25,20 @@ import haxe.ds.List;
 
 class Writer {
 
-	/*
-	* The next constant is required for computing the Central
-	* Directory Record(CDR) size. CDR consists of some fields
-	* of constant size and a filename. Constant represents
-	* total length of all fields with constant size for each
-	* file in archive
-	*/
+	/**
+		The next constant is required for computing the Central
+		Directory Record(CDR) size. CDR consists of some fields
+		of constant size and a filename. Constant represents
+		total length of all fields with constant size for each
+		file in archive
+	**/
 	inline static var CENTRAL_DIRECTORY_RECORD_FIELDS_SIZE = 46;
 
-	/*
-	* The following constant is the total size of all fields
-	* of Local File Header. It's required for calculating
-	* offset of start of central directory record
-	*/
+	/**
+		The following constant is the total size of all fields
+		of Local File Header. It's required for calculating
+		offset of start of central directory record
+	**/
 	inline static var LOCAL_FILE_HEADER_FIELDS_SIZE = 30;
 
 	var o : haxe.io.Output;

std/hl/vm/Deque.hx

@@ -29,27 +29,27 @@ abstract Deque<T>(hl.Abstract<"hl_deque">) {
 
 	/**
 		Create a message queue for multithread access.
-	*/
+	**/
 	public function new() {
 		this = alloc();
 	}
 
 	/**
 		Add a message at the end of the queue.
-	*/
+	**/
 	public function add( i : T ) {
 	}
 
 	/**
 		Add a message at the head of the queue.
-	*/
+	**/
 	public function push( i : T ) {
 	}
 
 	/**
 		Pop a message from the queue head. Either block until a message
 		is available or return immediately with `null`.
-	*/
+	**/
 	public function pop( block : Bool ) : Null<T> {
 		return null;
 	}

std/hl/vm/Mutex.hx

@@ -25,12 +25,12 @@ package hl.vm;
 	Creates a mutex, which can be used to acquire a temporary lock 
 	to access some ressource. The main difference with a lock is 
 	that a mutex must always be released by the owner thread.
-*/
+**/
 abstract Mutex(hl.Abstract<"hl_mutex">) {
 
 	/**
 		Creates a mutex.
-	*/
+	**/
 	public function new() {
 		this = alloc(true);
 	}
@@ -39,14 +39,14 @@ abstract Mutex(hl.Abstract<"hl_mutex">) {
 		The current thread acquire the mutex or wait if not available.
 		The same thread can acquire several times the same mutex but 
 		must release it as many times it has been acquired.
-	*/
+	**/
 	@:hlNative("std","mutex_acquire") public function acquire() {
 	}
 
 	/**
 		Try to acquire the mutex, returns true if acquire or false 
 		if it's already locked by another thread.
-	*/
+	**/
 	@:hlNative("std","mutex_try_acquire") public function tryAcquire() : Bool {
 		return false;
 	}
@@ -55,7 +55,7 @@ abstract Mutex(hl.Abstract<"hl_mutex">) {
 		Release a mutex that has been acquired by the current thread. 
 		The behavior is undefined if the current thread does not own
 		the mutex.
-	*/
+	**/
 	@:hlNative("std","mutex_release") public function release() {
 	}
 

std/hl/vm/Tls.hx

@@ -35,21 +35,21 @@ abstract Tls<T>(hl.Abstract<"hl_tls">) {
 		a value that will be different depending on the local thread. 
 		Set the tls value to `null` before exiting the thread 
 		or the memory will never be collected.
-	*/
+	**/
 	public function new() {
 		this = tls_alloc(true);
 	}
 
 	/**
 		Returns the value set by tls_set for the local thread.
-	*/
+	**/
 	function get_value() : T {
 		return tls_get(this);
 	}
 
 	/**
 		Set the value of the TLS for the local thread.
-	*/
+	**/
 	function set_value( v : T ) {
 		tls_set(this, v);
 		return v;

std/js/Syntax.hx

@@ -58,6 +58,6 @@ extern class Syntax {
 	/**
 		Generate `o.f` expression, if `f` is a constant string,
 		or `o[f]` if it's any other expression.
-	*/
+	**/
 	static function field(o:Dynamic, f:String):Dynamic;
 }

std/lua/Boot.hx

@@ -44,26 +44,26 @@ class Boot {
 	static function __unhtml(s : String)
 		return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
 
-	/*
+	/**
 	   Indicates if the given object is a class.
-	*/
+	**/
 	static inline public function isClass(o:Dynamic) : Bool {
 		if (Lua.type(o) != "table") return false;
 		else return untyped __define_feature__("lua.Boot.isClass", o.__name__);
 	}
 
-	/*
+	/**
 	   Indicates if the given object is a enum.
-	*/
+	**/
 	static inline public function isEnum(e:Dynamic) : Bool {
 		if (Lua.type(e) != "table") return false;
 		else return untyped __define_feature__("lua.Boot.isEnum", e.__ename__);
 	}
 
-	/*
+	/**
 	   Returns the class of a given object, and defines the getClass feature
 	   for the given class.
-	*/
+	**/
 	static inline public function getClass(o:Dynamic) : Class<Dynamic> {
 		if (Std.is(o, Array)) return Array;
 		else if (Std.is(o, String)) return String;
@@ -74,9 +74,9 @@ class Boot {
 		}
 	}
 
-	/*
+	/**
 	   Indicates if the given object is an instance of the given Type
-	*/
+	**/
 	@:ifFeature("typed_catch")
 	private static function __instanceof(o : Dynamic, cl : Dynamic) {
 		if( cl == null ) return false;
@@ -122,9 +122,9 @@ class Boot {
 			&& Lua.getmetatable(o).__index == untyped Array.prototype;
 	}
 
-	/*
+	/**
 	   Indicates if the given object inherits from the given class
-	*/
+	**/
 	static function inheritsFrom(o:Dynamic, cl:Class<Dynamic>) : Bool {
 		while (Lua.getmetatable(o) != null && Lua.getmetatable(o).__index != null){
 			if (Lua.getmetatable(o).__index == untyped cl.prototype) return true;
@@ -139,9 +139,9 @@ class Boot {
 		else throw "Cannot cast " +Std.string(o) + " to " +Std.string(t);
 	}
 
-	/*
+	/**
 	   Helper method to generate a string representation of an enum
-	*/
+	**/
 	static function printEnum(o:Array<Dynamic>, s : String){
 		if (o.length == 2){
 			return o[0];
@@ -159,25 +159,25 @@ class Boot {
 		}
 	}
 
-	/*
+	/**
 	   Helper method to generate a string representation of a class
-	*/
+	**/
 	static inline function printClass(c:Table<String,Dynamic>, s : String) : String {
 		return '{${printClassRec(c,'',s)}}';
 	}
 
-	/*
+	/**
 	   Helper method to generate a string representation of a class
-	*/
+	**/
 	static function printClassRec(c:Table<String,Dynamic>, result='', s : String) : String {
 		var f = Boot.__string_rec;
 		untyped __lua__("for k,v in pairs(c) do if result ~= '' then result = result .. ', ' end result = result .. k .. ':' .. f(v, s.. '\t') end");
 		return result;
 	}
 
-	/*
+	/**
 	   Generate a string representation for arbitrary object.
-	*/
+	**/
 	@:ifFeature("has_enum")
 	static function __string_rec(o : Dynamic, s:String = "") {
 		return switch(untyped __type__(o)){
@@ -232,9 +232,9 @@ class Boot {
 
 	}
 
-	/*
+	/**
 	   Define an array from the given table
-	*/
+	**/
 	public inline static function defArray<T>(tab: Table<Int,T>, ?length : Int) : Array<T> {
 		if (length == null){
 			length = TableTools.maxn(tab);
@@ -251,16 +251,16 @@ class Boot {
 		}
 	}
 
-	/*
+	/**
 	   Create a Haxe object from the given table structure
-	*/
+	**/
 	public inline static function tableToObject<T>(t:Table<String,T>) : Dynamic<T> {
 		return untyped _hx_o(t);
 	}
 
-	/*
+	/**
 	   Get Date object as string representation
-	*/
+	**/
 	public static function dateStr( date : std.Date ) : String {
 		var m = date.getMonth() + 1;
 		var d = date.getDate();
@@ -275,16 +275,16 @@ class Boot {
 			+":"+(if( s < 10 ) "0"+s else ""+s);
 	}
 
-	/*
+	/**
 	   A 32 bit clamp function for numbers
-	*/
+	**/
 	public inline static function clamp(x:Float){
 		return untyped __define_feature__("lua.Boot.clamp", _hx_bit_clamp(x));
 	}
 
-	/*
+	/**
 	   Create a standard date object from a lua string representation
-	*/
+	**/
 	public static function strDate( s : String ) : std.Date {
 		switch( s.length ) {
 		case 8: // hh:mm:ss
@@ -311,9 +311,9 @@ class Boot {
 		}
 	}
 
-	/*
+	/**
 	  Helper method to determine if class cl1 extends, implements, or otherwise equals cl2
-	*/
+	**/
 	public static function extendsOrImplements(cl1 : Class<Dynamic>, cl2 : Class<Dynamic>) : Bool {
 		if (cl1 == null || cl2 == null) return false;
 		else if (cl1 == cl2) return true;
@@ -329,9 +329,9 @@ class Boot {
 	}
 
 
-	/*
+	/**
 		Returns a shell escaped version of "cmd" along with any args
-	*/
+	**/
 	public static function shellEscapeCmd(cmd : String, ?args : Array<String>){
 		if (args != null) {
 			switch (Sys.systemName()) {
@@ -347,9 +347,9 @@ class Boot {
 		return cmd;
 	}
 
-	/*
+	/**
 	   Returns a temp file path that can be used for reading and writing
-	*/
+	**/
 	public static function tempFile() : String {
 		switch (Sys.systemName()){
 			case "Windows" : return haxe.io.Path.join([Os.getenv("TMP"), Os.tmpname()]);

std/neko/Random.hx

@@ -30,28 +30,28 @@ class Random {
 
 	/**
 		Create a new random with random seed.
-	*/
+	**/
 	public function new() {
 		r = random_new();
 	}
 
 	/**
 		Set the generator seed.
-	*/
+	**/
 	public function setSeed( s : Int ) {
 		random_set_seed(r,s);
 	}
 
 	/**
 		Return a random integer modulo max.
-	*/
+	**/
 	public function int( max : Int ) : Int {
 		return random_int(r,max);
 	}
 
 	/**
 		Return a random float.
-	*/
+	**/
 	public function float() : Float {
 		return random_float(r);
 	}

std/neko/vm/Deque.hx

@@ -29,21 +29,21 @@ class Deque<T> {
 
 	/**
 		Create a message queue for multithread access.
-	*/
+	**/
 	public function new() {
 		q = deque_create();
 	}
 
 	/**
 		Add a message at the end of the queue.
-	*/
+	**/
 	public function add( i : T ) {
 		deque_add(q,i);
 	}
 
 	/**
 		Add a message at the head of the queue.
-	*/
+	**/
 	public function push( i : T ) {
 		deque_push(q,i);
 	}
@@ -51,7 +51,7 @@ class Deque<T> {
 	/**
 		Pop a message from the queue head. Either block until a message 
 		is available or return immediately with `null`.
-	*/
+	**/
 	public function pop( block : Bool ) : Null<T> {
 		return deque_pop(q,block);
 	}

std/neko/vm/Gc.hx

@@ -27,7 +27,7 @@ package neko.vm;
 class Gc {
 	/**
 		Run the Neko garbage collector.
-	*/
+	**/
 	public static function run( major : Bool ) {
 		_run(major);
 	}
@@ -35,7 +35,7 @@ class Gc {
 	/**
 		Return the size of the GC heap and the among of free space, 
 		in bytes.
-	*/
+	**/
 	public static function stats() : { heap : Int, free : Int } {
 		return _stats();
 	}

std/neko/vm/Lock.hx

@@ -26,7 +26,7 @@ class Lock {
 
 	/**
 		Creates a lock which is initially locked.
-	*/
+	**/
 	public function new() {
 		l = lock_create();
 	}
@@ -35,7 +35,7 @@ class Lock {
 		Waits for a lock to be released and acquire it. If timeout 
 		(in seconds) is not `null` and expires then the returned 
 		value is `false`.
-	*/
+	**/
 	public function wait( ?timeout : Float ) : Bool {
 		return lock_wait(l,timeout);
 	}
@@ -44,7 +44,7 @@ class Lock {
 		Release a lock. The thread does not need to own the lock 
 		to be able to release it. If a lock is released several 
 		times, it can be acquired as many times.
-	*/
+	**/
 	public function release() {
 		lock_release(l);
 	}

std/neko/vm/Mutex.hx

@@ -31,7 +31,7 @@ class Mutex {
 
 	/**
 		Creates a mutex.
-	*/
+	**/
 	public function new() {
 		m = mutex_create();
 	}
@@ -40,7 +40,7 @@ class Mutex {
 		The current thread acquire the mutex or wait if not available.
 		The same thread can acquire several times the same mutex but 
 		must release it as many times it has been acquired.
-	*/
+	**/
 	public function acquire() {
 		mutex_acquire(m);
 	}
@@ -48,7 +48,7 @@ class Mutex {
 	/**
 		Try to acquire the mutex, returns true if acquire or false 
 		if it's already locked by another thread.
-	*/
+	**/
 	public function tryAcquire() : Bool {
 		return mutex_try(m);
 	}
@@ -57,7 +57,7 @@ class Mutex {
 		Release a mutex that has been acquired by the current thread. 
 		The behavior is undefined if the current thread does not own
 		the mutex.
-	*/
+	**/
 	public function release() {
 		mutex_release(m);
 	}

std/neko/vm/Tls.hx

@@ -34,21 +34,21 @@ class Tls<T> {
 		a value that will be different depending on the local thread. 
 		Set the tls value to `null` before exiting the thread 
 		or the memory will never be collected.
-	*/
+	**/
 	public function new() {
 		t = tls_create();
 	}
 
 	/**
 		Returns the value set by tls_set for the local thread.
-	*/
+	**/
 	function get_value() : T {
 		return tls_get(t);
 	}
 
 	/**
 		Set the value of the TLS for the local thread.
-	*/
+	**/
 	function set_value( v : T ) {
 		tls_set(t,v);
 		return v;

std/neko/vm/Ui.hx

@@ -31,7 +31,7 @@ class Ui {
 		Tells if the current thread is the main loop thread or not. 
 		The main loop thread is the one in which the first "ui" 
 		library primitive has been loaded.
-	*/
+	**/
 	public static function isMainThread() {
 		return _is_main_thread();
 	}
@@ -39,7 +39,7 @@ class Ui {
 	/**
 		Starts the native UI event loop. This method can only be called 
 		from the main thread.
-	*/
+	**/
 	public static function loop() {
 		_loop();
 	}
@@ -47,7 +47,7 @@ class Ui {
 	/**
 		Stop the native UI event loop. This method can only be called 
 		from the main thread.
-	*/
+	**/
 	public static function stopLoop() {
 		_sync(_stop_loop);
 	}
@@ -56,7 +56,7 @@ class Ui {
 		Queue a method call callb to be executed by the main thread while 
 		running the UI event loop. This can be used to perform UI updates 
 		in the UI thread using results processed by another thread.
-	*/
+	**/
 	public static function sync( f : Void -> Void ) {
 		_sync(f);
 	}

std/php/Global.hx

@@ -282,7 +282,7 @@ extern class Global {
 
 	/**
 		@see http://php.net/manual/en/function.constant.php
-	*/
+	**/
 	static function constant( name:String ) : Dynamic;
 
 	/**

std/php/Lib.hx

@@ -51,7 +51,7 @@ class Lib {
 		Displays structured information about one or more expressions
 		that includes its type and value. Arrays and objects are
 		explored recursively with values indented to show structure.
-	*/
+	**/
 	public static inline function dump(v : Dynamic) : Void {
 		Global.var_dump(v);
 	}
@@ -73,7 +73,7 @@ class Lib {
 
 	/**
 		Find out whether an extension is loaded.
-	*/
+	**/
 	public static inline function extensionLoaded(name : String) {
 		return Global.extension_loaded(name);
 	}
@@ -84,7 +84,7 @@ class Lib {
 
 	/**
 		Output file content from the given file name.
-	*/
+	**/
 	public static inline function printFile(file : String) {
 		return Global.fpassthru(Global.fopen(file,  "r"));
 	}
@@ -121,14 +121,9 @@ class Lib {
 	}
 
 	/**
-	 * See the documentation for the equivalent PHP function for details on usage:
-	 * <http://php.net/manual/en/function.mail.php>
-	 * @param	to
-	 * @param	subject
-	 * @param	message
-	 * @param	?additionalHeaders
-	 * @param	?additionalParameters
-	 */
+		See the documentation for the equivalent PHP function for details on usage:
+		<http://php.net/manual/en/function.mail.php>
+	**/
 	public static inline function mail(to : String, subject : String, message : String, ?additionalHeaders : String, ?additionalParameters : String) : Bool {
 		return Global.mail(to, subject, message, additionalHeaders, additionalParameters);
 	}

std/php/Syntax.hx

@@ -175,7 +175,7 @@ extern class Syntax {
         ```haxe
         trace(Syntax.nativeClassName(php.Web)); // outputs: php\Web
         ```
-     */
+    **/
     static function nativeClassName<T>(cls:EitherType<Class<T>, Enum<T>>) : String;
 
     /**
@@ -290,7 +290,7 @@ extern class Syntax {
     /**
         Generates `clone $value`.
         @see http://php.net/manual/en/language.oop5.cloning.php
-     */
+    **/
     static inline function clone<T>(value:T):T {
         return Syntax.code('(clone {0})', value);
     }
@@ -298,7 +298,7 @@ extern class Syntax {
     /**
         Generates `yield $value`.
         @see http://php.net/manual/en/language.generators.syntax.php
-     */
+    **/
     static inline function yield(value:Dynamic):Dynamic {
         return Syntax.code('yield {0}', value);
     }
@@ -306,7 +306,7 @@ extern class Syntax {
     /**
         Generates `yield $key => $value`.
         @see http://php.net/manual/en/language.generators.syntax.php
-     */
+    **/
     static inline function yieldPair(key:Dynamic, value:Dynamic):Dynamic {
         return Syntax.code('yield {0} => {1}', key, value);
     }
@@ -314,7 +314,7 @@ extern class Syntax {
     /**
         Generates `yield for $value`.
         @see http://php.net/manual/en/language.generators.syntax.php
-     */
+    **/
     static inline function yieldFrom(value:Dynamic):Dynamic {
         return Syntax.code('yield from {0}', value);
     }

std/php/_std/StringTools.hx

@@ -124,7 +124,7 @@ import php.*;
 		Returns a String that can be used as a single command line argument
 		on Unix.
 		The input will be quoted, or escaped if necessary.
-	*/
+	**/
 	public static function quoteUnixArg(argument:String):String {
 		// Based on cpython's shlex.quote().
 		// https://hg.python.org/cpython/file/a3f076d4f54f/Lib/shlex.py#l278
@@ -142,7 +142,7 @@ import php.*;
 
 	/**
 		Character codes of the characters that will be escaped by `quoteWinArg(_, true)`.
-	*/
+	**/
 	public static var winMetaCharacters = [";".code, ",".code, " ".code, "(".code, ")".code, "%".code, "!".code, "^".code, "\"".code, "<".code, ">".code, "&".code, "|".code, "\n".code, "\r".code];
 
 	/**
@@ -157,7 +157,7 @@ import php.*;
 		quoteWinArg("abc") == "abc";
 		quoteWinArg("ab c") == '"ab c"';
 		```
-	*/
+	**/
 	public static function quoteWinArg(argument:String, escapeMetaCharacters:Bool):String {
 		// If there is no space, tab, back-slash, or double-quotes, and it is not an empty string.
 		if (!~/^[^ \t\\"]+$/.match(argument)) {

std/php/_std/haxe/CallStack.hx

@@ -20,7 +20,7 @@ class CallStack {
 		If defined this function will be used to transform call stack entries.
 		@param String - generated php file name.
 		@param Int - Line number in generated file.
-	*/
+	**/
 	static public var mapPosition : String->Int->Null<{?source:String, ?originalLine:Int}>;
 
 	@:ifFeature("haxe.CallStack.exceptionStack")

std/php/_std/sys/io/Process.hx

@@ -132,7 +132,7 @@ class Process {
 		It can run executables, as well as shell commands that are not executables (e.g. on Windows: `dir`, `cd`, `echo` etc).
 
 		`close()` should be called when the `Process` is no longer used.
-	*/
+	**/
 	public function new( cmd : String, ?args : Array<String>, ?detached : Bool ) : Void {
 		if( detached ) throw "Detached process is not supported on this platform";
 		var descriptors = Syntax.arrayDecl(
@@ -153,7 +153,7 @@ class Process {
 
 	/**
 		Return the process ID.
-	*/
+	**/
 	public function getPid() : Int {
 		return pid;
 	}
@@ -174,7 +174,7 @@ class Process {
 	/**
 		Close the process handle and release the associated resources.
 		All `Process` fields should not be used after `close()` is called.
-	*/
+	**/
 	public function close() : Void {
 		if (!running) return;
 
@@ -184,7 +184,7 @@ class Process {
 
 	/**
 		Kill the process.
-	*/
+	**/
 	public function kill() : Void {
 		process.proc_terminate();
 	}

std/sys/io/Process.hx

@@ -51,12 +51,12 @@ extern class Process {
 		`detached` allows the created process to be standalone. You cannot communicate with it but you can look at its exit code.
 		
 		`close()` should be called when the `Process` is no longer used.
-	*/
+	**/
 	function new( cmd : String, ?args : Array<String>, ?detached : Bool ) : Void;
 
 	/**
 		Return the process ID.
-	*/
+	**/
 	function getPid() : Int;
 
 	/**
@@ -64,18 +64,18 @@ extern class Process {
 		If `block` is true or not specified, it will block until the process terminates.
 		If `block` is false, it will return either the process exit code if it's already terminated or null if it's still running.
 		If the process has already exited, return the exit code immediately.
-	*/
+	**/
 	function exitCode( block : Bool = true ) : Null<Int>;
 
 	/**
 		Close the process handle and release the associated resources.
 		All `Process` fields should not be used after `close()` is called.
-	*/
+	**/
 	function close() : Void;
 
 	/**
 		Kill the process.
-	*/
+	**/
 	function kill() : Void;
 
 }