Add checking of number of parameters of PROC/EXEC to the cross-compiler.

Author: dmsc

src/basic.syn

@@ -95,6 +95,8 @@ EXTERN {
 
 #@if EXTENDED
  E_DATA_FILE
+ E_COUNT_PARAM
+ E_PROC_CHECK
 #@endif
 
 #@if FASTBASIC_FP
@@ -635,12 +637,23 @@ OPT_EXEC_PARAM:
         pass
 
 EXEC_PARAM_MORE:
+#@if EXTENDED
+        # In the cross-compiler, we count parameters to detect program errors
+        E_COUNT_PARAM
+#@endif
         C_EXPR EXEC_PARAM_MORE
         pass
 
 # Optional variable in PROC
 OPT_PROC_VAR:
+#@if EXTENDED
+        # In the cross-compiler, we count parameters to detect program errors
+        E_COUNT_PARAM
+#@endif
         VAR_WORD_SAVE OPT_PROC_VAR emit { TOK_POP, TOK_VAR_STORE } E_POP_VAR
+#@if EXTENDED
+        E_PROC_CHECK
+#@endif
         pass
 
 # Parse a line

src/compiler/parser.cc

@@ -575,7 +575,6 @@ bool SMB_E_NUMBER_FP(parse &s)
 
 #endif
 
-static std::string last_label_name;
 bool SMB_E_LABEL_DEF(parse &s)
 {
     s.debug("E_LABEL_DEF");
@@ -584,10 +583,11 @@ bool SMB_E_LABEL_DEF(parse &s)
     if( !s.get_ident(name) )
         return false;
     if( v.find(name) == v.end() )
-        v[name] = VT_UNDEF;
-    if( v[name] != VT_UNDEF )
+        v[name] = labelType();
+    if( v[name].is_defined() )
         return false;
-    last_label_name = name;
+    s.last_label = name;
+    s.current_params = 0;
     s.add_text(name);
     s.emit_label("fb_lbl_" + name);
     return true;
@@ -597,61 +597,81 @@ bool SMB_E_LABEL(parse &s)
 {
     s.debug("E_LABEL");
     // Get type
-    enum VarType type = get_vartype(s.remove_last().get_str());
-    auto &v = s.labels;
+    auto ltype = labelType(s.remove_last().get_str());
+    // Get identifier
     std::string name;
     if( !s.get_ident(name) )
         return false;
-    if( v.find(name) == v.end() )
+    auto it = s.labels.find(name);
+    if( it == s.labels.end() )
         return false;
     // Check type
-    if( v[name] != type )
+    if( it->second != ltype )
         return false;
     s.add_text(name);
     s.emit_word("fb_lbl_" + name);
     return true;
 }
 
+bool SMB_E_COUNT_PARAM(parse &s)
+{
+    s.debug("E_COUNT_PARAM");
+    s.current_params ++;
+    return false;
+}
+
 // Called in EXEC, creates a label if not exists, if already exists checks
 // that it is a PROC.
 bool SMB_E_LABEL_CREATE(parse &s)
 {
     s.debug("E_LABEL_CREATE");
-    // Get type
-    auto &v = s.labels;
     std::string name;
     if( !s.get_ident(name) )
         return false;
-    // Create if not exists
-    if( v.find(name) == v.end() )
-        v[name] = VT_UNDEF;
+    // Get type, create if not exists
+    auto &v = s.labels[name];
     // Check type
-    if( v[name] != VT_UNDEF )
+    if( !v.is_proc() )
         return false;
     // Store variable name
     s.add_text(name);
     s.last_label = name;
+    s.current_params = 0;
     return true;
 }
 
 bool SMB_E_DO_EXEC(parse &s)
 {
+    int pnum = s.current_params;
     s.debug("E_DO_EXEC");
+    auto &l = s.labels[s.last_label];
+    if( !l.add_proc_params(pnum) )
+        throw parse_error("invalid number of parameters in EXEC, expected " +
+                std::to_string(l.num_params()) + ", got "
+                + std::to_string(pnum) , s.pos);
     s.emit_word("fb_lbl_" + s.last_label);
     return true;
 }
 
+bool SMB_E_PROC_CHECK(parse &s)
+{
+    int pnum = s.current_params - 1;
+    s.debug("E_PROC_CHECK");
+    auto &l = s.labels[s.last_label];
+    if( !l.add_proc_params(pnum) )
+        throw parse_error("invalid number of parameters in PROC, expected " +
+                std::to_string(l.num_params()) + ", got "
+                + std::to_string(pnum) , s.pos);
+    l.define();
+    return true;
+}
+
 bool SMB_E_LABEL_SET_TYPE(parse &s)
 {
     s.debug("E_LABEL_SET_TYPE");
-
     s.skipws();
     // Get type
-    enum VarType type = get_vartype(s.remove_last().get_str());
-    auto &v = s.labels;
-    if( do_debug )
-        std::cout << "\tset label '" << last_label_name << "' to " << int(type) << "\n";
-    v[last_label_name] = (v[last_label_name] & ~0xFF) + type;
+    s.labels[s.last_label] = labelType(s.remove_last().get_str());
     return true;
 }
 

src/compiler/parser.h

@@ -22,6 +22,7 @@
 
 #include "codew.h"
 #include "looptype.h"
+#include "vartype.h"
 
 #include <algorithm>
 #include <map>
@@ -68,12 +69,13 @@ class parse {
         std::map<std::string, std::vector<codew>> procs;
         std::vector<std::string> proc_stack;
         std::map<std::string, int> vars;
-        std::map<std::string, int> labels;
+        std::map<std::string, labelType> labels;
         std::vector<jump> jumps;
         int label_num;
         bool finalized;
         std::vector<codew> *code;
-        std::string last_label;
+        std::string last_label; // Last label to be referenced in an EXEC
+        int current_params;     // Number of parameters in PROC/EXEC being parsed
         // Used to store an un-abbreviated line
         struct expand_line {
             std::string text;

src/compiler/vartype.cc

@@ -19,6 +19,7 @@
 // vartype.cc: Defines types of variables
 
 #include "vartype.h"
+#include <stdexcept>
 
 VarType get_vartype(std::string t)
 {
@@ -82,3 +83,42 @@ bool var_type_is_array(enum VarType t)
     return false;
 }
 
+labelType::labelType(): type(0) {}
+
+labelType::labelType(std::string str)
+{
+    if( str == "VT_ARRAY_WORD" )
+        type = 128;
+    else if( str == "VT_ARRAY_BYTE" )
+        type = 129;
+    else
+        throw std::runtime_error("invalid label type " + str);
+}
+
+bool labelType::is_defined()
+{
+    return type >= 64;
+}
+
+bool labelType::is_proc()
+{
+    return type < 128;
+}
+
+bool labelType::add_proc_params(int params)
+{
+    if( !type )
+        type = params + 1;
+
+    return num_params() == params;
+}
+
+int labelType::num_params()
+{
+    return (type & 63) - 1;
+}
+
+void labelType::define()
+{
+    type |= 64;
+}

src/compiler/vartype.h

@@ -21,6 +21,7 @@
 #pragma once
 #include <string>
 
+// Variable types
 enum VarType {
         VT_UNDEF = 0,
         VT_WORD,
@@ -36,3 +37,21 @@ VarType get_vartype(std::string t);
 std::string get_vt_name(enum VarType t);
 bool var_type_is_array(enum VarType t);
 
+// Label types
+class labelType {
+    public:
+        // Create from string in parser file
+        labelType(std::string t);
+        labelType();
+        bool is_defined();
+        bool is_proc();
+        bool add_proc_params(int params);
+        int  num_params();
+        void define();
+        bool operator !=(const labelType &l) const { return type != l.type; }
+    private:
+        int type;
+};
+
+
+