Page Menu
Home
WickedGov Phorge
Search
Configure Global Search
Log In
Files
F7403699
MhchemPatterns.php
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Size
15 KB
Referenced Files
None
Subscribers
None
MhchemPatterns.php
View Options
<?php
/**
* Copyright (c) 2023 Johannes Stegmüller
*
* This file is a port of mhchemParser originally authored by Martin Hensel in javascript/typescript.
* The original license for this software can be found in the accompanying LICENSE.mhchemParser-ts.txt file.
*/
declare
(
strict_types
=
1
);
namespace
MediaWiki\Extension\Math\WikiTexVC\Mhchem
;
use
MediaWiki\Extension\Math\WikiTexVC\Mhchem\MhchemRegExp
as
Reg
;
use
RuntimeException
;
/**
* Contains all matching regex patterns and match functions for mhchemParser in PHP.
*
* corresponds mostly to the 'patterns' array in line ~207 in mhchemParser.js by Martin Hensel
*
* @author Johannes Stegmüller
* @license GPL-2.0-or-later
*/
class
MhchemPatterns
{
/** @var array */
private
array
$patterns
;
/**
* Matching patterns
* either regexes or function that return null or {match_:"a", remainder:"bc"}
* @return array
*/
public
function
getPatterns
():
array
{
return
$this
->
patterns
;
}
/**
* @param string $input
* @param string|Reg $begExcl
* @param string|Reg $begIncl
* @param mixed|null $endIncl
* @param mixed|null $endExcl
* @param string|Reg|null $beg2Excl
* @param string|Reg|null $beg2Incl
* @param mixed|null $end2Incl
* @param mixed|null $end2Excl
* @param bool|null $combine
*/
public
function
findObserveGroups
(
$input
,
$begExcl
,
$begIncl
,
$endIncl
,
$endExcl
=
null
,
$beg2Excl
=
null
,
$beg2Incl
=
null
,
$end2Incl
=
null
,
$end2Excl
=
null
,
$combine
=
null
):
?
array
{
$match
=
$this
->
matchObsGrInner
(
$input
,
$begExcl
);
if
(
$match
===
null
)
{
return
null
;
}
$input
=
substr
(
$input
,
strlen
(
$match
)
);
$match
=
$this
->
matchObsGrInner
(
$input
,
$begIncl
);
if
(
$match
===
null
)
{
return
null
;
}
if
(
$endIncl
===
"0"
)
{
throw
new
RuntimeException
(
"error in condition, check next loc "
);
}
$e
=
$this
->
findObserveGroupsInner
(
$input
,
strlen
(
$match
),
MhchemUtil
::
issetJS
(
$endIncl
)
?
$endIncl
:
$endExcl
);
if
(
$e
===
null
)
{
return
null
;
}
$match1
=
substr
(
$input
,
0
,
(
$endIncl
?
$e
[
"endMatchEnd"
]
:
$e
[
"endMatchBegin"
]
)
);
if
(
!(
MhchemUtil
::
issetJS
(
$beg2Excl
)
||
MhchemUtil
::
issetJS
(
$beg2Incl
)
)
)
{
return
[
"match_"
=>
$match1
,
"remainder"
=>
substr
(
$input
,
$e
[
"endMatchEnd"
]
)
];
}
else
{
$group2
=
$this
->
findObserveGroups
(
substr
(
$input
,
$e
[
"endMatchEnd"
]
),
$beg2Excl
,
$beg2Incl
,
$end2Incl
,
$end2Excl
);
if
(
$group2
===
null
)
{
return
null
;
}
$matchRet
=
[
$match1
,
$group2
[
"match_"
]
];
return
[
"match_"
=>
(
$combine
?
implode
(
""
,
$matchRet
)
:
$matchRet
),
"remainder"
=>
$group2
[
"remainder"
]
];
}
}
/**
* @param string $input
* @param string|Reg $pattern
* @return string|null
*/
private
function
matchObsGrInner
(
string
$input
,
$pattern
)
{
/**
* In javascript this is checking if the incoming pattern is a string,
* if not the assumption is that it is of regex type. Since PHP has
* strings here.
*/
if
(
!
$pattern
instanceof
Reg
)
{
// Added this if to catch empty needle for strpos input in PHP
if
(
!
MhchemUtil
::
issetJS
(
$pattern
)
||
str_starts_with
(
$input
,
$pattern
)
)
{
return
$pattern
;
}
}
elseif
(
preg_match
(
$pattern
->
getRegExp
(),
$input
,
$matches
)
)
{
return
$matches
[
0
];
}
return
null
;
}
/**
* @param string $input
* @param int $i
* @param string $endChars
* @return array|null
*/
private
function
findObserveGroupsInner
(
string
$input
,
$i
,
$endChars
):
?
array
{
$braces
=
0
;
while
(
$i
<
strlen
(
$input
)
)
{
$a
=
$input
[
$i
];
$match
=
$this
->
matchObsGrInner
(
substr
(
$input
,
$i
),
$endChars
);
if
(
$match
!==
null
&&
$braces
===
0
)
{
return
[
"endMatchBegin"
=>
$i
,
"endMatchEnd"
=>
$i
+
strlen
(
$match
)
];
}
elseif
(
$a
===
"{"
)
{
$braces
++;
}
elseif
(
$a
===
"}"
)
{
if
(
$braces
===
0
)
{
// Unexpected character
throw
new
RuntimeException
(
"ExtraCloseMissingOpen: Extra close brace or missing open brace"
);
}
else
{
$braces
--;
}
}
$i
++;
}
return
null
;
}
public
function
__construct
()
{
$this
->
patterns
=
[
'empty'
=>
new
Reg
(
"/^$/"
),
'else'
=>
new
Reg
(
"/^./"
),
'else2'
=>
new
Reg
(
"/^./"
),
'space'
=>
new
Reg
(
"/^
\s
/"
),
'space A'
=>
new
Reg
(
"/^
\s
(?=[A-Z
\\\\
$])/"
),
'space$'
=>
new
Reg
(
"/^
\s
$/"
),
'a-z'
=>
new
Reg
(
"/^[a-z]/"
),
'x'
=>
new
Reg
(
"/^x/"
),
'x$'
=>
new
Reg
(
"/^x$/"
),
'i$'
=>
new
Reg
(
"/^i$/"
),
'letters'
=>
new
Reg
(
"/^(?:[a-zA-Z
\x
{03B1}-
\x
{03C9}
\x
{0391}-
\x
{03A9}?@]|(?:
\\\\
(?:alpha|beta|gamma|delta|epsilon"
.
"|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma"
.
"|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:
\s
+|
\{\}
|(?![a-zA-Z]))))+/u"
),
'
\\
greek'
=>
new
Reg
(
"/^
\\\\
(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi"
.
"|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)"
.
"(?:
\s
+|
\{\}
|(?![a-zA-Z]))/"
),
'one lowercase latin letter $'
=>
new
Reg
(
"/^(?:([a-z])(?:$|[^a-zA-Z]))$/"
),
'$one lowercase latin letter$ $'
=>
new
Reg
(
"/^
\\\$
(?:([a-z])(?:$|[^a-zA-Z]))
\\\$
$/"
),
'one lowercase greek letter $'
=>
new
Reg
(
"/^(?:
\\\$
?[
\x
{003B1}-
\x
{0003C9}]
\\\$
?|
\\\$
?
\\\\
(?:alpha|beta|gamma|"
.
"delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|"
.
"phi|chi|psi|omega)
\s
*
\\\$
?)(?:
\s
+|
\{\}
|(?![a-zA-Z]))$/u"
),
'digits'
=>
new
Reg
(
"/^[0-9]+/"
),
'-9.,9'
=>
new
Reg
(
"/^[+
\-
]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:
\.
[0-9]+))/"
),
'-9.,9 no missing 0'
=>
new
Reg
(
"/^[+
\-
]?[0-9]+(?:[.,][0-9]+)?/"
),
'(-)(9.,9)(e)(99)'
=>
static
function
(
$input
)
{
$matches
=
[];
$match
=
preg_match
(
"/^(
\+\-
|
\+\/\-
|
\+
|
\-
|
\\\\
pm
\s
?)?([0-9]+(?:[,.][0-9]+)?|"
.
"[0-9]*(?:
\.
[0-9]+))?(
\(
(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:
\.
[0-9]+))
\)
)?(?:(?:([eE])"
.
"|
\s
*(
\*
|x|
\\\\
times|
\x
{00D7})
\s
*10
\^
)([+
\-
]?[0-9]+|
\{
[+
\-
]?[0-9]+
\}
))?/u"
,
$input
,
$matches
);
if
(
$match
&&
$matches
[
0
]
)
{
// could also match ""
return
[
"match_"
=>
array_slice
(
$matches
,
1
),
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
return
null
;
},
'(-)(9)^(-9)'
=>
new
Reg
(
"/^(
\+\-
|
\+\/\-
|
\+
|
\-
|
\\\\
pm
\s
?)?([0-9]+(?:[,.][0-9]+)?|"
.
"[0-9]*(?:
\.
[0-9]+)?)
\^
([+
\-
]?[0-9]+|
\{
[+
\-
]?[0-9]+
\}
)/"
),
'state of aggregation $'
=>
function
(
$input
)
{
// ... or crystal system
$a
=
$this
->
findObserveGroups
(
$input
,
""
,
new
Reg
(
"/^
\(
[a-z]{1,3}(?=[
\)
,])/"
),
")"
,
""
);
if
(
$a
&&
preg_match
(
"/^($|[
\s
,;
\)\]\}
])/"
,
$a
[
"remainder"
]
)
)
{
return
$a
;
}
$matches
=
[];
$match
=
preg_match
(
"/^(?:
\(
(?:
\\\\
ca
\s
?)?
\\\$
[amothc]
\\\$\)
)/"
,
$input
,
$matches
);
if
(
$match
)
{
return
[
"match_"
=>
$matches
[
0
],
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
return
null
;
},
'_{(state of aggregation)}$'
=>
new
Reg
(
"/^_
\{
(
\(
[a-z]{1,3}
\)
)
\}
/"
),
'{[('
=>
new
Reg
(
"/^(?:
\\\{
|
\[
|
\(
)/"
),
')]}'
=>
new
Reg
(
"/^(?:
\)
|
\]
|
\\\}
)/"
),
', '
=>
new
Reg
(
"/^[,;]
\s
*/"
),
','
=>
new
Reg
(
"/^[,;]/"
),
'.'
=>
new
Reg
(
"/^[.]/"
),
'. __* '
=>
new
Reg
(
"/^([.
\x
{22C5}
\x
{00B7}
\x
{2022}]|[*])
\s
*/u"
),
'...'
=>
new
Reg
(
"/^
\.\.\.
(?=$|[^.])/"
),
'^{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"^{"
,
""
,
""
,
"}"
);
},
'^($...$)'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"^"
,
"$"
,
"$"
,
""
);
},
'^a'
=>
new
Reg
(
"/^
\^
([0-9]+|[^
\\\_
])/u"
),
'^
\\
x{}{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"^"
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
,
""
,
"{"
,
"}"
,
""
,
true
);
},
'^
\\
x{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"^"
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
);
},
'^
\\
x'
=>
new
Reg
(
"/^
\^
(
\\\\
[a-zA-Z]+)
\s
*/"
),
'^(-1)'
=>
new
Reg
(
"/^
\^
(-?
\d
+)/"
),
'
\'
'
=>
new
Reg
(
"/^'/"
),
'_{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"_{"
,
""
,
""
,
"}"
);
},
'_($...$)'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"_"
,
"$"
,
"$"
,
""
);
},
'_9'
=>
new
Reg
(
"/^_([+
\-
]?[0-9]+|[^
\\\\
])/"
),
'_
\\
x{}{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"_"
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
,
""
,
"{"
,
"}"
,
""
,
true
);
},
'_
\\
x{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"_"
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
);
},
'_
\\
x'
=>
new
Reg
(
"/^_(
\\\\
[a-zA-Z]+)
\s
*/"
),
'^_'
=>
new
Reg
(
"/^(?:
\^
(?=_)|
\_
(?=
\^
)|[
\^
_]$)/"
),
'{}^'
=>
new
Reg
(
"/^
\{\}
(?=
\^
)/"
),
'{}'
=>
new
Reg
(
"/^
\{\}
/"
),
'{...}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
""
,
"{"
,
"}"
,
""
);
},
'{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"{"
,
""
,
""
,
"}"
);
},
'$...$'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
""
,
"
\$
"
,
"
\$
"
,
""
);
},
'${(...)}$__$(...)$'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\$
{"
,
""
,
""
,
"}
\$
"
)
??
$this
->
findObserveGroups
(
$input
,
"
\$
"
,
""
,
""
,
"
\$
"
);
},
'=<>'
=>
new
Reg
(
"/^[=<>]/"
),
'#'
=>
new
Reg
(
"/^[#
\x
{2261}]/u"
),
'+'
=>
new
Reg
(
"/^
\+
/"
),
// -space -, -; -] -/ -$ -state-of-aggregation orig: "/^-(?=[\s_},;\]/]|$|\([a-z]+\))/"
'-$'
=>
new
Reg
(
"/^-(?=[
\s
_},;
\]\/
]|$|
\(
[a-z]+
\)
)/u"
),
'-9'
=>
new
Reg
(
"/^-(?=[0-9])/"
),
'- orbital overlap'
=>
new
Reg
(
"/^-(?=(?:[spd]|sp)(?:$|[
\s
,;
\)\]\}
]))/"
),
'-'
=>
new
Reg
(
"/^-/"
),
'pm-operator'
=>
new
Reg
(
"/^(?:
\\\\
pm|
\\\$\\\\
pm
\\\$
|
\+
-|
\+\/
-)/"
),
'operator'
=>
new
Reg
(
"/^(?:
\+
|(?:[
\-
=<>]|<<|>>|
\\\\
approx|
\\\$\\\\
approx
\\\$
)(?=
\s
|$|-?[0-9]))/"
),
'arrowUpDown'
=>
new
Reg
(
"/^(?:v|
\(
v
\)
|
\^
|
\(\^\)
)(?=$|[
\s
,;
\)\]\}
])/"
),
'
\\
bond{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
bond{"
,
""
,
""
,
"}"
);
},
'->'
=>
new
Reg
(
'/^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[
\x
{2192}
\x
{27F6}
\x
{21CC}])/u'
),
'CMT'
=>
new
Reg
(
"/^[CMT](?=
\[
)/"
),
'[(...)]'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"["
,
""
,
""
,
"]"
);
},
'1st-level escape'
=>
new
Reg
(
"/^(&|
\\\\\\\\
|
\\\\
hline)
\s
*/"
),
// \\x - but output no space before
'
\\
,'
=>
new
Reg
(
"/^(?:
\\\\
[,
\
;:])/"
),
'
\\
x{}{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
""
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
,
""
,
"{"
,
"}"
,
""
,
true
);
},
'
\\
x{}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
""
,
new
Reg
(
"/^
\\\\
[a-zA-Z]+
\{
/"
),
"}"
,
""
);
},
'
\\
ca'
=>
new
Reg
(
"/^
\\\\
ca(?:
\s
+|(?![a-zA-Z]))/"
),
'
\\
x'
=>
new
Reg
(
"/^(?:
\\\\
[a-zA-Z]+
\s
*|
\\\\
[_&{}%])/"
),
// only those with numbers in front, because the others will be formatted correctly anyway
'orbital'
=>
new
Reg
(
"/^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/"
),
'others'
=>
new
Reg
(
"/^[
\/
~|]/"
),
'
\\
frac{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
frac{"
,
""
,
""
,
"}"
,
"{"
,
""
,
""
,
"}"
);
},
'
\\
overset{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
overset{"
,
""
,
""
,
"}"
,
"{"
,
""
,
""
,
"}"
);
},
'
\\
underset{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
underset{"
,
""
,
""
,
"}"
,
"{"
,
""
,
""
,
"}"
);
},
'
\\
underbrace{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
underbrace{"
,
""
,
""
,
"}_"
,
"{"
,
""
,
""
,
"}"
);
},
'
\\
color{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
color{"
,
""
,
""
,
"}"
);
},
'
\\
color{(...)}{(...)}'
=>
function
(
$input
)
{
// ?? instead of ||
return
$this
->
findObserveGroups
(
$input
,
"
\\
color{"
,
""
,
""
,
"}"
,
"{"
,
""
,
""
,
"}"
)
??
$this
->
findObserveGroups
(
$input
,
"
\\
color"
,
"
\\
"
,
""
,
new
Reg
(
"/^(?=
\{
)/"
),
"{"
,
""
,
""
,
"}"
);
},
'
\\
ce{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
ce{"
,
""
,
""
,
"}"
);
},
'
\\
pu{(...)}'
=>
function
(
$input
)
{
return
$this
->
findObserveGroups
(
$input
,
"
\\
pu{"
,
""
,
""
,
"}"
);
},
'oxidation$'
=>
new
Reg
(
"/^(?:[+-][IVX]+|(?:
\\\\
pm|
\\\$\\\\
pm
\\\$
|
\+
-|
\+\/
-)
\s
*0)$/"
),
'd-oxidation$'
=>
new
Reg
(
"/^(?:[+-]?[IVX]+|(?:
\\\\
pm|
\\\$\\\\
pm
\\\$
|
\+
-|
\+\/
-)
\s
*0)$/"
),
'1/2$'
=>
new
Reg
(
"/^[+
\-
]?(?:[0-9]+|
\\\$
[a-z]
\\\$
|[a-z])
\/
[0-9]+(?:
\\\$
[a-z]
\\\$
|[a-z])?$/"
),
'amount'
=>
function
(
$input
)
{
$matches
=
[];
// e.g. 2, 0.5, 1/2, -2, n/2, +; $a$ could be added later in parsing
$match
=
preg_match
(
"/^(?:(?:(?:
\(
[+
\-
]?[0-9]+
\/
[0-9]+
\)
|[+
\-
]?(?:[0-9]+|
\\\$
[a-z]
\\\$
"
.
"|[a-z])
\/
[0-9]+|[+
\-
]?[0-9]+[.,][0-9]+|[+
\-
]?
\.
[0-9]+|[+
\-
]?[0-9]+)(?:[a-z](?=
\s
*[A-Z]))?)"
.
"|[+
\-
]?[a-z](?=
\s
*[A-Z])|
\+
(?!
\s
))/"
,
$input
,
$matches
);
if
(
$match
)
{
return
[
"match_"
=>
$matches
[
0
],
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
$a
=
$this
->
findObserveGroups
(
$input
,
""
,
"$"
,
"$"
,
""
);
// e.g. $2n-1$, $-$
if
(
MhchemUtil
::
issetJS
(
$a
)
)
{
$matchesI
=
[];
$match
=
preg_match
(
"/^
\\\$
(?:
\(
?[+
\-
]?(?:[0-9]*[a-z]?[+
\-
])"
.
"?[0-9]*[a-z](?:[+
\-
][0-9]*[a-z]?)?
\)
?|
\+
|-)
\\\$
$/"
,
$a
[
"match_"
]
??
""
,
$matchesI
);
if
(
$match
)
{
return
[
"match_"
=>
$matchesI
[
0
],
"remainder"
=>
substr
(
$input
,
strlen
(
$matchesI
[
0
]
)
)
];
}
}
return
null
;
},
'amount2'
=>
function
(
$input
)
{
/* @phan-suppress-next-line PhanInfiniteRecursion, PhanUndeclaredInvokeInCallable */
return
$this
->
patterns
[
'amount'
](
$input
);
},
'(KV letters),'
=>
new
Reg
(
"/^(?:[A-Z][a-z]{0,2}|i)(?=,)/"
),
'formula$'
=>
static
function
(
$input
)
{
if
(
preg_match
(
"/^
\(
[a-z]+
\)
$/"
,
$input
)
)
{
// state of aggregation = no formula
return
null
;
}
$matches
=
[];
$match
=
preg_match
(
"/^(?:[a-z]|(?:[0-9
\ \+\-\,\.\(\)
]+[a-z])+[0-9
\ \+\-\,\.\(\)
]*|"
.
"(?:[a-z][0-9
\ \+\-\,\.\(\)
]+)+[a-z]?)$/"
,
$input
,
$matches
);
if
(
$match
)
{
return
[
"match_"
=>
$matches
[
0
],
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
return
null
;
},
'uprightEntities'
=>
new
Reg
(
"/^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/"
),
'/'
=>
new
Reg
(
"/^
\s
*(
\/
)
\s
*/"
),
'//'
=>
new
Reg
(
"/^
\s
*(
\/\/
)
\s
*/"
),
'*'
=>
new
Reg
(
"/^
\s
*[*.]
\s
*/"
)
];
}
/**
* Matching function
* e.g. match("a", input) will look for the regexp called "a" and see if it matches
* returns null or {match_:"a", remainder:"bc"}
* @param string $m key for fetching a pattern
* @param string $input string to check
* @return array|mixed|null information about the match
*/
public
function
match
(
string
$m
,
string
$input
)
{
$pattern
=
$this
->
patterns
[
$m
]
??
null
;
if
(
!
$pattern
)
{
// Trying to use non-existing pattern
throw
new
RuntimeException
(
"MhchemBugP: mhchem bug P. Please report. ("
.
$m
.
")"
);
}
elseif
(
$pattern
instanceof
Reg
)
{
$matches
=
[];
$match
=
preg_match
(
$pattern
->
getRegExp
(),
$input
,
$matches
);
if
(
$match
)
{
if
(
count
(
$matches
)
>
2
)
{
return
[
"match_"
=>
array_slice
(
$matches
,
1
),
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
else
{
return
[
"match_"
=>
MhchemUtil
::
issetJS
(
$matches
[
1
]
??
null
)
?
$matches
[
1
]
:
$matches
[
0
],
"remainder"
=>
substr
(
$input
,
strlen
(
$matches
[
0
]
)
)
];
}
}
return
null
;
}
elseif
(
is_callable
(
$pattern
)
)
{
// $pattern cannot be an instance of MhchemRegExp here, which causes this warning.
/* @phan-suppress-next-line PhanUndeclaredInvokeInCallable */
return
$this
->
patterns
[
$m
](
$input
);
}
else
{
return
null
;
}
}
}
File Metadata
Details
Attached
Mime Type
text/x-php
Expires
Sat, Nov 21, 18:46 (23 h, 5 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
7c/b8/8ef46abfe784b49830cf341ff91a
Default Alt Text
MhchemPatterns.php (15 KB)
Attached To
Mode
rMWPROD MediaWiki Production
Attached
Detach File
Event Timeline
Log In to Comment