પીવીએસ-સ્ટુડિયો અને સતત એકીકરણ: ટીમસિટી. ઓપન રોલરકોસ્ટર ટાયકૂન 2 પ્રોજેક્ટનું વિશ્લેષણ

પીવીએસ-સ્ટુડિયો વિશ્લેષકનો ઉપયોગ કરવા માટેના સૌથી વર્તમાન દૃશ્યોમાંનું એક સીઆઈ સિસ્ટમ્સ સાથેનું એકીકરણ છે. અને તેમ છતાં લગભગ કોઈપણ સતત એકીકરણ સિસ્ટમમાંથી PVS-સ્ટુડિયો પ્રોજેક્ટનું વિશ્લેષણ માત્ર થોડા આદેશોમાં બનાવી શકાય છે, અમે આ પ્રક્રિયાને વધુ અનુકૂળ બનાવવાનું ચાલુ રાખીએ છીએ. PVS-સ્ટુડિયો હવે ટીમસિટી - ટીમસિટી ઇન્સ્પેક્શન પ્રકાર માટે વિશ્લેષક આઉટપુટને ફોર્મેટમાં રૂપાંતરિત કરવા માટે સપોર્ટ ધરાવે છે. ચાલો જોઈએ કે તે કેવી રીતે કાર્ય કરે છે.

વપરાયેલ સોફ્ટવેર વિશે માહિતી

પીવીએસ-સ્ટુડિયો — C, C++, C# અને Java કોડનું સ્થિર વિશ્લેષક, વિવિધ પ્રકારની ભૂલો શોધવા અને સુધારવાના કાર્યને સરળ બનાવવા માટે રચાયેલ છે. વિશ્લેષકનો ઉપયોગ Windows, Linux અને macOS પર થઈ શકે છે. આ લેખમાં આપણે ફક્ત વિશ્લેષકનો જ નહીં, પરંતુ તેના વિતરણમાંથી કેટલીક ઉપયોગિતાઓનો પણ સક્રિયપણે ઉપયોગ કરીશું.

સીએલ મોનિટર — એક મોનિટરિંગ સર્વર છે જે કમ્પાઈલર લોન્ચનું મોનિટર કરે છે. તમારા પ્રોજેક્ટનું નિર્માણ કરવાનું શરૂ કરતા પહેલા તે તરત જ ચલાવવું આવશ્યક છે. સ્નૂપિંગ મોડમાં, સર્વર બધા સપોર્ટેડ કમ્પાઇલર્સના રનને અટકાવશે. તે નોંધવું યોગ્ય છે કે આ ઉપયોગિતાનો ઉપયોગ ફક્ત C/C++ પ્રોજેક્ટ્સનું વિશ્લેષણ કરવા માટે થઈ શકે છે.

PlogConverter - વિશ્લેષક અહેવાલોને વિવિધ ફોર્મેટમાં રૂપાંતરિત કરવા માટેની ઉપયોગિતા.

અભ્યાસ હેઠળના પ્રોજેક્ટ વિશે માહિતી

ચાલો આ કાર્યક્ષમતાને વ્યવહારુ ઉદાહરણ પર અજમાવીએ - ચાલો OpenRCT2 પ્રોજેક્ટનું વિશ્લેષણ કરીએ.

ઓપનઆરસીટી 2 - રમત રોલરકોસ્ટર ટાયકૂન 2 (RCT2) નું ખુલ્લું અમલીકરણ, તેને નવા કાર્યો સાથે વિસ્તરણ અને બગ્સ ફિક્સિંગ. ગેમપ્લે રાઇડ્સ, દુકાનો અને સુવિધાઓ ધરાવતો મનોરંજન પાર્ક બનાવવા અને જાળવવાની આસપાસ ફરે છે. ખેલાડીએ મહેમાનોને ખુશ રાખીને નફો મેળવવા અને પાર્કની સારી પ્રતિષ્ઠા જાળવવાનો પ્રયાસ કરવો જોઈએ. OpenRCT2 તમને દૃશ્ય અને સેન્ડબોક્સ બંનેમાં રમવાની મંજૂરી આપે છે. દૃશ્યો માટે ખેલાડીએ ચોક્કસ કાર્યને નિર્ધારિત સમયની અંદર પૂર્ણ કરવું જરૂરી છે, જ્યારે સેન્ડબોક્સ ખેલાડીને કોઈપણ પ્રતિબંધો અથવા નાણાં વિના વધુ લવચીક પાર્ક બનાવવાની મંજૂરી આપે છે.

ગોઠવણ

સમય બચાવવા માટે, હું સંભવતઃ ઇન્સ્ટોલેશન પ્રક્રિયાને છોડી દઈશ અને મારા કમ્પ્યુટર પર ટીમસિટી સર્વર ચાલતું હોય તે ક્ષણથી શરૂ કરીશ. અમારે અહીં જવાની જરૂર છે: localhost:{ઇન્સ્ટોલેશન પ્રક્રિયા દરમિયાન ઉલ્લેખિત પોર્ટ} (મારા કિસ્સામાં, લોકલહોસ્ટ:9090) અને અધિકૃતતા ડેટા દાખલ કરો. દાખલ થયા પછી અમારું સ્વાગત કરવામાં આવશે:

પ્રોજેક્ટ બનાવો બટન પર ક્લિક કરો. આગળ, મેન્યુઅલી પસંદ કરો અને ફીલ્ડ્સ ભરો.

બટન દબાવ્યા પછી બનાવો, અમને સેટિંગ્સ સાથે વિન્ડો દ્વારા આવકારવામાં આવે છે.

ચાલો ક્લિક કરીએ બિલ્ડ રૂપરેખાંકન બનાવો.

ફીલ્ડ્સ ભરો અને ક્લિક કરો બનાવો. અમે તમને વર્ઝન કંટ્રોલ સિસ્ટમ પસંદ કરવાનું કહેતી વિન્ડો જોઈએ છીએ. સ્ત્રોતો પહેલેથી જ સ્થાનિક રીતે સ્થિત હોવાથી, ક્લિક કરો જાઓ.

છેલ્લે, અમે પ્રોજેક્ટ સેટિંગ્સ પર આગળ વધીએ છીએ.

ચાલો એસેમ્બલી સ્ટેપ્સ ઉમેરીએ, આ કરવા માટે ક્લિક કરો: બિલ્ડ સ્ટેપ્સ -> બિલ્ડ સ્ટેપ ઉમેરો.

અહીં અમે પસંદ કરીએ છીએ:

• રનર પ્રકાર -> કમાન્ડ લાઇન
• ચલાવો -> કસ્ટમ સ્ક્રિપ્ટ

અમે પ્રોજેક્ટ સંકલન દરમિયાન વિશ્લેષણ કરીશું, એસેમ્બલી અને વિશ્લેષણ એક પગલું હોવું જોઈએ, તેથી ફીલ્ડ ભરો કસ્ટમ સ્ક્રિપ્ટ:

અમે વ્યક્તિગત પગલાંઓ પછીથી જોઈશું. તે મહત્વનું છે કે વિશ્લેષક લોડ કરવા, પ્રોજેક્ટને એસેમ્બલ કરવા, તેનું વિશ્લેષણ કરવા, રિપોર્ટને આઉટપુટ કરવા અને તેને ફોર્મેટ કરવા માટે કોડની માત્ર અગિયાર લાઇન લાગે છે.

છેલ્લી વસ્તુ જે આપણે કરવાની જરૂર છે તે પર્યાવરણ ચલોને સેટ કરવાની છે, જેની મેં તેમની વાંચનક્ષમતા સુધારવાની કેટલીક રીતો દર્શાવી છે. આ કરવા માટે, ચાલો આગળ વધીએ: પરિમાણો -> નવું પરિમાણ ઉમેરો અને ત્રણ ચલો ઉમેરો:

તમારે ફક્ત બટન દબાવવાનું છે ચલાવો ઉપર જમણા ખૂણે. જ્યારે પ્રોજેક્ટ એસેમ્બલ અને વિશ્લેષણ કરવામાં આવી રહ્યો છે, ત્યારે હું તમને સ્ક્રિપ્ટ વિશે જણાવીશ.

સીધી સ્ક્રિપ્ટ

પ્રથમ, આપણે નવીનતમ PVS-Studio વિતરણ ડાઉનલોડ કરવાની જરૂર છે. આ માટે અમે ચોકલેટી પેકેજ મેનેજરનો ઉપયોગ કરીએ છીએ. જેઓ આ વિશે વધુ જાણવા માગે છે તેમના માટે અનુરૂપ છે લેખ:

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)
  {
    ....
  }
  ....
}

ચાલો નજીકથી નજર કરીએ. અભિવ્યક્તિ imageDirection/8 ખોટા હશે જો છબી દિશા -7 થી 7 ની રેન્જમાં છે. બીજો ભાગ: (ઇમેજ ડાયરેક્શન / 8) != 3 ચેક છબી દિશા શ્રેણીની બહાર હોવા બદલ: અનુક્રમે -31 થી -24 અને 24 થી 31 સુધી. આ રીતે ચોક્કસ શ્રેણીમાં સમાવેશ કરવા માટે સંખ્યાઓ તપાસવી તે મારા માટે તદ્દન વિચિત્ર લાગે છે અને, જો કોડના આ ભાગમાં કોઈ ભૂલ ન હોય તો પણ, હું આ શરતોને વધુ સ્પષ્ટ કરવા માટે ફરીથી લખવાની ભલામણ કરીશ. જે લોકો આ કોડ વાંચશે અને જાળવશે તેમના માટે આનાથી જીવન વધુ સરળ બનશે.

ચેતવણી N5

V587 આ પ્રકારની સોંપણીઓનો એક વિચિત્ર ક્રમ: A = B; B = A;. રેખાઓ તપાસો: 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] અભિવ્યક્તિ '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-Studio સ્ટેટિક વિશ્લેષકને તમારા TeamCity પ્રોજેક્ટમાં એકીકૃત કરવું એકદમ સરળ છે. આ કરવા માટે, ફક્ત એક નાની રૂપરેખાંકન ફાઇલ લખવા માટે તે પૂરતું છે. કોડ તપાસવાથી તમે એસેમ્બલી પછી તરત જ સમસ્યાઓ ઓળખી શકશો, જે જટિલતા અને ફેરફારોની કિંમત હજુ પણ ઓછી હોય ત્યારે તેમને દૂર કરવામાં મદદ કરશે.

જો તમે આ લેખ અંગ્રેજી બોલતા પ્રેક્ષકો સાથે શેર કરવા માંગતા હો, તો કૃપા કરીને અનુવાદ લિંકનો ઉપયોગ કરો: Vladislav Stolyarov. પીવીએસ-સ્ટુડિયો અને સતત એકીકરણ: ટીમસિટી. ઓપન રોલરકોસ્ટર ટાયકૂન 2 પ્રોજેક્ટનું વિશ્લેષણ.

સોર્સ: www.habr.com