LCOV - code coverage report
Current view: top level - Core - OOConstToString.m (source / functions) Hit Total Coverage
Test: coverxygen.info Lines: 0 52 0.0 %
Date: 2025-05-28 07:50:54 Functions: 0 0 -

          Line data    Source code
       1           0 : /*
       2             : 
       3             : OOConstToString.m
       4             : 
       5             : Oolite
       6             : Copyright (C) 2004-2013 Giles C Williams and contributors
       7             : 
       8             : This program is free software; you can redistribute it and/or
       9             : modify it under the terms of the GNU General Public License
      10             : as published by the Free Software Foundation; either version );
      11             : of the License, or (at your option) any later version.
      12             : 
      13             : This program is distributed in the hope that it will be useful,
      14             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             : GNU General Public License for more details.
      17             : 
      18             : You should have received a copy of the GNU General Public License
      19             : along with this program; if not, write to the Free Software
      20             : Foundation, Inc., ); Franklin Street, Fifth Floor, Boston,
      21             : MA );-);, USA.
      22             : 
      23             : */
      24             : 
      25             : #import "OOConstToString.h"
      26             : #include <jsapi.h>
      27             : #import "OOCollectionExtractors.h"
      28             : 
      29             : #import "Universe.h"
      30             : #import "PlayerEntity.h"
      31             : #import "OOEquipmentType.h"
      32             : 
      33           0 : #define CASE(foo) case foo: return @#foo;
      34           0 : #define REVERSE_CASE(foo) if ([string isEqualToString:@#foo]) return foo;
      35             : 
      36             : 
      37           0 : #define ENTRY(label, value) case label: return @#label;
      38           0 : #define GALACTIC_HYPERSPACE_ENTRY(label, value) case GALACTIC_HYPERSPACE_##label: return @#label;
      39           0 : #define DIFF_STRING_ENTRY(label, string) case label: return @string;
      40             : 
      41           0 : NSString *OOStringFromEntityStatus(OOEntityStatus value)
      42             : {
      43             :         switch (value)
      44             :         {
      45             :                 #include "OOEntityStatus.tbl"
      46             :         }
      47             :         return @"UNDEFINED";
      48             : }
      49             : 
      50             : 
      51           0 : NSString *OOStringFromBehaviour(OOBehaviour value)
      52             : {
      53             :         switch (value)
      54             :         {
      55             :                 #include "OOBehaviour.tbl"
      56             :         }
      57             :         
      58             :         return @"** BEHAVIOUR UNKNOWN **";
      59             : }
      60             : 
      61             : 
      62           0 : NSString *OOStringFromCompassMode(OOCompassMode value)
      63             : {
      64             :         switch (value)
      65             :         {
      66             :                 #include "OOCompassMode.tbl"
      67             :         }
      68             :         
      69             :         return @"UNDEFINED";
      70             : }
      71             : 
      72           0 : NSString *OOStringFromLongRangeChartMode(OOLongRangeChartMode value)
      73             : {
      74             :         switch (value)
      75             :         {
      76             :                 #include "OOLongRangeChartMode.tbl"
      77             :         }
      78             : 
      79             :         return @"UNDEFINED";
      80             : }
      81             : 
      82           0 : NSString *OOStringFromGalacticHyperspaceBehaviour(OOGalacticHyperspaceBehaviour value)
      83             : {
      84             :         switch (value)
      85             :         {
      86             :                 #include "OOGalacticHyperspaceBehaviour.tbl"
      87             :         }
      88             :         
      89             :         return @"UNDEFINED";
      90             : }
      91             : 
      92             : 
      93           0 : NSString *OOStringFromGUIScreenID(OOGUIScreenID value)
      94             : {
      95             :         switch (value)
      96             :         {
      97             :                 #include "OOGUIScreenID.tbl"
      98             :         }
      99             :         
     100             :         return @"UNDEFINED";
     101             : }
     102             : 
     103             : 
     104           0 : NSString *OOStringFromScanClass(OOScanClass value)
     105             : {
     106             :         switch (value)
     107             :         {
     108             :                 #include "OOScanClass.tbl"
     109             :         }
     110             :         
     111             :         return @"UNDEFINED";
     112             : }
     113             : 
     114             : 
     115           0 : NSString *OOStringFromShipDamageType(OOShipDamageType value)
     116             : {
     117             :         switch (value)
     118             :         {
     119             :                 #include "OOShipDamageType.tbl"
     120             :         }
     121             :         
     122             :         return @"UNDEFINED";
     123             : }
     124             : 
     125           0 : NSString *OOStringFromLegalStatusReason(OOLegalStatusReason value)
     126             : {
     127             :         switch (value)
     128             :         {
     129             :                 #include "OOLegalStatusReason.tbl"
     130             :         }
     131             :         
     132             :         return @"UNDEFINED";
     133             : }
     134             : 
     135             : 
     136             : #undef ENTRY
     137             : #undef GALACTIC_HYPERSPACE_ENTRY
     138             : 
     139             : 
     140           0 : #define ENTRY(label, value) if ([string isEqualToString:@#label])  return label;
     141           0 : #define GALACTIC_HYPERSPACE_ENTRY(label, value) if ([string isEqualToString:@#label])  return GALACTIC_HYPERSPACE_##label;
     142             : 
     143           0 : OOEntityStatus OOEntityStatusFromString(NSString *string)
     144             : {
     145             :         #include "OOEntityStatus.tbl"
     146             :         
     147             :         return kOOEntityStatusDefault;
     148             : }
     149             : 
     150             : 
     151           0 : OOCompassMode OOCompassModeFromString(NSString *string)
     152             : {
     153             :         #include "OOCompassMode.tbl"
     154             :         
     155             :         return kOOCompassModeDefault;
     156             : }
     157             : 
     158             : 
     159           0 : OOGalacticHyperspaceBehaviour OOGalacticHyperspaceBehaviourFromString(NSString *string)
     160             : {
     161             :         #include "OOGalacticHyperspaceBehaviour.tbl"
     162             :         
     163             :         // Transparently (but inefficiently) support american spelling. FIXME: remove in EMMSTRAN.
     164             :         if ([string hasPrefix:@"BEHAVIOR_"])
     165             :         {
     166             :                 string = [string substringFromIndex:[@"BEHAVIOR_" length]];
     167             :                 string = [@"BEHAVIOUR_" stringByAppendingString:string];
     168             :                 return OOGalacticHyperspaceBehaviourFromString(string);
     169             :         }
     170             :         
     171             :         return kOOGalacticHyperspaceBehaviourDefault;
     172             : }
     173             : 
     174             : 
     175           0 : OOGUIScreenID OOGUIScreenIDFromString(NSString *string)
     176             : {
     177             :         #include "OOGUIScreenID.tbl"
     178             :         
     179             :         return kOOGUIScreenIDDefault;
     180             : }
     181             : 
     182             : 
     183           0 : OOScanClass OOScanClassFromString(NSString *string)
     184             : {
     185             :         #include "OOScanClass.tbl"
     186             :         
     187             :         return kOOScanClassDefault;
     188             : }
     189             : 
     190           0 : OOLongRangeChartMode OOLongRangeChartModeFromString(NSString *string)
     191             : {
     192             :         #include "OOLongRangeChartMode.tbl"
     193             :         
     194             :         return kOOLongRangeChartModeDefault;
     195             : }
     196             : 
     197             : #undef ENTRY
     198             : #undef GALACTIC_HYPERSPACE_ENTRY
     199             : 
     200             : 
     201           0 : NSString *RouteTypeToString(OORouteType routeType)
     202             : {
     203             :         switch (routeType)
     204             :         {
     205             :                 CASE(OPTIMIZED_BY_NONE);
     206             :                 CASE(OPTIMIZED_BY_JUMPS);
     207             :                 CASE(OPTIMIZED_BY_TIME);
     208             :         }
     209             :         
     210             :         return @"** ROUTE TYPE UNKNOWN **";
     211             : }
     212             : 
     213             : 
     214           0 : NSString *OODisplayStringFromGovernmentID(OOGovernmentID government)
     215             : {
     216             :         NSArray         *strings = nil;
     217             :         NSString        *value = nil;
     218             :         
     219             :         strings = [[UNIVERSE descriptions] objectForKey:@"government"]; 
     220             :         if ([strings isKindOfClass:[NSArray class]] && government < [strings count])
     221             :         {
     222             :                 value = [strings objectAtIndex:government];
     223             :                 if ([value isKindOfClass:[NSString class]]) return value;
     224             :         }
     225             :         
     226             :         return nil;
     227             : }
     228             : 
     229             : 
     230           0 : NSString *OODisplayStringFromEconomyID(OOEconomyID economy)
     231             : {
     232             :         NSArray         *strings = nil;
     233             :         NSString        *value = nil;
     234             :         
     235             :         strings = [[UNIVERSE descriptions] objectForKey:@"economy"]; 
     236             :         if ([strings isKindOfClass:[NSArray class]] && economy < [strings count])
     237             :         {
     238             :                 value = [strings objectAtIndex:economy];
     239             :                 if ([value isKindOfClass:[NSString class]]) return value;
     240             :         }
     241             :         
     242             :         return nil;
     243             : }
     244             : 
     245             : 
     246           0 : NSString *JSTypeToString(int /* JSType */ type)
     247             : {
     248             :         switch ((JSType)type)
     249             :         {
     250             :                 CASE(JSTYPE_VOID);
     251             :                 CASE(JSTYPE_OBJECT);
     252             :                 CASE(JSTYPE_FUNCTION);
     253             :                 CASE(JSTYPE_STRING);
     254             :                 CASE(JSTYPE_NUMBER);
     255             :                 CASE(JSTYPE_BOOLEAN);
     256             :                 CASE(JSTYPE_NULL);
     257             :                 CASE(JSTYPE_XML);
     258             :                 CASE(JSTYPE_LIMIT);
     259             :         }
     260             :         return [NSString stringWithFormat:@"unknown (%u)", type];
     261             : }
     262             : 
     263             : 
     264           0 : NSString *OOStringFromWeaponType(OOWeaponType weapon)
     265             : {
     266             :         if (weapon == nil) {
     267             :                 return @"EQ_WEAPON_NONE";
     268             :         } else {
     269             :                 return [weapon identifier];
     270             :         }
     271             : }
     272             : 
     273             : 
     274           0 : OOWeaponType OOWeaponTypeFromString(NSString *string)
     275             : {
     276             :         return OOWeaponTypeFromEquipmentIdentifierSloppy(string);
     277             : }
     278             : 
     279             : 
     280           0 : NSString *OOEquipmentIdentifierFromWeaponType(OOWeaponType weapon)
     281             : {
     282             :         return [weapon identifier];
     283             : }
     284             : 
     285             : 
     286           0 : OOWeaponType OOWeaponTypeFromEquipmentIdentifierSloppy(NSString *string)
     287             : {
     288             :         OOWeaponType w = [OOEquipmentType equipmentTypeWithIdentifier:string];
     289             :         if (w == nil)
     290             :         {
     291             :                 if (![string hasPrefix:@"EQ_"])
     292             :                 {
     293             :                         w = [OOEquipmentType equipmentTypeWithIdentifier:[NSString stringWithFormat:@"EQ_%@",string]];
     294             :                         if (w != nil)
     295             :                         {
     296             :                                 return w;
     297             :                         }
     298             :                 }
     299             :                 return [OOEquipmentType equipmentTypeWithIdentifier:@"EQ_WEAPON_NONE"];
     300             :         }
     301             :         return w;
     302             : }
     303             : 
     304             : 
     305             : /* Previous save games will have weapon types stored as ints to the
     306             :  * various weapon types */
     307           0 : OOWeaponType OOWeaponTypeFromEquipmentIdentifierLegacy(NSString *string)
     308             : {
     309             :         if ([string intValue] > 0)
     310             :         {
     311             :                 switch ([string intValue])
     312             :                 {
     313             :                 case 2:
     314             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(@"EQ_WEAPON_PULSE_LASER");
     315             :                 case 3:
     316             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(@"EQ_WEAPON_BEAM_LASER");
     317             :                 case 4:
     318             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(@"EQ_WEAPON_MINING_LASER");
     319             :                 case 5:
     320             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(@"EQ_WEAPON_MILITARY_LASER");
     321             :                 case 10:
     322             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(@"EQ_WEAPON_THARGOID_LASER");
     323             :                 default:
     324             :                         return OOWeaponTypeFromEquipmentIdentifierSloppy(string);
     325             :                 }
     326             :         }
     327             :         return OOWeaponTypeFromEquipmentIdentifierSloppy(string);
     328             : }
     329             : 
     330             : 
     331           0 : OOWeaponType OOWeaponTypeFromEquipmentIdentifierStrict(NSString *string)
     332             : {
     333             :         // there is no difference between the two any more
     334             :         return OOWeaponTypeFromEquipmentIdentifierSloppy(string);
     335             : }
     336             : 
     337             : 
     338           0 : NSString *CargoTypeToString(OOCargoType cargo)
     339             : {
     340             :         switch (cargo)
     341             :         {
     342             :                 CASE(CARGO_NOT_CARGO);
     343             :                 CASE(CARGO_SLAVES);
     344             :                 CASE(CARGO_ALLOY);
     345             :                 CASE(CARGO_MINERALS);
     346             :                 CASE(CARGO_THARGOID);
     347             :                 CASE(CARGO_RANDOM);
     348             :                 CASE(CARGO_SCRIPTED_ITEM);
     349             :                 CASE(CARGO_CHARACTER);
     350             :         }
     351             :         return @"Unknown cargo";
     352             : }
     353             : 
     354             : 
     355           0 : OOCargoType StringToCargoType(NSString *string)
     356             : {
     357             :         REVERSE_CASE(CARGO_NOT_CARGO);
     358             :         REVERSE_CASE(CARGO_SLAVES);
     359             :         REVERSE_CASE(CARGO_ALLOY);
     360             :         REVERSE_CASE(CARGO_MINERALS);
     361             :         REVERSE_CASE(CARGO_THARGOID);
     362             :         REVERSE_CASE(CARGO_RANDOM);
     363             :         REVERSE_CASE(CARGO_SCRIPTED_ITEM);
     364             :         REVERSE_CASE(CARGO_CHARACTER);
     365             :         
     366             :         // Backwards compatibility.
     367             :         if ([string isEqual:@"CARGO_CARRIED"]) return CARGO_RANDOM;
     368             :         
     369             :         return kOOCargoTypeDefault;
     370             : }
     371             : 
     372             : 
     373           0 : NSString *EnergyUnitTypeToString(OOEnergyUnitType unit)
     374             : {
     375             :         switch (unit)
     376             :         {
     377             :                 CASE(ENERGY_UNIT_NONE);
     378             :                 CASE(ENERGY_UNIT_NORMAL);
     379             :                 CASE(ENERGY_UNIT_NAVAL);
     380             :                 CASE(ENERGY_UNIT_NORMAL_DAMAGED);
     381             :                 CASE(ENERGY_UNIT_NAVAL_DAMAGED);
     382             :                         
     383             :                 case OLD_ENERGY_UNIT_NORMAL:
     384             :                 case OLD_ENERGY_UNIT_NAVAL:
     385             :                         break;
     386             :         }
     387             :         
     388             :         return @"Unsupported energy unit";
     389             : }
     390             : 
     391             : 
     392           0 : OOEnergyUnitType StringToEnergyUnitType(NSString *string)
     393             : {
     394             :         REVERSE_CASE(ENERGY_UNIT_NONE);
     395             :         REVERSE_CASE(ENERGY_UNIT_NORMAL);
     396             :         REVERSE_CASE(ENERGY_UNIT_NAVAL);
     397             :         REVERSE_CASE(ENERGY_UNIT_NORMAL_DAMAGED);
     398             :         REVERSE_CASE(ENERGY_UNIT_NAVAL_DAMAGED);
     399             :         
     400             :         return kOOEnergyUnitTypeDefault;
     401             : }
     402             : 
     403             : 
     404           0 : NSString *OODisplayRatingStringFromKillCount(unsigned kills)
     405             : {
     406             :         enum { kRatingCount = 9 };
     407             :         
     408             :         NSArray                         *ratingNames = nil;
     409             :         const unsigned          killThresholds[kRatingCount - 1] =
     410             :                                                 {
     411             :                                                         0x0008,
     412             :                                                         0x0010,
     413             :                                                         0x0020,
     414             :                                                         0x0040,
     415             :                                                         0x0080,
     416             :                                                         0x0200,
     417             :                                                         0x0A00,
     418             :                                                         0x1900
     419             :                                                 };
     420             :         unsigned                        i;
     421             :         
     422             :         ratingNames = [[UNIVERSE descriptions] oo_arrayForKey:@"rating"];
     423             :         for (i = 0; i < kRatingCount - 1; ++i)
     424             :         {
     425             :                 if (kills < killThresholds[i])  return [ratingNames oo_stringAtIndex:i];
     426             :         }
     427             :         
     428             :         return [ratingNames oo_stringAtIndex:kRatingCount - 1];
     429             : }
     430             : 
     431             : 
     432           0 : NSString *KillCountToRatingAndKillString(unsigned kills)
     433             : {
     434             :         return [NSString stringWithFormat:@"%@   (%u)", OODisplayRatingStringFromKillCount(kills), kills];
     435             : }
     436             : 
     437             : 
     438           0 : NSString *OODisplayStringFromLegalStatus(int legalStatus)
     439             : {
     440             :         enum { kStatusCount = 3 };
     441             :         
     442             :         NSArray                         *statusNames = nil;
     443             :         const int                       statusThresholds[kStatusCount - 1] =
     444             :                                                 {
     445             :                                                         1,
     446             :                                                         51
     447             :                                                 };
     448             :         unsigned                        i;
     449             :         
     450             :         statusNames = [[UNIVERSE descriptions] oo_arrayForKey:@"legal_status"];
     451             :         for (i = 0; i != kStatusCount - 1; ++i)
     452             :         {
     453             :                 if (legalStatus < statusThresholds[i])  return [statusNames oo_stringAtIndex:i];
     454             :         }
     455             :         
     456             :         return [statusNames oo_stringAtIndex:kStatusCount - 1];
     457             : }
     458             : 
     459             : 
     460           0 : NSString *OODisplayStringFromAlertCondition(OOAlertCondition alertCondition)
     461             : {
     462             :         NSArray *conditionNames = [[UNIVERSE descriptions] oo_arrayForKey:@"condition"];
     463             :         return [conditionNames oo_stringAtIndex:alertCondition];
     464             : }
     465             : 
     466             : 
     467           0 : NSString *OODisplayStringFromShaderSetting(OOShaderSetting setting)
     468             : {
     469             :         switch (setting)
     470             :         {
     471             :                 case SHADERS_NOT_SUPPORTED:     return DESC(@"shaderfx-not-available");
     472             :                 case SHADERS_OFF:                       return DESC(@"shaderfx-off");
     473             :                 case SHADERS_SIMPLE:            return DESC(@"shaderfx-simple");
     474             :                 case SHADERS_FULL:                      return DESC(@"shaderfx-full");
     475             :         }
     476             :         
     477             :         return @"??";
     478             : }
     479             : 
     480             : 
     481           0 : NSString *OOStringFromShaderSetting(OOShaderSetting setting)
     482             : {
     483             :         switch (setting)
     484             :         {
     485             :                 CASE(SHADERS_OFF);
     486             :                 CASE(SHADERS_SIMPLE);
     487             :                 CASE(SHADERS_FULL);
     488             :                 CASE(SHADERS_NOT_SUPPORTED);
     489             :         }
     490             :         
     491             :         return @"UNDEFINED";
     492             : }
     493             : 
     494             : 
     495           0 : OOShaderSetting OOShaderSettingFromString(NSString *string)
     496             : {
     497             :         REVERSE_CASE(SHADERS_OFF);
     498             :         REVERSE_CASE(SHADERS_SIMPLE);
     499             :         REVERSE_CASE(SHADERS_FULL);
     500             :         REVERSE_CASE(SHADERS_NOT_SUPPORTED);
     501             :         
     502             :         return kOOShaderSettingDefault;
     503             : }
     504             : 
     505             : 
     506           0 : NSString *CommodityDisplayNameForSymbolicName(NSString *symbolicName)
     507             : {
     508             :         NSString *ret = [UNIVERSE descriptionForKey:[@"commodity-name " stringByAppendingString:[symbolicName lowercaseString]]];
     509             :         return ret ? ret : symbolicName;
     510             : }
     511             : 
     512             : 
     513           0 : NSString *CommodityDisplayNameForCommodityArray(NSArray *commodityDefinition)
     514             : {
     515             :         return CommodityDisplayNameForSymbolicName([commodityDefinition oo_stringAtIndex:MARKET_NAME]);
     516             : }
     517             : 
     518             : 
     519           0 : NSString *DisplayStringForMassUnit(OOMassUnit unit)
     520             : {
     521             :         switch (unit)
     522             :         {
     523             :                 case UNITS_TONS:  return DESC(@"cargo-tons-symbol");
     524             :                 case UNITS_KILOGRAMS:  return DESC(@"cargo-kilograms-symbol");
     525             :                 case UNITS_GRAMS:  return DESC(@"cargo-grams-symbol");
     526             :         }
     527             :         
     528             :         return @"??";
     529             : }
     530             : 
     531             : 
     532           0 : NSString *DisplayStringForMassUnitForCommodity(OOCommodityType commodity)
     533             : {
     534             :         return DisplayStringForMassUnit([[UNIVERSE commodityMarket] massUnitForGood:commodity]);
     535             : }
     536             : 
     537             : 
     538           0 : OORouteType StringToRouteType(NSString *string)
     539             : {
     540             :         REVERSE_CASE(OPTIMIZED_BY_NONE);
     541             :         REVERSE_CASE(OPTIMIZED_BY_JUMPS);
     542             :         REVERSE_CASE(OPTIMIZED_BY_TIME);
     543             :         
     544             :         return kOORouteTypeDefault;
     545             : }
     546             : 
     547             : 
     548           0 : NSString *DockingClearanceStatusToString(OODockingClearanceStatus dockingClearanceStatus)
     549             : {
     550             :         switch (dockingClearanceStatus)
     551             :         {
     552             :                 CASE(DOCKING_CLEARANCE_STATUS_NONE);
     553             :                 CASE(DOCKING_CLEARANCE_STATUS_REQUESTED);
     554             :                 CASE(DOCKING_CLEARANCE_STATUS_NOT_REQUIRED);
     555             :                 CASE(DOCKING_CLEARANCE_STATUS_GRANTED);
     556             :                 CASE(DOCKING_CLEARANCE_STATUS_TIMING_OUT);
     557             :         }
     558             :         
     559             :         return @"DOCKING_CLEARANCE_STATUS_UNKNOWN";
     560             : }
     561             : 
     562             : 
     563           0 : NSString *OOStringFromGraphicsDetail(OOGraphicsDetail detail)
     564             : {
     565             :         switch (detail)
     566             :         {
     567             :                 CASE(DETAIL_LEVEL_MINIMUM);
     568             :                 CASE(DETAIL_LEVEL_NORMAL);
     569             :                 CASE(DETAIL_LEVEL_SHADERS);
     570             :                 CASE(DETAIL_LEVEL_EXTRAS);
     571             :         }
     572             :         
     573             :         return @"DETAIL_LEVEL_UNKNOWN";
     574             : }
     575             : 
     576             : 
     577           0 : OOGraphicsDetail OOGraphicsDetailFromString(NSString *string)
     578             : {
     579             :         REVERSE_CASE(DETAIL_LEVEL_MINIMUM);
     580             :         REVERSE_CASE(DETAIL_LEVEL_NORMAL);
     581             :         REVERSE_CASE(DETAIL_LEVEL_SHADERS);
     582             :         REVERSE_CASE(DETAIL_LEVEL_EXTRAS);
     583             :         
     584             :         return DETAIL_LEVEL_MINIMUM;
     585             : }

Generated by: LCOV version 1.14