Change #2877: Make engine_override(), deactiavate() and import_sound() accept grfids as strings only.

Author: Hirundo

docs/nml-language.html

@@ -1048,6 +1048,13 @@ <h2><a name="block-disable_item">Disable items</a></h2>
 </pre>
 
 <h2><a name="block-deactivate">Deactivate other NewGRFs</a></h2>
+<pre class="exl">
+deactivate(&lt;grfID&gt;[[, &lt;grfID2&gt;], ...]);
+</pre>
+<p>With this statement, you can deactivate other NewGRFs. As parameters, you
+can supply any number of grfids (4-byte strings) to deactivate. Note that using
+this feature to block incompatible grfs is highly discouraged. Instead, disable
+your own grf with an error message via the <code>error()</code> statement.</p>
 
 <h2><a name="block-othergrf">Testing for other NewGRFs</a></h2>
 See the <a href="nml-language.html#builtin-functions">builtin functions</a> for the functions grf_XXX.
@@ -1076,7 +1083,7 @@ <h2><a name="block-override-grf">Overriding vehicles from other NewGRFs</a></h2>
 </pre>
 The targetID must be the grfID of the NewGRF whose vehicles are supposed to be changed via the engine override.
 The sourceID is the grfID of the NewGRF defining the overriding vehicles. If not set explicitly, the grfID of
-the NewGRF containing this statement is used.
+the NewGRF containing this statement is used. Both grfIDs are 4-byte strings.
 </p>
 <h2><a name="block-replacement">Sprite replacement</a></h2>
 <p>This section covers the three available methods to replace sprites.

nml/actions/action0.py

@@ -465,8 +465,8 @@ def get_disable_actions(disable):
 
 class EngineOverrideProp(object):
     def __init__(self, source, target):
-        self.source = actionE.bswap32(source.value)
-        self.target = actionE.bswap32(target.value)
+        self.source = source
+        self.target = target
 
     def write(self, file):
         file.print_bytex(0x11)
@@ -478,11 +478,9 @@ def get_size(self):
         return 9
 
 def get_engine_override_action(override):
-    source = override.source_grfid.reduce_constant()
-    target = override.grfid.reduce_constant()
     act0 = Action0(0x08, 0)
     act0.num_ids = 1
-    act0.prop_list.append(EngineOverrideProp(source, target))
+    act0.prop_list.append(EngineOverrideProp(override.source_grfid, override.grfid))
     return [act0]
 
 def get_callback_flags_actions(feature, id, flags):

nml/actions/actionE.py

@@ -3,7 +3,7 @@
 
 class ActionE(base_action.BaseAction):
     def __init__(self, grfid_list):
-        self.grfid_list = [bswap32(grfid.value) for grfid in grfid_list]
+        self.grfid_list = grfid_list
 
     def write(self, file):
         size = 2 + 4 * len(self.grfid_list)
@@ -16,34 +16,6 @@ def write(self, file):
         file.newline()
         file.end_sprite()
 
-def bswap32(value):
-    return ((value & 0xFF) << 24) | ((value & 0xFF00) << 8) | ((value & 0xFF0000) >> 8) | ((value & 0xFF000000) >> 24)
-
 def parse_deactivate_block(block):
-    action6.free_parameters.save()
-    grfid_list = []
-    action_list = []
-    act6 = action6.Action6()
-    offset = 2
-    for grfid in block.grfid_list:
-        if isinstance(grfid, expression.ConstantNumeric):
-            grfid_list.append(grfid)
-        else:
-            tmp_param, tmp_param_actions = actionD.get_tmp_parameter(grfid)
-            action_list.extend(tmp_param_actions)
-            for i in range(0, 4):
-                if i == 0:
-                    param = tmp_param
-                else:
-                    param = action6.free_parameters.pop()
-                    action_list.append(actionD.ActionD(expression.ConstantNumeric(param), expression.ConstantNumeric(tmp_param),
-                            nmlop.SHIFTU_LEFT, expression.ConstantNumeric(0xFF), expression.ConstantNumeric(-8 * i)))
-                act6.modify_bytes(param, 1, offset + 3 - i)
-            grfid_list.append(expression.ConstantNumeric(0))
-        offset += 4
-
-    if len(act6.modifications) != 0: action_list.append(act6)
-    action_list.append(ActionE(grfid_list))
+    return [ActionE(block.grfid_list)]
 
-    action6.free_parameters.restore()
-    return action_list

nml/ast/deactivate.py

@@ -1,13 +1,15 @@
 from nml.actions import actionE
 from nml.ast import base_statement
+from nml import expression
 
 class DeactivateBlock(base_statement.BaseStatement):
     def __init__(self, grfid_list, pos):
         base_statement.BaseStatement.__init__(self, "deactivate()", pos)
         self.grfid_list = grfid_list
 
     def pre_process(self):
-        self.grfid_list = [grfid.reduce() for grfid in self.grfid_list]
+        # Parse (string-)expressions to integers
+        self.grfid_list = [expression.parse_string_to_dword(grfid.reduce()) for grfid in self.grfid_list]
 
     def debug_print(self, indentation):
         print indentation*' ' + 'Deactivate other newgrfs:'

nml/ast/override.py

@@ -7,10 +7,10 @@ class EngineOverride(base_statement.BaseStatement):
     AST Node for an engine override.
 
     @ivar grfid: GRFid of the grf to override the engines from.
-    @type grfid: L{Expression}
+    @type grfid: C{int{
 
     @ivar source_grfid: GRFid of the grf that overrides the engines.
-    @type source_grfid: L{Expression} or C{None}
+    @type source_grfid: C{int}
     """
     def __init__(self, args, pos):
         base_statement.BaseStatement.__init__(self, "engine_override()", pos)
@@ -21,16 +21,15 @@ def pre_process(self):
             raise generic.ScriptError("engine_override expects 1 or 2 parameters", self.pos)
 
         if len(self.args) == 1:
-            source = expression.Identifier('GRFID')
+            try:
+                self.source_grfid = expression.Identifier('GRFID').reduce(global_constants.const_list).value
+                assert isinstance(self.source_grfid, int)
+            except generic.ScriptError:
+                raise generic.ScriptError("GRFID of this grf is required, but no grf-block is defined.", self.pos)
         else:
-            source = self.args[0]
-        self.source_grfid = source.reduce(global_constants.const_list)
-        if isinstance(self.source_grfid, expression.StringLiteral):
-            self.source_grfid = expression.ConstantNumeric(expression.parse_string_to_dword(self.source_grfid))
-
-        self.grfid = self.args[-1].reduce(global_constants.const_list)
-        if isinstance(self.grfid, expression.StringLiteral):
-            self.grfid = expression.ConstantNumeric(expression.parse_string_to_dword(self.grfid))
+            self.source_grfid = expression.parse_string_to_dword(self.args[0].reduce(global_constants.const_list))
+
+        self.grfid = expression.parse_string_to_dword(self.args[-1].reduce(global_constants.const_list))
 
     def debug_print(self, indentation):
         print indentation*' ' + 'Engine override'

nml/expression/functioncall.py

@@ -402,11 +402,7 @@ def builtin_sound_file(name, args, pos):
 def builtin_sound_import(name, args, pos):
     if len(args) != 2:
         raise generic.ScriptError(name + "() must have 2 parameter", pos)
-    grfid = args[0].reduce()
-    if isinstance(grfid, ConstantNumeric):
-        grfid = grfid.value
-    else:
-        grfid = parse_string_to_dword(grfid)
+    grfid = parse_string_to_dword(args[0].reduce())
     sound_num = args[1].reduce_constant().value
     return ConstantNumeric(action11.add_sound((grfid, sound_num)), pos)
 #}

regression/002_sounds.nml

@@ -1,2 +1,2 @@
 param[0] = sound("beef.wav");
-param[1] = import_sound(0x87654321, 3);
+param[1] = import_sound("\12\34\56\78", 3);

regression/004_deactivate.nml

@@ -1,7 +1,7 @@
 /*
 Test deactivate(grfids...), which deactivates other grfs
 The nfo / grf equivalent of this is ActionE
-Note that grfs are in big-endian, therefore byte-swapping is required
-If the grfid is not a compile-time constant, this is done at runtime.
 */
-deactivate(0x12345678, param[0]);
+deactivate("ABCD");
+deactivate("\01\02\03\04", "EFGH");
+

regression/023_engine_override.nml

@@ -10,4 +10,4 @@ grf {
 engine_override("test", "ABCD");
 
 // also override some other grf, this time not setting our own grfid explicitly
-engine_override(0x12345678);
+engine_override("\12\34\56\78");