As reported by Colt, there was a crash in the in-mission jump sequence in Shepherds where the mission previously worked. The proximate cause was a handwritten SEXP called via script that omitted whitespace before an opening parenthesis. This was incorrectly recognized by the upgraded SEXP parser as an invalid SEXP. Unfortunately, a separate bug in `get_line_num()` caused a crash when the parser tried to display a warning, because the function tried to calculate the line number of a SEXP that did not come from a parsed file.
This commit fixes the parser to recognize opening parentheses even when no whitespace precedes them, moves the output to the 'unexpected end of sexp' warnings will they will now be seen, and fixes `get_line_num()` to work when there is no parsed text.
Follow-up to #5520.
Supercaps use a physics flag on warpin that makes them slow down faster than they would under the normal physics code. This adds that flag as an option for custom warp parameters.
Since flags are not yet parsed when warp parameters are parsed, the code needs to skip ahead and peek at the flags in the same way as the weapon override.
In at least two instances, `split_str_once()` can be called with width values derived from mod-supplied values that can be 0 or less (specifically, two hud gauges: if `+Messages:` has a `Max Width:` that's too small, or `+Directives:` has a `Max Line Width:` of 0 or less). Since user-supplied code shouldn't be tripping assertions, I looked into adding security around the calling sites when I realized that the assertion wasn't actually protecting against anything; the function would run just fine with a negative pixel width, it would just break with every whitespace. Since both calling sites that could trip the assertion already treat getting `src` back as output as an "I can't split this" error condition, it's perfectly fine (and skips iterating through the string) to just `return src` if the maximum pixel width is 0 or less, so let's just do that instead. Technically this is a behavior change in Release code, but the result of the old code would've been to spam the message log with every individual word in every message (if `Max Width:` was too small), and for directives to seemingly-randomly split only after the first word (if `Max Line Width:` was 0 or less). Not splitting at all is at least as correct, saves some pointless processing, and *should* still be obviously wrong if there was supposed to be a reasonable width value.
In retail, number parsing picked up immediately at the character after the number parsed, so parsing `0.50` as an int would yield 0, and then the next available characters would be `.50`. Even though parsing has been tightened up and made stricter, we can still "fail gracefully" by simulating the old behavior. And when failing gracefully, the message can be a warning.
When parsing a list of numbers, such as in the $uvec or $fvec of models, a bug was reported where whitespace before the comma caused the number parsing to fail. This change checks for a comma after whitespace instead of checking for a comma as the very next character.
Two enhancements:
1) Allow the SEXP help description to take up multiple lines. Since the parser did not originally use `stuff_string` with `F_MULTITEXT`, this required some creative parsing.
2) Generate the text for minimum and maximum number of arguments.
`gr_get_string_size` takes a length parameter, but `split_str_once` was calling it with the position instead. This led to incorrect results occasionally. If the incorrect pixel width had the bad luck to be exactly equal to the remaining space, this would cause an infinite loop. This fixes the bug and adds a bunch of safeguards to prevent a similar situation in the future.
* Add custom data to ship tables
* add index check to shipclass.cpp
* fix hasCustomData name to use the proper casing
* Add custom data to weapon tables
* Add validity checks and remove superfluous empty check
* Attempt to appease clang-tidy
* Use F_RAW as recommended by @BMagnu
* Creates a function to parse maps and uses it in ship.cpp and weapons.cpp
* another attempt to appease clang-tidy
* Remove superfluous using
* Small style and grammar fixes
* Accidentally forgot this change. Rename 'delimiter' to 'end_marker'
The old XSTR parsing code was a bit of a mess and did not even properly enforce its format. These new routines enforce the actual XSTR format and warn when it is malformed, which is helpful for catching table errors as early as possible. This fixes#3627 and also catches mismatched quotes and other common XSTR errors. No more wondering why comments are being mysteriously parsed instead of ignored!
When an empty string is encountered in the weapon list, it's valid, but the -1 should actually be stored, not skipped.
This bug was preventing ship weapons from being explicitly set to None.
* wip
* basics are working
* turret case is handled
* better fighter beam handling
* missing commit?
* handle missile spawn
* clean up, commenting and ssb handling
* random in sphere and per burst rot counts for "share random" flag
* clean up, clarity and comments
* accidental whitespace changes
* bugfix
* NULL -> nullptr
* more efficiency/clarity
* review tweaks and bugfixes
Here's a bug that's been around ever since version 3.6. If the subsystem names were not essentially the same, the function wouldn't do the expected string comparison.
Commit 6c2ebab01c (#3439) added a `max_line_length` argument to `split_str()`, but one call had the extra argument added in the wrong spot, and so a previously-pointless-but-harmless `ignored_char` of 0 became a `max_line_length` of 0, resulting (ultimately) in an exception in the unicode code when the iterator tried to decrement at the beginning of a ship's description. This gets rid of the argument entirely, rather than reordering them, because ignoring null characters doesn't really do anything anyway.
I've also added `Assertion`s to check `max_line_length` that should prevent this specific problem from occurring again in the future.
* Added a byte limit for line length in split function
* Fix call error
* Ádd missing limits import
* Change hardcoded values into defines
* Cleanup default argument
#3271 changed the logic of `stuff_token_list()` in such a way that the supplied index being used to access an array was no longer skipped if it was invalid; naturally, this means that this warning was now being inevitably followed up by an out-of-bounds array access. Adding a `!skip_this_entry` check should hopefully fix the problem while still allowing the loadout count parsing code below it to run, which was presumably the reason the `continue` statement was replaced with the `skip_this_entry` variable in the first place. Fixes#3405.
This moves the ## to # escape sequence logic from `mission_process_alt_types` to its own function where it can be used elsewhere (such as for ship class and weapon class display names that need to do the same thing). Also, this introduces a !! escape sequence for exclamation points that is needed for exclamation points to be used in scripts, as @naomimyselfandi pointed out.
Goober5000