ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਅਤੇ ਨਿਰੰਤਰ ਏਕੀਕਰਣ: ਟੀਮਸਿਟੀ। ਓਪਨ ਰੋਲਰਕੋਸਟਰ ਟਾਈਕੂਨ 2 ਪ੍ਰੋਜੈਕਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ

ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਵਿਸ਼ਲੇਸ਼ਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਮੌਜੂਦਾ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚੋਂ ਇੱਕ ਸੀਆਈ ਪ੍ਰਣਾਲੀਆਂ ਨਾਲ ਇਸਦਾ ਏਕੀਕਰਣ ਹੈ। ਅਤੇ ਹਾਲਾਂਕਿ ਲਗਭਗ ਕਿਸੇ ਵੀ ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਪ੍ਰਣਾਲੀ ਤੋਂ ਇੱਕ PVS-ਸਟੂਡੀਓ ਪ੍ਰੋਜੈਕਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਸਿਰਫ ਕੁਝ ਕਮਾਂਡਾਂ ਵਿੱਚ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਅਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਹੋਰ ਵੀ ਸੁਵਿਧਾਜਨਕ ਬਣਾਉਣਾ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ। PVS-ਸਟੂਡੀਓ ਕੋਲ ਹੁਣ ਵਿਸ਼ਲੇਸ਼ਕ ਆਉਟਪੁੱਟ ਨੂੰ TeamCity - TeamCity ਨਿਰੀਖਣ ਕਿਸਮ ਲਈ ਇੱਕ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਸਮਰਥਨ ਹੈ। ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

ਵਰਤੇ ਗਏ ਸੌਫਟਵੇਅਰ ਬਾਰੇ ਜਾਣਕਾਰੀ

ਪੀਵੀਐਸ-ਸਟੂਡੀਓ — C, C++, C# ਅਤੇ Java ਕੋਡ ਦਾ ਇੱਕ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਕ, ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਲੱਭਣ ਅਤੇ ਠੀਕ ਕਰਨ ਦੇ ਕੰਮ ਦੀ ਸਹੂਲਤ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਵਿਸ਼ਲੇਸ਼ਕ ਨੂੰ ਵਿੰਡੋਜ਼, ਲੀਨਕਸ ਅਤੇ ਮੈਕੋਸ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਲੇਖ ਵਿਚ ਅਸੀਂ ਸਰਗਰਮੀ ਨਾਲ ਨਾ ਸਿਰਫ ਵਿਸ਼ਲੇਸ਼ਕ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਸਗੋਂ ਇਸਦੀ ਵੰਡ ਤੋਂ ਕੁਝ ਉਪਯੋਗਤਾਵਾਂ ਵੀ ਵਰਤਾਂਗੇ.

CLMonitor — ਇੱਕ ਨਿਗਰਾਨੀ ਸਰਵਰ ਹੈ ਜੋ ਕੰਪਾਈਲਰ ਲਾਂਚਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਤੁਰੰਤ ਚਲਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਨੂਪਿੰਗ ਮੋਡ ਵਿੱਚ, ਸਰਵਰ ਸਾਰੇ ਸਮਰਥਿਤ ਕੰਪਾਈਲਰ ਦੇ ਰਨ ਨੂੰ ਰੋਕ ਦੇਵੇਗਾ। ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਇਹ ਸਹੂਲਤ ਸਿਰਫ C/C++ ਪ੍ਰੋਜੈਕਟਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।

PlogConverter - ਵਿਸ਼ਲੇਸ਼ਕ ਰਿਪੋਰਟਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਬਦਲਣ ਲਈ ਇੱਕ ਉਪਯੋਗਤਾ।

ਅਧਿਐਨ ਅਧੀਨ ਪ੍ਰੋਜੈਕਟ ਬਾਰੇ ਜਾਣਕਾਰੀ

ਆਉ ਇੱਕ ਵਿਹਾਰਕ ਉਦਾਹਰਣ 'ਤੇ ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ - ਆਓ OpenRCT2 ਪ੍ਰੋਜੈਕਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੀਏ।

ਓਪਨਆਰਸੀਟੀ 2 - ਗੇਮ ਰੋਲਰਕੋਸਟਰ ਟਾਈਕੂਨ 2 (RCT2) ਦਾ ਇੱਕ ਖੁੱਲਾ ਅਮਲੀਕਰਨ, ਇਸ ਨੂੰ ਨਵੇਂ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਫੈਲਾਉਣਾ ਅਤੇ ਬੱਗ ਫਿਕਸ ਕਰਨਾ। ਗੇਮਪਲੇ ਇੱਕ ਮਨੋਰੰਜਨ ਪਾਰਕ ਬਣਾਉਣ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਕਰਨ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਘੁੰਮਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਵਾਰੀਆਂ, ਦੁਕਾਨਾਂ ਅਤੇ ਸਹੂਲਤਾਂ ਸ਼ਾਮਲ ਹਨ। ਖਿਡਾਰੀ ਨੂੰ ਮੁਨਾਫ਼ਾ ਕਮਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਮਹਿਮਾਨਾਂ ਨੂੰ ਖੁਸ਼ ਰੱਖਦੇ ਹੋਏ ਪਾਰਕ ਦੀ ਚੰਗੀ ਸਾਖ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। OpenRCT2 ਤੁਹਾਨੂੰ ਦ੍ਰਿਸ਼ ਅਤੇ ਸੈਂਡਬੌਕਸ ਦੋਵਾਂ ਵਿੱਚ ਖੇਡਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਖਿਡਾਰੀ ਨੂੰ ਇੱਕ ਨਿਰਧਾਰਤ ਸਮੇਂ ਦੇ ਅੰਦਰ ਇੱਕ ਖਾਸ ਕੰਮ ਪੂਰਾ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਸੈਂਡਬੌਕਸ ਖਿਡਾਰੀ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਪਾਬੰਦੀਆਂ ਜਾਂ ਵਿੱਤ ਦੇ ਇੱਕ ਵਧੇਰੇ ਲਚਕਦਾਰ ਪਾਰਕ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਵਿਵਸਥਾ

ਸਮਾਂ ਬਚਾਉਣ ਲਈ, ਮੈਂ ਸ਼ਾਇਦ ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗਾ ਅਤੇ ਉਸ ਪਲ ਤੋਂ ਸ਼ੁਰੂ ਕਰਾਂਗਾ ਜਦੋਂ ਮੇਰੇ ਕੰਪਿਊਟਰ 'ਤੇ TeamCity ਸਰਵਰ ਚੱਲ ਰਿਹਾ ਹੈ। ਸਾਨੂੰ ਇਸ 'ਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ: ਲੋਕਲਹੋਸਟ:{ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਨਿਰਧਾਰਿਤ ਪੋਰਟ} (ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਲੋਕਲਹੋਸਟ:9090) ਅਤੇ ਪ੍ਰਮਾਣੀਕਰਨ ਡੇਟਾ ਦਾਖਲ ਕਰੋ। ਦਾਖਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਸਾਨੂੰ ਇਹਨਾਂ ਦੁਆਰਾ ਸਵਾਗਤ ਕੀਤਾ ਜਾਵੇਗਾ:

ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ ਬਟਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਅੱਗੇ, ਹੱਥੀਂ ਚੁਣੋ ਅਤੇ ਖੇਤਰ ਭਰੋ।

ਬਟਨ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ ਬਣਾਓ, ਸਾਨੂੰ ਸੈਟਿੰਗਾਂ ਵਾਲੀ ਵਿੰਡੋ ਦੁਆਰਾ ਸਵਾਗਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਆਓ ਕਲਿੱਕ ਕਰੀਏ ਬਿਲਡ ਕੌਂਫਿਗਰੇਸ਼ਨ ਬਣਾਓ.

ਖੇਤਰਾਂ ਨੂੰ ਭਰੋ ਅਤੇ ਕਲਿੱਕ ਕਰੋ ਬਣਾਓ. ਅਸੀਂ ਇੱਕ ਵਿੰਡੋ ਵੇਖਦੇ ਹਾਂ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਸੰਸਕਰਣ ਕੰਟਰੋਲ ਸਿਸਟਮ ਦੀ ਚੋਣ ਕਰਨ ਲਈ ਕਹਿ ਰਹੀ ਹੈ। ਕਿਉਂਕਿ ਸਰੋਤ ਪਹਿਲਾਂ ਹੀ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਸਥਿਤ ਹਨ, ਕਲਿੱਕ ਕਰੋ ਛੱਡੋ.

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ ਤੇ ਜਾਂਦੇ ਹਾਂ.

ਆਓ ਅਸੈਂਬਲੀ ਸਟੈਪਸ ਜੋੜੀਏ, ਅਜਿਹਾ ਕਰਨ ਲਈ ਕਲਿੱਕ ਕਰੋ: ਬਿਲਡ ਸਟੈਪਸ -> ਬਿਲਡ ਸਟੈਪ ਸ਼ਾਮਲ ਕਰੋ.

ਇੱਥੇ ਅਸੀਂ ਚੁਣਦੇ ਹਾਂ:

• ਰਨਰ ਦੀ ਕਿਸਮ -> ਕਮਾਂਡ ਲਾਈਨ
• ਚਲਾਓ -> ਕਸਟਮ ਸਕ੍ਰਿਪਟ

ਕਿਉਂਕਿ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਕੰਪਾਇਲੇਸ਼ਨ ਦੌਰਾਨ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਾਂਗੇ, ਅਸੈਂਬਲੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਇੱਕ ਕਦਮ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਇਸ ਲਈ ਖੇਤਰ ਨੂੰ ਭਰੋ ਕਸਟਮ ਸਕ੍ਰਿਪਟ:

ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਕਦਮਾਂ ਨੂੰ ਦੇਖਾਂਗੇ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਵਿਸ਼ਲੇਸ਼ਕ ਨੂੰ ਲੋਡ ਕਰਨਾ, ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ, ਇਸਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ, ਰਿਪੋਰਟ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਫਾਰਮੈਟ ਕਰਨ ਲਈ ਕੋਡ ਦੀਆਂ ਸਿਰਫ ਗਿਆਰਾਂ ਲਾਈਨਾਂ ਲੱਗਦੀਆਂ ਹਨ।

ਆਖ਼ਰੀ ਚੀਜ਼ ਜੋ ਸਾਨੂੰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਉਹ ਹੈ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ, ਜੋ ਮੈਂ ਉਹਨਾਂ ਦੀ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਦੇ ਕੁਝ ਤਰੀਕੇ ਦੱਸੇ ਹਨ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਆਓ ਅੱਗੇ ਵਧੀਏ: ਪੈਰਾਮੀਟਰ -> ਨਵਾਂ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਤਿੰਨ ਵੇਰੀਏਬਲ ਜੋੜੋ:

ਤੁਹਾਨੂੰ ਬਸ ਬਟਨ ਦਬਾਉਣ ਦੀ ਲੋੜ ਹੈ ਚਲਾਓ ਉੱਪਰ ਸੱਜੇ ਕੋਨੇ ਵਿੱਚ. ਜਦੋਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਕੱਠਾ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਮੈਂ ਤੁਹਾਨੂੰ ਸਕ੍ਰਿਪਟ ਬਾਰੇ ਦੱਸਾਂਗਾ।

ਸਿੱਧੇ ਸਕ੍ਰਿਪਟ

ਪਹਿਲਾਂ, ਸਾਨੂੰ ਨਵੀਨਤਮ PVS-ਸਟੂਡੀਓ ਵੰਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸਦੇ ਲਈ ਅਸੀਂ ਚਾਕਲੇਟ ਪੈਕੇਜ ਮੈਨੇਜਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਜਿਹੜੇ ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹਨ, ਉਹਨਾਂ ਲਈ, ਇੱਕ ਅਨੁਸਾਰੀ ਹੈ ਲੇਖ:

choco install pvs-studio -y

ਅੱਗੇ, ਆਓ CLMonitor ਪ੍ਰੋਜੈਕਟ ਬਿਲਡ ਟਰੈਕਿੰਗ ਉਪਯੋਗਤਾ ਨੂੰ ਲਾਂਚ ਕਰੀਏ।

%CLmon% monitor –-attach

ਫਿਰ ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੇ ਰੂਪ ਵਿੱਚ ਬਣਾਵਾਂਗੇ ਐਮਐਸਬੀ MSBuild ਦੇ ਸੰਸਕਰਣ ਦਾ ਮਾਰਗ ਹੈ ਜੋ ਮੈਨੂੰ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ

%MSB% %ProjPath% /t:clean
%MSB% %ProjPath% /t:rebuild /p:configuration=release
%MSB% %ProjPath% /t:g2
%MSB% %ProjPath% /t:PublishPortable

ਚਲੋ ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਲਈ ਲੌਗਇਨ ਅਤੇ ਲਾਇਸੈਂਸ ਕੁੰਜੀ ਦਰਜ ਕਰੀਏ:

%PVS-Studio_cmd% credentials --username %PVS_Name% --serialNumber %PVS_Key%

ਬਿਲਡ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਪ੍ਰੀਪ੍ਰੋਸੈੱਸਡ ਫਾਈਲਾਂ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਣ ਬਣਾਉਣ ਲਈ CLMonitor ਨੂੰ ਦੁਬਾਰਾ ਚਲਾਓ:

%CLmon% analyze -l "c:ptest.plog"

ਫਿਰ ਅਸੀਂ ਆਪਣੀ ਵੰਡ ਤੋਂ ਇੱਕ ਹੋਰ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ. PlogConverter ਇੱਕ ਰਿਪੋਰਟ ਨੂੰ ਇੱਕ ਸਟੈਂਡਰਡ ਫਾਰਮੈਟ ਤੋਂ ਇੱਕ TeamCity-ਵਿਸ਼ੇਸ਼ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਇਸਦਾ ਧੰਨਵਾਦ, ਅਸੀਂ ਇਸਨੂੰ ਬਿਲਡ ਵਿੰਡੋ ਵਿੱਚ ਸਿੱਧਾ ਦੇਖ ਸਕਾਂਗੇ।

%PlogConverter% "c:ptest.plog" --renderTypes=TeamCity -o "C:temp"

ਆਖਰੀ ਪੜਾਅ ਵਿੱਚ ਫਾਰਮੈਟ ਕੀਤੀ ਰਿਪੋਰਟ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਹੈ stdout, ਜਿੱਥੇ ਇਸ ਨੂੰ TeamCity ਪਾਰਸਰ ਦੁਆਰਾ ਚੁੱਕਿਆ ਜਾਵੇਗਾ।

type "C:tempptest.plog_TeamCity.txt"

ਪੂਰਾ ਸਕ੍ਰਿਪਟ ਕੋਡ:

choco install pvs-studio -y
%CLmon% monitor --attach
set platform=x64
%MSB% %ProjPath% /t:clean
%MSB% %ProjPath% /t:rebuild /p:configuration=release
%MSB% %ProjPath% /t:g2
%MSB% %ProjPath% /t:PublishPortable
%PVS-Studio_cmd% credentials --username %PVS_Name% --serialNumber %PVS_Key%
%CLmon% analyze -l "c:ptest.plog"
%PlogConverter% "c:ptest.plog" --renderTypes=TeamCity -o "C:temp"
type "C:tempptest.plog_TeamCity.txt"

ਇਸ ਦੌਰਾਨ, ਪ੍ਰੋਜੈਕਟ ਦਾ ਅਸੈਂਬਲੀ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਸਫਲਤਾਪੂਰਵਕ ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ, ਅਸੀਂ ਟੈਬ 'ਤੇ ਜਾ ਸਕਦੇ ਹਾਂ ਪ੍ਰਾਜੈਕਟ ਅਤੇ ਇਸ ਨੂੰ ਯਕੀਨੀ ਬਣਾਓ.

ਹੁਣ 'ਤੇ ਕਲਿੱਕ ਕਰੀਏ ਨਿਰੀਖਣ ਕੁੱਲਵਿਸ਼ਲੇਸ਼ਕ ਰਿਪੋਰਟ ਦੇਖਣ ਲਈ:

ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਡਾਇਗਨੌਸਟਿਕ ਨਿਯਮ ਨੰਬਰਾਂ ਦੁਆਰਾ ਸਮੂਹਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੋਡ ਰਾਹੀਂ ਨੈਵੀਗੇਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਚੇਤਾਵਨੀ ਦੇ ਨਾਲ ਲਾਈਨ ਨੰਬਰ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਉੱਪਰ ਸੱਜੇ ਕੋਨੇ ਵਿੱਚ ਪ੍ਰਸ਼ਨ ਚਿੰਨ੍ਹ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਨਾਲ ਤੁਹਾਨੂੰ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ ਟੈਬ ਖੁੱਲ੍ਹ ਜਾਵੇਗਾ। ਤੁਸੀਂ ਵਿਸ਼ਲੇਸ਼ਕ ਚੇਤਾਵਨੀ ਦੇ ਨਾਲ ਲਾਈਨ ਨੰਬਰ 'ਤੇ ਕਲਿੱਕ ਕਰਕੇ ਕੋਡ ਰਾਹੀਂ ਵੀ ਨੈਵੀਗੇਟ ਕਰ ਸਕਦੇ ਹੋ। ਵਰਤਣ ਵੇਲੇ ਰਿਮੋਟ ਕੰਪਿਊਟਰ ਤੋਂ ਨੈਵੀਗੇਸ਼ਨ ਸੰਭਵ ਹੈ SourceTreeRoot ਮਾਰਕਰ ਕੋਈ ਵੀ ਜੋ ਵਿਸ਼ਲੇਸ਼ਕ ਦੇ ਸੰਚਾਲਨ ਦੇ ਇਸ ਢੰਗ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦਾ ਹੈ, ਉਹ ਸੰਬੰਧਿਤ ਭਾਗ ਨਾਲ ਆਪਣੇ ਆਪ ਨੂੰ ਜਾਣੂ ਕਰ ਸਕਦਾ ਹੈ ਦਸਤਾਵੇਜ਼.

ਵਿਸ਼ਲੇਸ਼ਕ ਦੇ ਨਤੀਜੇ ਦੇਖਣਾ

ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਬਿਲਡ ਦੀ ਤੈਨਾਤੀ ਅਤੇ ਸੰਰਚਨਾ ਪੂਰੀ ਕਰ ਲਈ ਹੈ, ਆਓ ਅਸੀਂ ਉਸ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਲੱਭੀਆਂ ਕੁਝ ਦਿਲਚਸਪ ਚੇਤਾਵਨੀਆਂ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ ਜੋ ਅਸੀਂ ਦੇਖ ਰਹੇ ਹਾਂ।

ਚੇਤਾਵਨੀ N1

V773 [CWE-401] ਅਪਵਾਦ 'ਨਤੀਜਾ' ਪੁਆਇੰਟਰ ਨੂੰ ਜਾਰੀ ਕੀਤੇ ਬਿਨਾਂ ਸੁੱਟ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਇੱਕ ਮੈਮੋਰੀ ਲੀਕ ਸੰਭਵ ਹੈ. libopenrct2 ObjectFactory.cpp 443

Object* CreateObjectFromJson(....)
{
  Object* result = nullptr;
  ....
  result = CreateObject(entry);
  ....
  if (readContext.WasError())
  {
    throw std::runtime_error("Object has errors");
  }
  ....
}

Object* CreateObject(const rct_object_entry& entry)
{
  Object* result;
  switch (entry.GetType())
  {
    case OBJECT_TYPE_RIDE:
      result = new RideObject(entry);
      break;
    case OBJECT_TYPE_SMALL_SCENERY:
      result = new SmallSceneryObject(entry);
      break;
    case OBJECT_TYPE_LARGE_SCENERY:
      result = new LargeSceneryObject(entry);
      break;
    ....
    default:
      throw std::runtime_error("Invalid object type");
  }
  return result;
}

ਵਿਸ਼ਲੇਸ਼ਕ ਨੇ ਇੱਕ ਗਲਤੀ ਦੇਖੀ ਜੋ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਮੈਮੋਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਆਬਜੈਕਟ ਬਣਾਓ, ਜਦੋਂ ਇੱਕ ਅਪਵਾਦ ਹੁੰਦਾ ਹੈ, ਮੈਮੋਰੀ ਸਾਫ਼ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਇੱਕ ਮੈਮੋਰੀ ਲੀਕ ਹੁੰਦੀ ਹੈ।

ਚੇਤਾਵਨੀ N2

V501 '|' ਦੇ ਖੱਬੇ ਅਤੇ ਸੱਜੇ ਪਾਸੇ '(1ULL << WIDX_MONTH_BOX)' ਇੱਕੋ ਜਿਹੇ ਉਪ-ਸਮੀਕਰਨ ਹਨ। ਆਪਰੇਟਰ libopenrct2ui Cheats.cpp 487

static uint64_t window_cheats_page_enabled_widgets[] = 
{
  MAIN_CHEAT_ENABLED_WIDGETS |
  (1ULL << WIDX_NO_MONEY) |
  (1ULL << WIDX_ADD_SET_MONEY_GROUP) |
  (1ULL << WIDX_MONEY_SPINNER) |
  (1ULL << WIDX_MONEY_SPINNER_INCREMENT) |
  (1ULL << WIDX_MONEY_SPINNER_DECREMENT) |
  (1ULL << WIDX_ADD_MONEY) |
  (1ULL << WIDX_SET_MONEY) |
  (1ULL << WIDX_CLEAR_LOAN) |
  (1ULL << WIDX_DATE_SET) |
  (1ULL << WIDX_MONTH_BOX) |  // <=
  (1ULL << WIDX_MONTH_UP) |
  (1ULL << WIDX_MONTH_DOWN) |
  (1ULL << WIDX_YEAR_BOX) |
  (1ULL << WIDX_YEAR_UP) |
  (1ULL << WIDX_YEAR_DOWN) |
  (1ULL << WIDX_DAY_BOX) |
  (1ULL << WIDX_DAY_UP) |
  (1ULL << WIDX_DAY_DOWN) |
  (1ULL << WIDX_MONTH_BOX) |  // <=
  (1ULL << WIDX_DATE_GROUP) |
  (1ULL << WIDX_DATE_RESET),
  ....
};

ਇੱਕ ਸਥਿਰ ਵਿਸ਼ਲੇਸ਼ਕ ਤੋਂ ਇਲਾਵਾ ਬਹੁਤ ਘੱਟ ਲੋਕ ਇਸ ਧਿਆਨ ਦੀ ਪ੍ਰੀਖਿਆ ਪਾਸ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਕਾਪੀ-ਪੇਸਟ ਉਦਾਹਰਨ ਇਸ ਕਾਰਨ ਕਰਕੇ ਚੰਗੀ ਹੈ।

ਚੇਤਾਵਨੀਆਂ N3

V703 ਇਹ ਅਜੀਬ ਹੈ ਕਿ ਉਤਪੰਨ ਕਲਾਸ 'RCT12BannerElement' ਵਿੱਚ 'ਝੰਡੇ' ਖੇਤਰ ਬੇਸ ਕਲਾਸ 'RCT12TileElementBase' ਵਿੱਚ ਫੀਲਡ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰਦਾ ਹੈ। ਲਾਈਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: RCT12.h:570, RCT12.h:259। libopenrct2 RCT12.h 570

struct RCT12SpriteBase
{
  ....
  uint8_t flags;
  ....
};
struct rct1_peep : RCT12SpriteBase
{
  ....
  uint8_t flags;
  ....
};

ਬੇਸ਼ੱਕ, ਬੇਸ ਕਲਾਸ ਅਤੇ ਡਿਸੈਂਡੈਂਟ ਵਿੱਚ ਇੱਕੋ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹਮੇਸ਼ਾ ਇੱਕ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦਾ। ਹਾਲਾਂਕਿ, ਵਿਰਾਸਤੀ ਤਕਨਾਲੋਜੀ ਖੁਦ ਇਹ ਮੰਨਦੀ ਹੈ ਕਿ ਮਾਤਾ-ਪਿਤਾ ਵਰਗ ਦੇ ਸਾਰੇ ਖੇਤਰ ਬਾਲ ਵਰਗ ਵਿੱਚ ਮੌਜੂਦ ਹਨ। ਵਾਰਸ ਵਿੱਚ ਇੱਕੋ ਨਾਮ ਨਾਲ ਖੇਤ ਘੋਸ਼ਿਤ ਕਰਕੇ, ਅਸੀਂ ਭੰਬਲਭੂਸਾ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ।

ਚੇਤਾਵਨੀ N4

V793 ਇਹ ਅਜੀਬ ਹੈ ਕਿ 'imageDirection/8' ਕਥਨ ਦਾ ਨਤੀਜਾ ਸਥਿਤੀ ਦਾ ਇੱਕ ਹਿੱਸਾ ਹੈ. ਸ਼ਾਇਦ, ਇਸ ਕਥਨ ਦੀ ਤੁਲਨਾ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਨਾਲ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਸੀ। libopenrct2 ObservationTower.cpp 38

void vehicle_visual_observation_tower(...., int32_t imageDirection, ....)
{
  if ((imageDirection / 8) && (imageDirection / 8) != 3)
  {
    ....
  }
  ....
}

ਆਓ ਇੱਕ ਡੂੰਘੀ ਵਿਚਾਰ ਕਰੀਏ। ਸਮੀਕਰਨ ਚਿੱਤਰ ਦਿਸ਼ਾ/8 ਝੂਠਾ ਹੋਵੇਗਾ ਜੇਕਰ ਚਿੱਤਰ ਦੀ ਦਿਸ਼ਾ -7 ਤੋਂ 7 ਦੀ ਰੇਂਜ ਵਿੱਚ ਹੈ। ਦੂਜਾ ਭਾਗ: (imageDirection/8) !=3 ਜਾਂਚਾਂ ਚਿੱਤਰ ਦੀ ਦਿਸ਼ਾ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਹੋਣ ਲਈ: ਕ੍ਰਮਵਾਰ -31 ਤੋਂ -24 ਅਤੇ 24 ਤੋਂ 31 ਤੱਕ। ਇਸ ਤਰੀਕੇ ਨਾਲ ਕਿਸੇ ਖਾਸ ਰੇਂਜ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਸੰਖਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਮੇਰੇ ਲਈ ਬਹੁਤ ਅਜੀਬ ਲੱਗਦਾ ਹੈ ਅਤੇ, ਭਾਵੇਂ ਕੋਡ ਦੇ ਇਸ ਹਿੱਸੇ ਵਿੱਚ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ, ਮੈਂ ਇਹਨਾਂ ਸ਼ਰਤਾਂ ਨੂੰ ਹੋਰ ਸਪੱਸ਼ਟ ਹੋਣ ਲਈ ਦੁਬਾਰਾ ਲਿਖਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਾਂਗਾ। ਇਹ ਉਹਨਾਂ ਲੋਕਾਂ ਲਈ ਜੀਵਨ ਨੂੰ ਬਹੁਤ ਸੌਖਾ ਬਣਾ ਦੇਵੇਗਾ ਜੋ ਇਸ ਕੋਡ ਨੂੰ ਪੜ੍ਹਦੇ ਅਤੇ ਸੰਭਾਲਦੇ ਹਨ।

ਚੇਤਾਵਨੀ N5

V587 ਇਸ ਕਿਸਮ ਦੇ ਅਸਾਈਨਮੈਂਟਾਂ ਦਾ ਇੱਕ ਅਜੀਬ ਕ੍ਰਮ: A = B; ਬੀ = ਏ;। ਲਾਈਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: 1115, 1118. libopenrct2ui MouseInput.cpp 1118

void process_mouse_over(....)
{
  ....
  switch (window->widgets[widgetId].type)
  {
    case WWT_VIEWPORT:
      ebx = 0;
      edi = cursorId;                                 // <=
      // Window event WE_UNKNOWN_0E was called here,
      // but no windows actually implemented a handler and
      // it's not known what it was for
      cursorId = edi;                                 // <=
      if ((ebx & 0xFF) != 0)
      {
        set_cursor(cursorId);
        return;
      }
      break;
      ....
  }
  ....
}

ਇਹ ਕੋਡ ਟੁਕੜਾ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਡੀਕੰਪਿਲੇਸ਼ਨ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ। ਫਿਰ, ਟਿੱਪਣੀ ਛੱਡ ਕੇ ਨਿਰਣਾ ਕਰਦੇ ਹੋਏ, ਗੈਰ-ਕਾਰਜ ਕੋਡ ਦਾ ਹਿੱਸਾ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਸੀ. ਹਾਲਾਂਕਿ, ਅਜੇ ਵੀ ਕੁਝ ਓਪਰੇਸ਼ਨ ਬਾਕੀ ਹਨ ਕਰਸਰ ਆਈ.ਡੀ, ਜਿਸਦਾ ਵੀ ਬਹੁਤਾ ਮਤਲਬ ਨਹੀਂ ਹੈ।

ਚੇਤਾਵਨੀ N6

V1004 [CWE-476] 'ਪਲੇਅਰ' ਪੁਆਇੰਟਰ ਨੂੰ nullptr ਦੇ ਵਿਰੁੱਧ ਪ੍ਰਮਾਣਿਤ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਅਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਵਰਤਿਆ ਗਿਆ ਸੀ। ਲਾਈਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: 2085, 2094. libopenrct2 Network.cpp 2094

void Network::ProcessPlayerList()
{
  ....
  auto* player = GetPlayerByID(pendingPlayer.Id);
  if (player == nullptr)
  {
    // Add new player.
    player = AddPlayer("", "");
    if (player)                                          // <=
    {
      *player = pendingPlayer;
       if (player->Flags & NETWORK_PLAYER_FLAG_ISSERVER)
       {
         _serverConnection->Player = player;
       }
    }
    newPlayers.push_back(player->Id);                    // <=
  }
  ....
}

ਇਹ ਕੋਡ ਠੀਕ ਕਰਨਾ ਕਾਫ਼ੀ ਆਸਾਨ ਹੈ; ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਤੀਜੀ ਵਾਰ ਦੇਖਣ ਦੀ ਲੋੜ ਹੈ ਖਿਡਾਰੀ ਇੱਕ ਨਲ ਪੁਆਇੰਟਰ ਵਿੱਚ, ਜਾਂ ਇਸਨੂੰ ਕੰਡੀਸ਼ਨਲ ਸਟੇਟਮੈਂਟ ਦੇ ਮੁੱਖ ਭਾਗ ਵਿੱਚ ਜੋੜੋ। ਮੈਂ ਦੂਜੇ ਵਿਕਲਪ ਦਾ ਸੁਝਾਅ ਦੇਵਾਂਗਾ:

void Network::ProcessPlayerList()
{
  ....
  auto* player = GetPlayerByID(pendingPlayer.Id);
  if (player == nullptr)
  {
    // Add new player.
    player = AddPlayer("", "");
    if (player)
    {
      *player = pendingPlayer;
      if (player->Flags & NETWORK_PLAYER_FLAG_ISSERVER)
      {
        _serverConnection->Player = player;
      }
      newPlayers.push_back(player->Id);
    }
  }
  ....
}

ਚੇਤਾਵਨੀ N7

V547 [CWE-570] ਸਮੀਕਰਨ 'name == nullptr' ਹਮੇਸ਼ਾ ਗਲਤ ਹੁੰਦਾ ਹੈ। libopenrct2 ServerList.cpp 102

std::optional<ServerListEntry> ServerListEntry::FromJson(...)
{
  auto name = json_object_get(server, "name");
  .....
  if (name == nullptr || version == nullptr)
  {
    ....
  }
  else
  {
    ....
    entry.name = (name == nullptr ? "" : json_string_value(name));
    ....
  }
  ....
}

ਤੁਸੀਂ ਇੱਕ ਝਟਕੇ ਵਿੱਚ ਕੋਡ ਦੀ ਇੱਕ ਮੁਸ਼ਕਲ ਪੜ੍ਹਨ ਵਾਲੀ ਲਾਈਨ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਦੀ ਜਾਂਚ ਕਰਕੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹੋ nullptr. ਮੈਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਬਦਲਣ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹਾਂ:

std::optional<ServerListEntry> ServerListEntry::FromJson(...)
{
  auto name = json_object_get(server, "name");
  .....
  if (name == nullptr || version == nullptr)
  {
    name = ""
    ....
  }
  else
  {
    ....
    entry.name = json_string_value(name);
    ....
  }
  ....
}

ਚੇਤਾਵਨੀ N8

V1048 [CWE-1164] 'ColumnHeaderPressedCurrentState' ਵੇਰੀਏਬਲ ਨੂੰ ਉਹੀ ਮੁੱਲ ਦਿੱਤਾ ਗਿਆ ਸੀ। libopenrct2ui CustomListView.cpp 510

void CustomListView::MouseUp(....)
{
  ....
  if (!ColumnHeaderPressedCurrentState)
  {
    ColumnHeaderPressed = std::nullopt;
    ColumnHeaderPressedCurrentState = false;
    Invalidate();
  }
}

ਕੋਡ ਕਾਫ਼ੀ ਅਜੀਬ ਲੱਗਦਾ ਹੈ. ਇਹ ਮੈਨੂੰ ਜਾਪਦਾ ਹੈ ਕਿ ਸਥਿਤੀ ਵਿੱਚ ਜਾਂ ਵੇਰੀਏਬਲ ਨੂੰ ਦੁਬਾਰਾ ਨਿਰਧਾਰਤ ਕਰਨ ਵੇਲੇ ਇੱਕ ਟਾਈਪੋ ਸੀ ਕਾਲਮ ਹੈਡਰ ਦਬਾਇਆ ਮੌਜੂਦਾ ਸਥਿਤੀ ਮੁੱਲ ਝੂਠੇ.

ਸਿੱਟਾ

ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਤੁਹਾਡੇ ਟੀਮਸਿਟੀ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ PVS-ਸਟੂਡੀਓ ਸਟੈਟਿਕ ਐਨਾਲਾਈਜ਼ਰ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਿਰਫ ਇੱਕ ਛੋਟੀ ਸੰਰਚਨਾ ਫਾਈਲ ਲਿਖਣ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ. ਕੋਡ ਦੀ ਜਾਂਚ ਕਰਨ ਨਾਲ ਤੁਹਾਨੂੰ ਅਸੈਂਬਲੀ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ ਸਮੱਸਿਆਵਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਮਿਲੇਗੀ, ਜੋ ਉਹਨਾਂ ਨੂੰ ਖਤਮ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗੀ ਜਦੋਂ ਤਬਦੀਲੀਆਂ ਦੀ ਗੁੰਝਲਤਾ ਅਤੇ ਲਾਗਤ ਅਜੇ ਵੀ ਘੱਟ ਹੋਵੇਗੀ।

ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਲੇਖ ਨੂੰ ਅੰਗ੍ਰੇਜ਼ੀ ਬੋਲਣ ਵਾਲੇ ਦਰਸ਼ਕਾਂ ਨਾਲ ਸਾਂਝਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ਅਨੁਵਾਦ ਲਿੰਕ ਦੀ ਵਰਤੋਂ ਕਰੋ: ਵਲਾਦਿਸਲਾਵ ਸਟੋਲਯਾਰੋਵ। ਪੀਵੀਐਸ-ਸਟੂਡੀਓ ਅਤੇ ਨਿਰੰਤਰ ਏਕੀਕਰਣ: ਟੀਮਸਿਟੀ। ਓਪਨ ਰੋਲਰਕੋਸਟਰ ਟਾਈਕੂਨ 2 ਪ੍ਰੋਜੈਕਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ.

ਸਰੋਤ: www.habr.com