ruby: slicc: use default argument value

Before this patch, while one could declare / define a function with default
argument values, but the actual function call would require one to specify
all the arguments.  This patch changes the check for  function arguments.
Now a function call needs to specify arguments that are at least as much as
those with default values and at most the total number of arguments taken
as input by the function.

6 files changed, 50 insertions, 21 deletions

diff --git a/src/mem/slicc/ast/EnumDeclAST.py b/src/mem/slicc/ast/EnumDeclAST.py
index d97c13483..bc0c1c224 100644
--- a/src/mem/slicc/ast/EnumDeclAST.py
+++ b/src/mem/slicc/ast/EnumDeclAST.py
@@ -67,6 +67,6 @@ class EnumDeclAST(DeclAST):
         pairs = { "external" : "yes" }
         func = Func(self.symtab, func_id + "_" + t.c_ident,
                     func_id, self.location,
-                    self.symtab.find("std::string", Type), [ t ], [], "",
+                    self.symtab.find("std::string", Type), [ t ], [], [], "",
                     pairs)
         self.symtab.newSymbol(func)
diff --git a/src/mem/slicc/ast/FormalParamAST.py b/src/mem/slicc/ast/FormalParamAST.py
index ce73304f1..ef39b40f0 100644
--- a/src/mem/slicc/ast/FormalParamAST.py
+++ b/src/mem/slicc/ast/FormalParamAST.py
@@ -46,6 +46,9 @@ class FormalParamAST(AST):
     def generate(self):
         type = self.type_ast.type
         param = "param_%s" % self.ident
+        proto = ""
+        body = ""
+        default = False
 
         # Add to symbol table
         v = Var(self.symtab, self.ident, self.location, type, param,
@@ -56,6 +59,21 @@ class FormalParamAST(AST):
            "interface" in type and (
                type["interface"] == "AbstractCacheEntry" or
                type["interface"] == "AbstractEntry")):
-            return type, "%s* %s" % (type.c_ident, param)
+            proto = "%s* %s" % (type.c_ident, param)
+            body = proto
+        elif self.default != None:
+            value = ""
+            if self.default == True:
+                value = "true"
+            elif self.default == False:
+                value = "false"
+            else:
+                value = "%s" % self.default
+            proto = "const %s& %s = %s" % (type.c_ident, param, value)
+            body = "const %s& %s" % (type.c_ident, param)
+            default = True
         else:
-            return type, "const %s& %s" % (type.c_ident, param)
+            proto = "const %s& %s" % (type.c_ident, param)
+            body = proto
+
+        return type, proto, body, default
diff --git a/src/mem/slicc/ast/FuncDeclAST.py b/src/mem/slicc/ast/FuncDeclAST.py
index 47ae7076e..4e64c0ba5 100644
--- a/src/mem/slicc/ast/FuncDeclAST.py
+++ b/src/mem/slicc/ast/FuncDeclAST.py
@@ -45,7 +45,9 @@ class FuncDeclAST(DeclAST):
 
     def generate(self, parent = None):
         types = []
-        params = []
+        proto_params = []
+        body_params = []
+        default_count = 0
         void_type = self.symtab.find("void", Type)
 
         # Generate definition code
@@ -58,13 +60,17 @@ class FuncDeclAST(DeclAST):
         for formal in self.formals:
             # Lookup parameter types
             try:
-                type, ident = formal.generate()
+                type, proto, body, default = formal.generate()
                 types.append(type)
-                params.append(ident)
+                proto_params.append(proto)
+                body_params.append(body)
+                if default:
+                    default_count += 1
 
             except AttributeError:
                 types.append(formal.type)
-                params.append(None)
+                proto_params.append(None)
+                body_params.append(None)
 
         body = self.slicc.codeFormatter()
         if self.statements is None:
@@ -87,7 +93,8 @@ class FuncDeclAST(DeclAST):
 
         machine = self.state_machine
         func = Func(self.symtab, func_name_args, self.ident, self.location,
-                    return_type, types, params, str(body), self.pairs)
+                    return_type, types, proto_params,
+                    body_params, str(body), self.pairs, default_count)
 
         if parent is not None:
             if not parent.addFunc(func):
diff --git a/src/mem/slicc/ast/InPortDeclAST.py b/src/mem/slicc/ast/InPortDeclAST.py
index 7a019a0e0..2ef043151 100644
--- a/src/mem/slicc/ast/InPortDeclAST.py
+++ b/src/mem/slicc/ast/InPortDeclAST.py
@@ -89,13 +89,13 @@ class InPortDeclAST(DeclAST):
         for param in param_types:
             trigger_func_name += "_" + param.ident
         func = Func(self.symtab, trigger_func_name, "trigger", self.location,
-                    void_type, param_types, [], "", pairs)
+                    void_type, param_types, [], [], "", pairs)
         symtab.newSymbol(func)
 
         # Add the stallPort method - this hacks reschedules the controller
         # for stalled messages that don't trigger events
         func = Func(self.symtab, "stallPort", "stallPort", self.location,
-                    void_type, [], [], "", pairs)
+                    void_type, [], [], [], "", pairs)
         symtab.newSymbol(func)
 
         param_types = []
diff --git a/src/mem/slicc/ast/StateDeclAST.py b/src/mem/slicc/ast/StateDeclAST.py
index f0a0b97d3..a33ea9245 100644
--- a/src/mem/slicc/ast/StateDeclAST.py
+++ b/src/mem/slicc/ast/StateDeclAST.py
@@ -66,7 +66,7 @@ class StateDeclAST(DeclAST):
         pairs = { "external" : "yes" }
         func = Func(self.symtab, func_id + "_" +
                     t.ident, func_id, self.location,
-                    self.symtab.find("std::string", Type), [ t ], [], "",
+                    self.symtab.find("std::string", Type), [ t ], [], [], "",
                     pairs)
         self.symtab.newSymbol(func)
 
@@ -76,6 +76,6 @@ class StateDeclAST(DeclAST):
         pairs = { "external" : "yes" }
         func = Func(self.symtab, func_id + "_" +
                     t.ident, func_id, self.location,
-                    self.symtab.find("AccessPermission", Type), [ t ], [], "",
+                    self.symtab.find("AccessPermission", Type), [ t ], [], [], "",
                     pairs)
         self.symtab.newSymbol(func)
diff --git a/src/mem/slicc/symbols/Func.py b/src/mem/slicc/symbols/Func.py
index 6da74002a..695450b9c 100644
--- a/src/mem/slicc/symbols/Func.py
+++ b/src/mem/slicc/symbols/Func.py
@@ -30,16 +30,19 @@ from slicc.symbols.Type import Type
 
 class Func(Symbol):
     def __init__(self, table, ident, name, location, return_type, param_types,
-                 param_strings, body, pairs):
+                 proto_param_strings, body_param_strings, body,
+                 pairs, default_count = 0):
         super(Func, self).__init__(table, ident, location, pairs)
         self.return_type = return_type
         self.param_types = param_types
-        self.param_strings = param_strings
+        self.proto_param_strings = proto_param_strings
+        self.body_param_strings = body_param_strings
         self.body = body
         self.isInternalMachineFunc = False
         self.c_ident = ident
         self.c_name = name
         self.class_name = ""
+        self.default_count = default_count
 
     def __repr__(self):
         return ""
@@ -57,16 +60,17 @@ class Func(Symbol):
             return_type += "*"
 
         return "%s %s(%s);" % (return_type, self.c_name,
-                               ", ".join(self.param_strings))
+                               ", ".join(self.proto_param_strings))
 
     def writeCodeFiles(self, path, includes):
         return
 
     def checkArguments(self, args):
-        if len(args) != len(self.param_types):
-            self.error("Wrong number of arguments passed to function : '%s'" +\
-                       " Expected %d, got %d", self.c_ident,
-                       len(self.param_types), len(args))
+        if len(args) + self.default_count < len(self.param_types) or \
+           len(args) > len(self.param_types):
+            self.error("Wrong number of arguments passed to function: '%s'" + \
+                       " Expected at least: %d, got: %d", self.c_ident,
+                       len(self.param_types) - self.default_count, len(args))
 
         cvec = []
         type_vec = []
@@ -91,14 +95,14 @@ class Func(Symbol):
         code = self.symtab.codeFormatter()
 
         # Generate function header
-        void_type = self.symtab.find("void", Type)
         return_type = self.return_type.c_ident
+        void_type = self.symtab.find("void", Type)
         if "return_by_ref" in self and self.return_type != void_type:
             return_type += "&"
         if "return_by_pointer" in self and self.return_type != void_type:
             return_type += "*"
 
-        params = ', '.join(self.param_strings)
+        params = ', '.join(self.body_param_strings)
 
         code('''
 $return_type