andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Easier to find 'static inline'

pull/1/head
Scott Lahteine 6 years ago
parent
cc0a60453f
commit
a4b0148365
6 changed files with 31 additions and 32 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      Marlin/src/feature/bedlevel/ubl/ubl.h
  2. 30
      Marlin/src/gcode/parser.h
  3. 2
      Marlin/src/libs/buzzer.h
  4. 2
      Marlin/src/module/planner.h
  5. 19
      Marlin/src/module/planner_bezier.cpp
  6. 4
      Marlin/src/module/stepper.h

6
Marlin/src/feature/bedlevel/ubl/ubl.h
View File

@ -215,7 +215,7 @@ class unified_bed_leveling {
* z_correction_for_x_on_horizontal_mesh_line is an optimization for
* the case where the printer is making a vertical line that only crosses horizontal mesh lines.
*/
inline static float z_correction_for_x_on_horizontal_mesh_line(const float &rx0, const int x1_i, const int yi) {
static inline float z_correction_for_x_on_horizontal_mesh_line(const float &rx0, const int x1_i, const int yi) {
if (!WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(yi, 0, GRID_MAX_POINTS_Y - 1)) {
#if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) {
@ -249,7 +249,7 @@ class unified_bed_leveling {
//
// See comments above for z_correction_for_x_on_horizontal_mesh_line
//
inline static float z_correction_for_y_on_vertical_mesh_line(const float &ry0, const int xi, const int y1_i) {
static inline float z_correction_for_y_on_vertical_mesh_line(const float &ry0, const int xi, const int y1_i) {
if (!WITHIN(xi, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(y1_i, 0, GRID_MAX_POINTS_Y - 1)) {
#if ENABLED(DEBUG_LEVELING_FEATURE)
if (DEBUGGING(LEVELING)) {
@ -362,7 +362,7 @@ class unified_bed_leveling {
static void line_to_destination_cartesian(const float &fr, const uint8_t e);
#endif
inline static bool mesh_is_valid() {
static inline bool mesh_is_valid() {
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
if (isnan(z_values[x][y])) return false;

30
Marlin/src/gcode/parser.h
View File

@ -175,10 +175,10 @@ public:
FORCE_INLINE static bool has_value() { return value_ptr != NULL; }
// Seen a parameter with a value
inline static bool seenval(const char c) { return seen(c) && has_value(); }
static inline bool seenval(const char c) { return seen(c) && has_value(); }
// Float removes 'E' to prevent scientific notation interpretation
inline static float value_float() {
static inline float value_float() {
if (value_ptr) {
char *e = value_ptr;
for (;;) {
@ -198,8 +198,8 @@ public:
}
// Code value as a long or ulong
inline static int32_t value_long() { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
inline static uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, NULL, 10) : 0UL; }
static inline int32_t value_long() { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
static inline uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, NULL, 10) : 0UL; }
// Code value for use as time
FORCE_INLINE static millis_t value_millis() { return value_ulong(); }
@ -208,10 +208,10 @@ public:
// Reduce to fewer bits
FORCE_INLINE static int16_t value_int() { return (int16_t)value_long(); }
FORCE_INLINE static uint16_t value_ushort() { return (uint16_t)value_long(); }
inline static uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); }
static inline uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); }
// Bool is true with no value or non-zero
inline static bool value_bool() { return !has_value() || !!value_byte(); }
static inline bool value_bool() { return !has_value() || !!value_byte(); }
// Units modes: Inches, Fahrenheit, Kelvin
@ -220,7 +220,7 @@ public:
// Init linear units by constructor
GCodeParser() { set_input_linear_units(LINEARUNIT_MM); }
inline static void set_input_linear_units(const LinearUnit units) {
static inline void set_input_linear_units(const LinearUnit units) {
switch (units) {
case LINEARUNIT_INCH:
linear_unit_factor = 25.4f;
@ -233,13 +233,13 @@ public:
volumetric_unit_factor = POW(linear_unit_factor, 3);
}
inline static float axis_unit_factor(const AxisEnum axis) {
static inline float axis_unit_factor(const AxisEnum axis) {
return (axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor);
}
inline static float value_linear_units() { return value_float() * linear_unit_factor; }
inline static float value_axis_units(const AxisEnum axis) { return value_float() * axis_unit_factor(axis); }
inline static float value_per_axis_unit(const AxisEnum axis) { return value_float() / axis_unit_factor(axis); }
static inline float value_linear_units() { return value_float() * linear_unit_factor; }
static inline float value_axis_units(const AxisEnum axis) { return value_float() * axis_unit_factor(axis); }
static inline float value_per_axis_unit(const AxisEnum axis) { return value_float() / axis_unit_factor(axis); }
#else
@ -251,7 +251,7 @@ public:
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
inline static void set_input_temp_units(TempUnit units) { input_temp_units = units; }
static inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
#if ENABLED(ULTIPANEL) && DISABLED(DISABLE_M503)
@ -261,7 +261,7 @@ public:
FORCE_INLINE static const char* temp_units_name() {
return input_temp_units == TEMPUNIT_K ? PSTR("Kelvin") : input_temp_units == TEMPUNIT_F ? PSTR("Fahrenheit") : PSTR("Celsius");
}
inline static float to_temp_units(const float &f) {
static inline float to_temp_units(const float &f) {
switch (input_temp_units) {
case TEMPUNIT_F:
return f * 0.5555555556f + 32;
@ -275,7 +275,7 @@ public:
#endif // ULTIPANEL && !DISABLE_M503
inline static float value_celsius() {
static inline float value_celsius() {
const float f = value_float();
switch (input_temp_units) {
case TEMPUNIT_F:
@ -288,7 +288,7 @@ public:
}
}
inline static float value_celsius_diff() {
static inline float value_celsius_diff() {
switch (input_temp_units) {
case TEMPUNIT_F:
return value_float() * 0.5555555556f;

2
Marlin/src/libs/buzzer.h
View File

@ -82,7 +82,7 @@ class Buzzer {
* @brief Resets the state of the class
* @details Brings the class state to a known one.
*/
inline static void reset() {
static inline void reset() {
off();
state.endtime = 0;
}

2
Marlin/src/module/planner.h
View File

@ -361,7 +361,7 @@ class Planner {
* Returns 1.0 if planner.z_fade_height is 0.0.
* Returns 0.0 if Z is past the specified 'Fade Height'.
*/
inline static float fade_scaling_factor_for_z(const float &rz) {
static inline float fade_scaling_factor_for_z(const float &rz) {
static float z_fade_factor = 1;
if (z_fade_height) {
if (rz >= z_fade_height) return 0;

19
Marlin/src/module/planner_bezier.cpp
View File

@ -45,7 +45,7 @@
#define SIGMA 0.1f
// Compute the linear interpolation between two real numbers.
inline static float interp(float a, float b, float t) { return (1 - t) * a + t * b; }
static inline float interp(const float &a, const float &b, const float &t) { return (1 - t) * a + t * b; }
/**
* Compute a Bézier curve using the De Casteljau's algorithm (see
@ -53,21 +53,20 @@ inline static float interp(float a, float b, float t) { return (1 - t) * a + t *
* easy to code and has good numerical stability (very important,
* since Arudino works with limited precision real numbers).
*/
inline static float eval_bezier(float a, float b, float c, float d, float t) {
float iab = interp(a, b, t);
float ibc = interp(b, c, t);
float icd = interp(c, d, t);
float iabc = interp(iab, ibc, t);
float ibcd = interp(ibc, icd, t);
float iabcd = interp(iabc, ibcd, t);
return iabcd;
static inline float eval_bezier(const float &a, const float &b, const float &c, const float &d, const float &t) {
const float iab = interp(a, b, t),
ibc = interp(b, c, t),
icd = interp(c, d, t),
iabc = interp(iab, ibc, t),
ibcd = interp(ibc, icd, t);
return interp(iabc, ibcd, t);
}
/**
* We approximate Euclidean distance with the sum of the coordinates
* offset (so-called "norm 1"), which is quicker to compute.
*/
inline static float dist1(float x1, float y1, float x2, float y2) { return ABS(x1 - x2) + ABS(y1 - y2); }
static inline float dist1(const float &x1, const float &y1, const float &x2, const float &y2) { return ABS(x1 - x2) + ABS(y1 - y2); }
/**
* The algorithm for computing the step is loosely based on the one in Kig

4
Marlin/src/module/stepper.h
View File

@ -435,7 +435,7 @@ class Stepper {
#endif
// Set the current position in steps
inline static void set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) {
static inline void set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) {
planner.synchronize();
const bool was_enabled = STEPPER_ISR_ENABLED();
if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
@ -443,7 +443,7 @@ class Stepper {
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
}
inline static void set_position(const AxisEnum a, const int32_t &v) {
static inline void set_position(const AxisEnum a, const int32_t &v) {
planner.synchronize();
#ifdef __AVR__

Write Preview
Loading…
Cancel
Save