പിവിഎസ്-സ്റ്റുഡിയോയും തുടർച്ചയായ സംയോജനവും: ടീംസിറ്റി. ഓപ്പൺ റോളർകോസ്റ്റർ ടൈക്കൂൺ 2 പദ്ധതിയുടെ വിശകലനം

പിവിഎസ്-സ്റ്റുഡിയോ അനലൈസർ ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും നിലവിലെ സാഹചര്യങ്ങളിലൊന്ന് സിഐ സിസ്റ്റങ്ങളുമായുള്ള അതിന്റെ സംയോജനമാണ്. ഏതെങ്കിലും തുടർച്ചയായ ഏകീകരണ സിസ്റ്റത്തിൽ നിന്നുള്ള ഒരു PVS-സ്റ്റുഡിയോ പ്രോജക്റ്റിന്റെ വിശകലനം കുറച്ച് കമാൻഡുകളായി നിർമ്മിക്കാമെങ്കിലും, ഞങ്ങൾ ഈ പ്രക്രിയ കൂടുതൽ സൗകര്യപ്രദമാക്കുന്നത് തുടരുന്നു. TeamCity - TeamCity Inspections Type-നുള്ള ഒരു ഫോർമാറ്റിലേക്ക് അനലൈസർ ഔട്ട്‌പുട്ട് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള പിന്തുണ പിവിഎസ്-സ്റ്റുഡിയോയ്ക്ക് ഇപ്പോൾ ഉണ്ട്. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കാം.

ഉപയോഗിച്ച സോഫ്റ്റ്‌വെയറിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ

പിവിഎസ്-സ്റ്റുഡിയോ - സി, സി++, സി#, ജാവ കോഡ് എന്നിവയുടെ സ്റ്റാറ്റിക് അനലൈസർ, വിവിധ തരത്തിലുള്ള പിശകുകൾ കണ്ടെത്തുന്നതിനും തിരുത്തുന്നതിനുമുള്ള ചുമതലകൾ സുഗമമാക്കുന്നതിന് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. വിൻഡോസ്, ലിനക്സ്, മാകോസ് എന്നിവയിൽ അനലൈസർ ഉപയോഗിക്കാം. ഈ ലേഖനത്തിൽ ഞങ്ങൾ അനലൈസർ മാത്രമല്ല, അതിന്റെ വിതരണത്തിൽ നിന്നുള്ള ചില യൂട്ടിലിറ്റികളും സജീവമായി ഉപയോഗിക്കും.

CLMonitor — കംപൈലർ ലോഞ്ചുകൾ നിരീക്ഷിക്കുന്ന ഒരു മോണിറ്ററിംഗ് സെർവറാണ്. നിങ്ങളുടെ പ്രോജക്റ്റ് നിർമ്മിക്കാൻ തുടങ്ങുന്നതിന് മുമ്പ് ഇത് ഉടൻ പ്രവർത്തിപ്പിക്കണം. സ്‌നൂപ്പിംഗ് മോഡിൽ, പിന്തുണയ്‌ക്കുന്ന എല്ലാ കമ്പൈലറുകളുടെയും റണ്ണുകൾ സെർവർ തടസ്സപ്പെടുത്തും. C/C++ പ്രോജക്റ്റുകൾ വിശകലനം ചെയ്യാൻ മാത്രമേ ഈ യൂട്ടിലിറ്റി ഉപയോഗിക്കാനാകൂ എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

പ്ലഗ് കൺവെർട്ടർ - അനലൈസർ റിപ്പോർട്ടുകൾ വ്യത്യസ്ത ഫോർമാറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനുള്ള ഒരു യൂട്ടിലിറ്റി.

പഠിച്ചുകൊണ്ടിരിക്കുന്ന പദ്ധതിയെക്കുറിച്ചുള്ള വിവരങ്ങൾ

ഒരു പ്രായോഗിക ഉദാഹരണത്തിൽ ഈ പ്രവർത്തനം പരീക്ഷിക്കാം - നമുക്ക് OpenRCT2 പ്രോജക്റ്റ് വിശകലനം ചെയ്യാം.

OpenRCT2 - റോളർകോസ്റ്റർ ടൈക്കൂൺ 2 (RCT2) ഗെയിമിന്റെ ഒരു തുറന്ന നിർവ്വഹണം, പുതിയ ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് ഇത് വികസിപ്പിക്കുകയും ബഗുകൾ പരിഹരിക്കുകയും ചെയ്യുന്നു. റൈഡുകൾ, ഷോപ്പുകൾ, സൗകര്യങ്ങൾ എന്നിവ അടങ്ങിയ ഒരു അമ്യൂസ്‌മെന്റ് പാർക്ക് നിർമ്മിക്കുകയും പരിപാലിക്കുകയും ചെയ്യുന്നതിനെ ചുറ്റിപ്പറ്റിയാണ് ഗെയിംപ്ലേ. അതിഥികളെ സന്തോഷിപ്പിച്ചുകൊണ്ട് പാർക്കിന്റെ നല്ല പ്രശസ്തി നിലനിർത്താനും ലാഭമുണ്ടാക്കാനും കളിക്കാരൻ ശ്രമിക്കണം. സാഹചര്യത്തിലും സാൻഡ്‌ബോക്‌സിലും പ്ലേ ചെയ്യാൻ OpenRCT2 നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു നിശ്ചിത സമയത്തിനുള്ളിൽ ഒരു നിർദ്ദിഷ്‌ട ടാസ്‌ക് പൂർത്തിയാക്കാൻ പ്ലെയർ ആവശ്യപ്പെടുന്നു, അതേസമയം സാൻഡ്‌ബോക്‌സ് പ്ലെയറിനെ നിയന്ത്രണങ്ങളോ സാമ്പത്തികമോ ഇല്ലാതെ കൂടുതൽ വഴക്കമുള്ള പാർക്ക് നിർമ്മിക്കാൻ അനുവദിക്കുന്നു.

കമപ്പെടുത്തല്

സമയം ലാഭിക്കുന്നതിനായി, ഞാൻ ഒരുപക്ഷേ ഇൻസ്റ്റാളേഷൻ പ്രക്രിയ ഒഴിവാക്കുകയും എന്റെ കമ്പ്യൂട്ടറിൽ TeamCity സെർവർ പ്രവർത്തിക്കുന്ന നിമിഷം മുതൽ ആരംഭിക്കുകയും ചെയ്യും. നമ്മൾ ഇതിലേക്ക് പോകേണ്ടതുണ്ട്: ലോക്കൽഹോസ്റ്റ്:{ഇൻസ്റ്റാളേഷൻ പ്രക്രിയയിൽ വ്യക്തമാക്കിയ പോർട്ട്} (എന്റെ കാര്യത്തിൽ, ലോക്കൽഹോസ്റ്റ്:9090) കൂടാതെ അംഗീകാര ഡാറ്റ നൽകുക. പ്രവേശിച്ച ശേഷം ഞങ്ങളെ സ്വാഗതം ചെയ്യും:

Create Project ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക. അടുത്തതായി, സ്വമേധയാ തിരഞ്ഞെടുത്ത് ഫീൽഡുകൾ പൂരിപ്പിക്കുക.

ബട്ടൺ അമർത്തി ശേഷം സൃഷ്ടിക്കാൻ, ക്രമീകരണങ്ങളുള്ള ഒരു വിൻഡോ ഞങ്ങളെ സ്വാഗതം ചെയ്യുന്നു.

ക്ലിക്ക് ചെയ്യാം ബിൽഡ് കോൺഫിഗറേഷൻ സൃഷ്ടിക്കുക.

ഫീൽഡുകൾ പൂരിപ്പിച്ച് ക്ലിക്ക് ചെയ്യുക സൃഷ്ടിക്കാൻ. ഒരു പതിപ്പ് നിയന്ത്രണ സംവിധാനം തിരഞ്ഞെടുക്കാൻ നിങ്ങളോട് ആവശ്യപ്പെടുന്ന ഒരു വിൻഡോ ഞങ്ങൾ കാണുന്നു. ഉറവിടങ്ങൾ ഇതിനകം പ്രാദേശികമായി സ്ഥിതിചെയ്യുന്നതിനാൽ, ക്ലിക്കുചെയ്യുക ഒഴിവാക്കുക.

അവസാനമായി, ഞങ്ങൾ പ്രോജക്റ്റ് ക്രമീകരണങ്ങളിലേക്ക് പോകുന്നു.

നമുക്ക് അസംബ്ലി ഘട്ടങ്ങൾ ചേർക്കാം, ഇത് ചെയ്യുന്നതിന്: ബിൽഡ് സ്റ്റെപ്പുകൾ -> ബിൽഡ് സ്റ്റെപ്പ് ചേർക്കുക.

ഇവിടെ ഞങ്ങൾ തിരഞ്ഞെടുക്കുന്നു:

• റണ്ണർ തരം -> കമാൻഡ് ലൈൻ
• റൺ -> കസ്റ്റം സ്ക്രിപ്റ്റ്

പ്രോജക്റ്റ് സമാഹരണ സമയത്ത് ഞങ്ങൾ വിശകലനം നടത്തുന്നതിനാൽ, അസംബ്ലിയും വിശകലനവും ഒരു ഘട്ടമായിരിക്കണം, അതിനാൽ ഫീൽഡ് പൂരിപ്പിക്കുക ഇച്ഛാനുസൃത സ്ക്രിപ്റ്റ്:

ഞങ്ങൾ വ്യക്തിഗത ഘട്ടങ്ങൾ പിന്നീട് നോക്കും. അനലൈസർ ലോഡുചെയ്യുന്നതിനും പ്രോജക്റ്റ് കൂട്ടിച്ചേർക്കുന്നതിനും വിശകലനം ചെയ്യുന്നതിനും റിപ്പോർട്ട് ഔട്ട്പുട്ട് ചെയ്യുന്നതിനും ഫോർമാറ്റ് ചെയ്യുന്നതിനും പതിനൊന്ന് വരി കോഡ് മാത്രമേ എടുക്കൂ എന്നത് പ്രധാനമാണ്.

പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജീകരിക്കുക എന്നതാണ് നമ്മൾ അവസാനമായി ചെയ്യേണ്ടത്, അവയുടെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നതിനുള്ള ചില വഴികൾ ഞാൻ വിവരിച്ചിട്ടുണ്ട്. ഇത് ചെയ്യുന്നതിന്, നമുക്ക് മുന്നോട്ട് പോകാം: പാരാമീറ്ററുകൾ -> പുതിയ പാരാമീറ്റർ ചേർക്കുക കൂടാതെ മൂന്ന് വേരിയബിളുകൾ ചേർക്കുക:

ബട്ടൺ അമർത്തിയാൽ മതി പ്രവർത്തിപ്പിക്കുക മുകളിൽ വലത് മൂലയിൽ. പ്രോജക്റ്റ് കൂട്ടിച്ചേർക്കുകയും വിശകലനം ചെയ്യുകയും ചെയ്യുമ്പോൾ, സ്ക്രിപ്റ്റിനെക്കുറിച്ച് ഞാൻ നിങ്ങളോട് പറയും.

നേരിട്ട് തിരക്കഥ

ആദ്യം, ഞങ്ങൾ ഏറ്റവും പുതിയ പിവിഎസ്-സ്റ്റുഡിയോ വിതരണം ഡൗൺലോഡ് ചെയ്യേണ്ടതുണ്ട്. ഇതിനായി ഞങ്ങൾ ചോക്കലേറ്റ് പാക്കേജ് മാനേജർ ഉപയോഗിക്കുന്നു. ഇതിനെക്കുറിച്ച് കൂടുതലറിയാൻ ആഗ്രഹിക്കുന്നവർക്കായി, ഒരു അനുബന്ധമുണ്ട് ഒരു ലേഖനം:

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-യുടെ ലോഗിൻ, ലൈസൻസ് കീ നൽകാം:

%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 വരെയുള്ള ശ്രേണിയിലാണ്. രണ്ടാം ഭാഗം: (ചിത്ര ദിശ / 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;
      ....
  }
  ....
}

ഈ കോഡ് ശകലം മിക്കവാറും ഡീകംപൈലേഷൻ വഴിയാണ് ലഭിച്ചത്. തുടർന്ന്, അവശേഷിച്ച അഭിപ്രായമനുസരിച്ച്, പ്രവർത്തിക്കാത്ത കോഡിന്റെ ഒരു ഭാഗം നീക്കം ചെയ്തു. എന്നിരുന്നാലും, ഇനിയും രണ്ട് ഓപ്പറേഷനുകൾ അവശേഷിക്കുന്നു cursorId, അതും കാര്യമായ അർത്ഥമില്ല.

മുന്നറിയിപ്പ് 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] 'പേര് == 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();
  }
}

കോഡ് തികച്ചും വിചിത്രമായി തോന്നുന്നു. കണ്ടീഷനിലോ അല്ലെങ്കിൽ വേരിയബിൾ വീണ്ടും അസൈൻ ചെയ്യുമ്പോഴോ അക്ഷരത്തെറ്റ് സംഭവിച്ചതായി എനിക്ക് തോന്നുന്നു കോളംഹെഡർ പ്രസ്സ്ഡ് കറന്റ് സ്റ്റേറ്റ് മൂല്യങ്ങൾ തെറ്റായ.

തീരുമാനം

ഞങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, നിങ്ങളുടെ TeamCity പ്രോജക്റ്റിലേക്ക് PVS-Studio സ്റ്റാറ്റിക് അനലൈസർ സംയോജിപ്പിക്കുന്നത് വളരെ ലളിതമാണ്. ഇത് ചെയ്യുന്നതിന്, ഒരു ചെറിയ കോൺഫിഗറേഷൻ ഫയൽ എഴുതിയാൽ മതി. കോഡ് പരിശോധിക്കുന്നത് അസംബ്ലിക്ക് ശേഷം ഉടൻ തന്നെ പ്രശ്നങ്ങൾ തിരിച്ചറിയാൻ നിങ്ങളെ അനുവദിക്കും, മാറ്റങ്ങളുടെ സങ്കീർണ്ണതയും വിലയും ഇപ്പോഴും കുറവായിരിക്കുമ്പോൾ അവ ഇല്ലാതാക്കാൻ സഹായിക്കും.

ഇംഗ്ലീഷ് സംസാരിക്കുന്ന പ്രേക്ഷകരുമായി ഈ ലേഖനം പങ്കിടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, വിവർത്തന ലിങ്ക് ഉപയോഗിക്കുക: Vladislav Stolyarov. പിവിഎസ്-സ്റ്റുഡിയോയും തുടർച്ചയായ സംയോജനവും: ടീംസിറ്റി. ഓപ്പൺ റോളർകോസ്റ്റർ ടൈക്കൂൺ 2 പദ്ധതിയുടെ വിശകലനം.

അവലംബം: www.habr.com