summaryrefslogtreecommitdiff
path: root/regexp.h
Commit message (Collapse)AuthorAgeFilesLines
* Base *.[ch] files: Replace leading tabs with blanksMichael G Schwern2021-05-311-141/+141
| | | | | | | This is a rebasing by @khw of part of GH #18792, which I needed to get in now to proceed with other commits. It also strips trailing white space from the affected files.
* regexp.h: Clarify how a computed value is derived.Karl Williamson2021-01-031-5/+6
|
* Document regexp, regmatch_infoKarl Williamson2020-12-301-6/+12
|
* regexec.c: Revamp S_setup_EXACTISH_ST() loop end conditionsKarl Williamson2020-12-191-6/+28
| | | | | | | | | | | Consider the pattern /A*B/ where A and B are arbitrary. The pattern matching code tries to make a tight loop to match the span of A's. The logic of this was not really updated when UTF-8 was added. I did revamp it some releases ago to fix some bugs and to at least consider UTF-8. This commit changes it so that Unicode is now a first class citizen. Some details are listed in the ticket GH #18414
* autodoc.pl: Specify scn for single-purpose filesKarl Williamson2020-11-061-2/+0
| | | | | | | | Many of the files in perl are for one thing only, and hence their embedded documentation will be for that one thing. By creating a hash here of them, those files don't have to worry about what section that documentation goes under, and so it can be completely changed without affecting them.
* regexp.h: White-space onlyKarl Williamson2020-10-161-167/+167
| | | | Indent preprocessor lines for clarity of program structure
* Use macro instead of its expansionKarl Williamson2020-09-091-1/+1
| | | | | We already have a macro that expands to what this code does; it's clearer to use it.
* Change some =head1 to apidoc_section linesKarl Williamson2020-09-041-1/+1
| | | | | apidoc_section is slightly favored over head1, as it is known only to autodoc, and can't be confused with real pod.
* Fix a bunch of repeated-word typosDagfinn Ilmari Mannsåker2020-05-221-1/+1
| | | | | Mostly in comments and docs, but some in diagnostic messages and one case of 'or die die'.
* regexp.h: no subbeg move when reordering regexp structRichard Leach2020-03-111-1/+1
|
* regexp.h -reorder regexp to close x86-64 alignment holesRichard Leach2020-03-111-12/+13
|
* regexp.h: remove redundant commentHugo van der Sanden2020-03-111-3/+0
| | | | | 14 years of churn have so far removed this comment from its original referents that it has no current relevance.
* inline.h: Change fcn name prefix from S_ to Perl_Karl Williamson2019-09-151-1/+1
| | | | | | | | | | | | | | | | This is being done only for those functions that don't have a guard preventing them from being seen outside of the Perl core. Talking to Tony Cook, we agreed that this was a good idea for two reasons: 1) The 'Perl_' prefix does not pollute XS caller's name space. The 'S_' one could be argued that it doesn't much either, but it does more so than 'Perl_', and the next reason is the clincher: 2) It allows us to change our minds about whether a function should be static inline or not, without affecting callers who use the Perl_ form, which they would be accustomed to anyway if they're using the full name form.
* avoid use-after free in /(?{...})/David Mitchell2019-08-061-0/+1
| | | | | | | | | | | | | | | | | | | RT #134208 In something like eval { sub { " " }->() =~ /(?{ die })/ } When the match string gets aliased to $_, the SAVE_DEFSV is done after the SAVEDESTRUCTOR_X(S_cleanup_regmatch_info_aux). So if croaking, the SV gets SvREFCNT_dec()ed by the SAVE_DEFSV, then S_cleanup_regmatch_info_aux() manipulates the SV's magic. This doesn't cause a problem unless the match string is temporary, in which case the only other reference keeping it alive will be removed by the FREETMPs during the croak. The fix is to make sure an extra ref to the sv is held.
* PATCH: [perl #133997] Assert fail with script runsKarl Williamson2019-04-131-0/+1
| | | | | | | | | | | | | The cause of this is the emulation of recursion in executing regex patterns and that the script run feature did not cooperate with it. The result is that the input pointers got pushed (but not the script run) and popped, so that the script run was pointing to something that had been tried, failed and otherwise popped. The solution I've adopted is to always push the current script run start position whenever a push is done; and pop it whenever a pop is done. If someone has suggestions about this code, please step forward.
* Implement variable length lookbehind in regex patternsKarl Williamson2019-03-181-0/+3
| | | | See [perl #132367].
* regexec.c: regmatch(): Add pushing eolKarl Williamson2019-03-181-0/+1
| | | | | | This continues the process of changing regmatch() to be able to restrict the end point of where it is looking in the input, by adding that eol position to the pushed state, and popping it when appropriate.
* regcomp.c: Use regnode offsets during parsingKarl Williamson2018-10-201-0/+2
| | | | | | | | | | | | | | | | | | | This changes the pattern parsing to use offsets from the first node in the pattern program, rather than direct addresses of such nodes. This is in preparation for a later change in which more mallocs will be done which will change those addresses, whereas the offsets will remain constant. Once the final program space is allocated, real addresses are used as currently. This limits the necessary changes to a few functions. Also, real addresses are used if they are constant across a function; again this limits the changes. Doing this introduces a new typedef for clarity 'regnode_offset' which is not a pointer, but a count. This necessitates changing a bunch of things to use 0 instead of NULL to indicate an error. A new boolean is also required to indicate if we are in the first or second passes of the pattern. And separate heap space is allocated for scratch during the first pass.
* Improve docs for lastparen, lastcloseparenDavid Mitchell2018-08-261-2/+2
| | | | | There's lots of confusion here, especially about lastparen - some of the docs are just plain wrong.
* fixup for NO_TAINT_SUPPORTYves Orton2018-04-241-0/+1
|
* eliminate _REGEXP_COMMON macro from regexp.hDavid Mitchell2018-03-061-48/+58
| | | | | | | | It is used in only one place now, so its better to expand it out rather than having a complex struct's fields defined using a huge macro. No functional changes, but I did take the opportunity to tidy up the formatting of the code comments for each struct field
* fix RX_MATCH_UTF8_on() macroDavid Mitchell2017-08-041-1/+1
| | | | | | v5.27.2-34-g196a02a reorganised the RX_FOO() macros, mostly redefining them in terms of the RXp_FOO() macros. A cut-an-paste error screwed up the definition of RX_MATCH_UTF8_on(), which is isn't used in core.
* fix RX_MATCH_COPY_FREE() on win32David Mitchell2017-07-271-1/+1
| | | | | | | My recent commit made RX_MATCH_COPY_FREE() a wrapper for RXp_MATCH_COPY_FREE() but it didn't build on VC 2003. Spotted by bulk88.
* add, and use, some RXp_FOO() variants of RX_FOO()David Mitchell2017-07-271-27/+44
| | | | | | | | | | | | | | | | | | | | For various RX_FOO() macros, add a RXp_FOO() variant, in such a way that the original macro is now defined in terms of #define RX_FOO(rx_sv) (RXp_FOO(ReANY(rx_sv))) (This is a pre-existing convention; this commit just makes a larger subset of the RX_() macros have an RXp_() variant). Then use those macros in various pp_hot.c and regexec.c functions like pp_match() and regexec_flags(), which already, or added via this commit, have this line near the start: regexp *prog = ReANY(rx); This avoids having to do multiple ReANY()'s, which is important as this macro now includes a conditional in its expression (to cope with PVLV-as-REGEX)..
* rename RX_HAS_CUTGROUP() to RXp_HAS_CUTGROUP()David Mitchell2017-07-271-1/+1
| | | | | | | | | It takes a private/internal regexp* pointer rather than a public REGEXP pointer, so rename it to match the other RXp_ macros. Most RXp_ macros are a variant of an RX_ macro; however, I didn't add an RX_HAS_CUTGROUP() macro - someone can always add that if needed. (There's only one use of RXp_HAS_CUTGROUP in core).
* reformat RX_() macrosDavid Mitchell2017-07-271-62/+66
| | | | | | | | | The previous commit caused the formatting of these macros to become messy. Realign them, replacing tabs with spaces, and split some long macros over multiple lines. Whitespace-only change (if you count splitting a macro with \ as whitespace).
* RX_FOO(prog) becomes RX_FOO(rx_sv)David Mitchell2017-07-271-53/+53
| | | | | | | | | | | | | | | | | There are a family of RX_() macros which take an SV of type REGEXP as an argument. For historical reasons (regexeps didn't use to be SVs), the name of the parameter is 'prog', which is also by convention used to name the actual regexp struct in some places. So e.g. at the top of re_intuit_start(), you see struct regexp *const prog = ReANY(rx); This is confusing. So for this class of macro, rename the parameter from 'prog' to 'rx_sv'. This makes it clearer that the arg should be a REGEXP* rather than an regexp*. Note that there are some RXp_() macros which do take a regexp* as an arg; I've left their parameter name as 'prog'.
* give REGEXP SVs the POK flag againDavid Mitchell2017-07-271-2/+3
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Commit v5.17.5-99-g8d919b0 stopped SVt_REGEXP SVs (and PVLVs acting as regexes) from having the POK and pPOK flags set. This made things like SvOK() and SvTRUE() slower, because as well as the quick single test for any I/N/P/R flags, SvOK() also has to test for (SvTYPE(sv) == SVt_REGEXP || (SvFLAGS(sv) & (SVTYPEMASK|SVp_POK|SVpgv_GP|SVf_FAKE)) == (SVt_PVLV|SVf_FAKE)) This commit fixes the issue fixed by g8d919b0 in a slightly different way, which is less invasive and allows the POK flag. Background: PVLV are basically PVMGs with a few extra fields. They are intended to be a superset of all scalar types, so any scalar value can be assigned to a PVLV SV. However, once REGEXPs were made into first-class scalar SVs, this assumption broke - there are a whole bunch of fields in a regex SV body which can't be copied to to a PVLV. So this broke: sub f { my $r = qr/abc/; # $r is reference to an SVt_REGEXP $_[0] = $$r; } f($h{foo}); # the hash access is deferred - a temporary PVLV is # passed instead The basic idea behind the g8d919b0 fix was, for an LV-acting-as-regex, to attach both a PVLV body and a regex body to the SV head. This commit keeps this basic concept; it just changes how the extra body is attached. The original fix changed SVt_REGEXP SVs so that sv.sv_u.svu_pv no longer pointed to the regexp's string representation; instead this pointer was stored in a union made out of the xpv_len field. Doing this necessitated not turning the POK flag on for any REGEXP SVs. This freed up the sv_u to point to the regex body, while the sv_any field could continue to point to the PVLV body. An ReANY() macro was introduced that returned the sv_u field rather than the sv_any field. This commit changes it so that instead, on regexp SVs (and LV-as-regexp SVs), sv_u always points to the string buffer (so they can have POK set again), but on specifically LV-as-regex SVs, the xpv_len_u union of the PVLV body points to the regexp body. This means that SVt_REGEXP SVs are now completely "normal" again, and SVt_PVLV SVs are normal except in the one case where they hold a regex, in which case rather than storing the string buffer's length, the PVLV body stores a pointer to the regex body.
* avoid double-freeing regex code blocksDavid Mitchell2017-02-011-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | RT #130650 heap-use-after-free in S_free_codeblocks When compiling qr/(?{...})/, a reg_code_blocks structure is allocated and various SVs are attached to it. Initially this is set to be freed via a destructor on the savestack, in case of early dying. Later the structure is attached to the compiling regex, and a boolean flag in the structure, 'attached', is set to true to show that the destructor no longer needs to free the struct. However, it is possible to get three orders of destruction: 1) allocate, push destructor, die early 2) allocate, push destructor, attach to regex, die 2) allocate, push destructor, attach to regex, succeed In 2, the regex is freed (via the savestack) before the destructor is called. In 3, the destructor is called, then later the regex is freed. It turns out perl can't currently handle case 2: qr'(?{})\6' Fix this by turning the 'attached' boolean field into an integer refcount, then keep a count of whether the struct is referenced from the savestack and/or the regex. Since it normally has a value of 1 or 2, it's similar to a boolean flag, but crucially it no longer just indicates that the regex has a pointer to it ('attached'), but that at least one of the savestack and regex have a pointer to it. So order of freeing no longer matters. I also updated S_free_codeblocks() so that it nulls out SV pointers in the reg_code_blocks struct before freeing them. This is is generally good practice to avoid double frees, although is probably not needed at the moment.
* Use cBOOL() instead of ? TRUE : FALSEDagfinn Ilmari Mannsåker2017-01-251-1/+1
| | | | Except under cpan/ and dist/
* better handle freeing of code blocks in /(?{...})/David Mitchell2017-01-241-0/+8
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | [perl #129140] attempting double-free Thus fixes some leaks and double frees in regexes which contain code blocks. During compilation, an array of struct reg_code_block's is malloced. Initially this is just attached to the RExC_state_t struct local var in Perl_re_op_compile(). Later it may be attached to a pattern. The difficulty is ensuring that the array is free()d (and the ref counts contained within decremented) should compilation croak early, while avoiding double frees once the array has been attached to a regex. The current mechanism of making the array the PVX of an SV is a bit flaky, as the array can be realloced(), and code can be re-entered when utf8 is detected mid-compilation. This commit changes the array into separately malloced head and body. The body contains the actual array, and can be realloced. The head contains a pointer to the array, plus size and an 'attached' boolean. This indicates whether the struct has been attached to a regex, and is effectively a 1-bit ref count. Whenever a head is allocated, SAVEDESTRUCTOR_X() is used to call S_free_codeblocks() to free the head and body on scope exit. This function skips the freeing if 'attached' is true, and this flag is set only at the point where the head gets attached to the regex. In one way this complicates the code, since the num_code_blocks field is now not always available (it's only there is a head has been allocated), but mainly its simplifies, since all the book-keeping is now done in the two new static functions S_alloc_code_blocks() and S_free_codeblocks()
* Add /xx regex pattern modifierKarl Williamson2017-01-131-3/+11
| | | | | This was first proposed in the thread starting at http://www.nntp.perl.org/group/perl.perl5.porters/2014/09/msg219394.html
* make OP_SPLIT a PMOP, and eliminate OP_PUSHREDavid Mitchell2016-10-041-3/+2
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Most ops that execute a regex, such as match and subst, are of type PMOP. A PMOP allows the actual regex to be attached directly to that op, due to its extra fields. OP_SPLIT is different; it is just a plain LISTOP, but it always has an OP_PUSHRE as its first child, which *is* a PMOP and which has the regex attached. At runtime, pp_pushre()'s only job is to push itself (i.e. the current PL_op) onto the stack. Later pp_split() pops this to get access to the regex it wants to execute. This is a bit unpleasant, because we're pushing an OP* onto the stack, which is supposed to be an array of SV*'s. As a bit of a hack, on DEBUGGING builds we push a PVLV with the PL_op address embedded instead, but this still isn't very satisfactory. Now that regexes are first-class SVs, we could push a REGEXP onto the stack rather than PL_op. However, there is an optimisation of @array = split which eliminates the assign and embeds the array's GV/padix directly in the PUSHRE op. So split still needs access to that op. But the pushre op will always be splitop->op_first anyway, so one possibility is to just skip executing the pushre altogether, and make pp_split just directly access op_first instead to get the regex and @array info. But if we're doing that, then why not just go the full hog and make OP_SPLIT into a PMOP, and eliminate the OP_PUSHRE op entirely: with the data that was spread across the two ops now combined into just the one split op. That is exactly what this commit does. For a simple compile-time pattern like split(/foo/, $s, 1), the optree looks like: before: <@> split[t2] lK </> pushre(/"foo"/) s/RTIME <0> padsv[$s:1,2] s <$> const(IV 1) s after: </> split(/"foo"/)[t2] lK/RTIME <0> padsv[$s:1,2] s <$> const[IV 1] s while for a run-time expression like split(/$pat/, $s, 1), before: <@> split[t3] lK </> pushre() sK/RTIME <|> regcomp(other->8) sK <0> padsv[$pat:2,3] s <0> padsv[$s:1,3] s <$> const(IV 1)s after: </> split()[t3] lK/RTIME <|> regcomp(other->8) sK <0> padsv[$pat:2,3] s <0> padsv[$s:1,3] s <$> const[IV 1] s This makes the code faster and simpler. At the same time, two new private flags have been added for OP_SPLIT - OPpSPLIT_ASSIGN and OPpSPLIT_LEX - which make it explicit that the assign op has been optimised away, and if so, whether the array is lexical. Also, deparsing of split has been improved, to the extent that perl TEST -deparse op/split.t now passes. Also, a couple of panic messages in pp_split() have been replaced with asserts().
* Make deprecated qr//xx fatalKarl Williamson2016-05-091-7/+0
| | | | This has been deprecated since v5.22
* fix "bad match" issue reported in perl #127705Yves Orton2016-03-151-12/+1
| | | | | | | | | | | | In 24be310237a0f8f19cfdb71de1b068b4ce9572a0 I reworked how we stored the close_paren info in the regexp match state structure. Unfortunately I missed a subtle aspect of the logic which meant that in certain cases we were relying on close_paren being true to avoid comparing it against a false ARG value for things like CURLYX, which meant that sometimes we would exit an stack frame prematurely. This patch fixes that logic and makes it more clear (via macros) what is going on.
* add consistency with other union membersYves Orton2016-03-151-1/+1
| | | | | | | | In most cases the curlyx member is the first thing after the yes state member, but eval was reversed. While debugging perl #127705 I switched them to see what would happen, which changed the bug, and ultimately revealed the cause of the problem. So I am going to leave them in the "consistent" order.
* fix Perl #126182, out of memory due to infinite pattern recursionYves Orton2016-03-061-1/+8
| | | | | | | | | | | | | | | | | | | The way we tracked if pattern recursion was infinite did not work properly. A pattern like "a"=~/(.(?2))((?<=(?=(?1)).))/ would loop forever, slowly eat up all available ram as it added pattern recursion stack frames. This patch changes the rules for recursion so that recursively entering a given pattern "subroutine" twice from the same position fails the match. This means that where previously we might have seen fatal exception we will now simply fail. This means that "aaabbb"=~/a(?R)?b/ succeeds with $& equal to "aaabbb".
* Unify GOSTART and GOSUBYves Orton2016-03-061-4/+10
| | | | | | | | | | | | | | | | GOSTART is a special case of GOSUB, we can remove a lot of offset twiddling, and other special casing by unifying them, at pretty much no cost. GOSUB has 2 arguments, ARG() and ARG2L(), which are interpreted as a U32 and an I32 respectively. ARG() holds the "parno" we will recurse into. ARG2L() holds a signed offset to the relevant start node for the recursion. Prior to this patch the argument to GOSUB would always be >=, and unlike other parts of our logic we would not use 0 to represent "start/end" of pattern, as GOSTART would be used for "recurse to beginning of pattern", after this patch we use 0 to represent "start/end", and a lot of complexity "goes away" along with GOSTART regops.
* first step cleaning up regexp recursion "return" logicYves Orton2016-03-061-1/+8
| | | | | | | | | | | | | | | | | | | | | | When we do a GOSUB/GOSTART we need to know where the recursion "returns" to the previous position in the pattern. Currently this is done by comparing cur_eval->u.eval.close_paren to the the argument of CLOSE parens, and within END blocks (for GOSTART). However, there is a problem. The state machinery for GOSUB/GOSTART is shared with EVAL ( implementing /(??{ ... })/ ), which also sets cur_eval->u.eval.close_paren to 0. This for instance breaks /(?(R)YES|NO)/ by making it return true within a /(??{ ... })/ when arguably it shouldn't. It also is confusing. So we change the meaning of close_paren so that 0 means "from EVAL", and that otherwise the value is "+1", so 1 means GOSTART (trigger for END), and 2 means "CLOSE1", etc. In order to make this transparent this patch adds the EVAL_CLOSE_PAREN_IS( cur_eval, EXPR ) macro which does the right thing: ( cur_eval && cur_eval->u.eval.close_paren && ( ( cur_eval->u.eval.close_paren - 1 ) == EXPR ) )
* Various pods: Add C<> around many typed-as-is thingsKarl Williamson2015-09-031-1/+1
| | | | Removes 'the' in front of parameter names in some instances.
* remove redundant PERL_EXPORT_C and PERL_XS_EXPORT_C macrosDaniel Dragan2015-06-031-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | These 2 macros were created for the Symbian port in commit "Symbian port of Perl" to replace a direct "extern" token. I guess the author was unaware of PERL_CALLCONV. PERL_CALLCONV is the official macro to use. PERL_XS_EXPORT_C and PERL_EXPORT_C have no usage on cpan grep except for modules with direct copies of core headers. A defect of using PERL_EXPORT_C and PERL_XS_EXPORT_C instead of PERL_CALLCONV is that win32/win32.h has no knowledge of the 2 macros and doesn't set them, and os/os2ish.h doesn't either. On Win32, since the unix defaults are used instead of Win32 specific "__declspec(dllimport)" token, XS modules use indirect function stubs in each XS module placed by the CC to call into perl5**.dll instead of directly calls the core C functions. I observed this in in XS-Typemap's DLL. To simplify the API, and to decrease the amount of macros needing to implemented to support each platform, just remove the 2 macros. Since perl.h's fallback defaults for PERL_CALLCONV are very late in perl.h, they need to be moved up before function declarations start in perlio.h (perlio.h is included from iperlsys.h). win32iop.h contains the "PerlIO" and SV" tokens, so perlio.h must be included before win32iop.h is. Including perlio.h so early in win32.h, causes PERL_CALLCONV not be defined since Win32 platform uses the fallback in perl.h, since win32.h doesn't always define PERL_CALLCONV and sometimes relies on the fallback. Since win32iop.h contains alot of declarations, it belongs with other declarations such as those in proto.h so move it from win32.h to perl.h. the "free" token in struct regexp_engine conflicts with win32iop's "#define free win32_free" so rename that member.
* Replace common Emacs file-local variables with dir-localsDagfinn Ilmari Mannsåker2015-03-221-6/+0
| | | | | | | | | | | | | | | | An empty cpan/.dir-locals.el stops Emacs using the core defaults for code imported from CPAN. Committer's work: To keep t/porting/cmp_version.t and t/porting/utils.t happy, $VERSION needed to be incremented in many files, including throughout dist/PathTools. perldelta entry for module updates. Add two Emacs control files to MANIFEST; re-sort MANIFEST. For: RT #124119.
* Reserve a bit for 'the re strict subpragma.Karl Williamson2015-01-131-1/+1
| | | | This is another step in the process
* Support for nocapture regexp flag /nMatthew Horsfall (alh)2014-12-281-5/+8
| | | | | | | | | | | | | | | | | | | | This flag will prevent () from capturing and filling in $1, $2, etc... Named captures will still work though, and if used will cause $1, $2, etc... to be filled in *only* within named groups. The motivation behind this is to allow the common construct of: /(?:b|c)a(?:t|n)/ To be rewritten more cleanly as: /(b|c)a(t|n)/n When you want grouping but no memory penalty on captures. You can also use ?n inside of a () directly to avoid capturing, and ?-n inside of a () to negate its effects if you want to capture.
* Create bit for /n.Karl Williamson2014-12-281-1/+1
|
* [perl #122911] regexp.h: Rmv VOL from op_comp sigFather Chrysostomos2014-10-061-1/+1
| | | | It is no longer needed as of 1067df30ae9.
* Suppress some Solaris warningsKarl Williamson2014-09-291-15/+16
| | | | | | | | We get an integer overflow message when we left shift a 1 into the highest bit of a word. This changes the 1's into 1U's to indicate unsigned. This is done for all the flag bits in the affected word, as they could get reorderd by someone in the future, unintentionally reintroducing this problem again.
* Deprecate multiple "x" in "/xx"Karl Williamson2014-09-291-5/+12
| | | | | | | | | | It is planned for a future Perl release to have /xx mean something different from just /x. To prepare for this, this commit raises a deprecation warning if someone currently has this usage. A grep of CPAN did not turn up any instances of this, but this is to be safe anyway. The added code is more general than actually needed, in case we want to do this for another flag.
* Make space for /xx flagKarl Williamson2014-09-291-2/+2
| | | | | | This doesn't actually use the flag yet. We no longer have to make version-dependent changes to ext/Devel-Peek/t/Peek.t, (it being in /ext) so this doesn't
* regexp.h: Comment shared-pool free bits schemeKarl Williamson2014-09-291-3/+39
|
View Lorry Controller Status