Add for and for each loop

Author: some100

docs/assets/for.png

@@ -20,6 +20,26 @@ until condition == true {
 
 ![](../assets/until.png){width="200"}
 
+## for each loop
+
+```goboscript
+for x in n {
+    # code
+}
+```
+
+![](../assets/foreach.png){width="200"}
+
+## for loop
+
+```goboscript
+for x = 0; x > n; x++ {
+    # code
+}
+```
+
+![](../assets/for.png){width="100"}
+
 ## forever loop
 
 ```goboscript

docs/assets/foreach.png

@@ -31,7 +31,7 @@ patterns:
   - name: keyword
     match: "\\b(costumes|sounds|global|list|nowarp|onflag|onkey|onbackdrop|onloudness|ontimer|on|onclone)\\b"
   - name: keyword.control
-    match: "\\b(if|else|elif|until|forever|repeat|delete|at|add|to|insert|true|false|as|struct|enum|return)\\b"
+    match: "\\b(if|else|elif|until|for|forever|repeat|delete|at|add|to|insert|true|false|as|struct|enum|return)\\b"
   - name: keyword
     match: "\\b(error|warn|breakpoint|local|not|and|or|in|length|round|abs|floor|ceil|sqrt|sin|cos|tan|asin|acos|atan|ln|log|antiln|antilog)\\b"
   - name: support.function.builtin

docs/language/control-flow.md

@@ -24,7 +24,7 @@
             <Keywords name="Folders in comment, open"></Keywords>
             <Keywords name="Folders in comment, middle"></Keywords>
             <Keywords name="Folders in comment, close"></Keywords>
-            <Keywords name="Keywords1">costumes sounds local proc func return nowarp if else elif until forever repeat list cloud struct enum</Keywords>
+            <Keywords name="Keywords1">costumes sounds local proc func return nowarp if else elif until for forever repeat list cloud struct enum</Keywords>
             <Keywords name="Keywords2">%define&#x000D;&#x000A;%if&#x000D;&#x000A;%else&#x000D;&#x000A;%endif&#x000D;&#x000A;%include&#x000D;&#x000A;%undef</Keywords>
             <Keywords name="Keywords3">true false</Keywords>
             <Keywords name="Keywords4">$</Keywords>

editors/code/syntaxes/goboscript.tmGrammar.yml

@@ -22,7 +22,7 @@ contexts:
       match: "\\b(costumes|sounds|global|variables|lists|nowarp|onflag|onkey|onbackdrop|onloudness|ontimer|on|onclone)\\b"
 
     - scope: keyword.control
-      match: "\\b(if|else|elif|until|forever|repeat|delete|at|add|to|insert)\\b"
+      match: "\\b(if|else|elif|until|for|forever|repeat|delete|at|add|to|insert)\\b"
 
     - scope: keyword
       match: "\\b(error|warn|breakpoint|local|not|and|or|in|length|round|abs|floor|ceil|sqrt|sin|cos|tan|asin|acos|atan|ln|log|antiln|antilog)\\b"

editors/notepad++/goboscript.udl.xml

@@ -20,6 +20,19 @@ pub enum Stmt {
         times: Box<Expr>,
         body: Vec<Stmt>,
     },
+    ForEach {
+        name: Name,
+        times: Box<Expr>,
+        body: Vec<Stmt>,
+    },
+    For {
+        name: Name,
+        value: Box<Expr>,
+        type_: Type,
+        cond: Box<Expr>,
+        incr: Box<Stmt>,
+        body: Vec<Stmt>,
+    },
     Forever {
         body: Vec<Stmt>,
         span: Span,

editors/sublime/goboscript.sublime-syntax

@@ -224,6 +224,8 @@ impl Stmt {
     fn opcode(&self, s: S) -> &'static str {
         match self {
             Stmt::Repeat { .. } => "control_repeat",
+            Stmt::ForEach { .. } => "control_for_each",
+            Stmt::For { .. } => "control_repeat_until",
             Stmt::Forever { .. } => "control_forever",
             Stmt::Branch { else_body, .. } => {
                 if else_body.is_empty() {
@@ -965,18 +967,20 @@ where T: Write + Seek
         self.stmts(s, d, &event.body, next_id, Some(this_id))
     }
 
-    pub fn stmts(
+    pub fn stmts_with_next(
         &mut self,
         s: S,
         d: D,
         stmts: &[Stmt],
         mut this_id: NodeID,
+        last_id: Option<NodeID>,
         mut parent_id: Option<NodeID>,
     ) -> io::Result<()> {
         for (i, stmt) in stmts.iter().enumerate() {
             let is_last = i == stmts.len() - 1;
             if is_last || stmt.is_terminator() {
-                self.stmt(s, d, stmt, this_id, None, parent_id)?;
+                let next_id = last_id;
+                self.stmt(s, d, stmt, this_id, next_id, parent_id)?;
                 if !is_last {
                     d.report(DiagnosticKind::FollowedByUnreachableCode, stmt.span());
                 }
@@ -990,6 +994,17 @@ where T: Write + Seek
         Ok(())
     }
 
+    pub fn stmts(
+        &mut self,
+        s: S,
+        d: D,
+        stmts: &[Stmt],
+        this_id: NodeID,
+        parent_id: Option<NodeID>,
+    ) -> io::Result<()> {
+        self.stmts_with_next(s, d, stmts, this_id, None, parent_id)
+    }
+
     pub fn stmt(
         &mut self,
         s: S,
@@ -1006,6 +1021,13 @@ where T: Write + Seek
         )?;
         match stmt {
             Stmt::Repeat { times, body } => self.repeat(s, d, this_id, times, body),
+            Stmt::ForEach { name, times, body } => self.foreach(s, d, this_id, name, times, body),
+            Stmt::For {
+                cond,
+                incr,
+                body,
+                ..
+            } => self.r#for(s, d, this_id, cond, incr, body),
             Stmt::Forever { body, span } => self.forever(s, d, this_id, body, span),
             Stmt::Branch {
                 cond,

src/ast/stmt.rs

@@ -55,6 +55,60 @@ where T: Write + Seek
         self.stmts(s, d, body, body_id, Some(this_id))
     }
 
+    pub fn foreach(
+        &mut self,
+        s: S,
+        d: D,
+        this_id: NodeID,
+        name: &Name,
+        times: &Expr,
+        body: &[Stmt],
+    ) -> io::Result<()> {
+        let times_id = self.id.new_id();
+        let body_id = self.id.new_id();
+        self.begin_inputs()?;
+        self.input(s, d, "VALUE", times, times_id)?;
+        self.substack("SUBSTACK", (!body.is_empty()).then_some(body_id))?;
+        self.end_obj()?; // inputs
+        match s.qualify_name(d, name) {
+            Some(QualifiedName::Var(qualified_name, _)) => {
+                self.single_field_id("VARIABLE", &qualified_name)?
+            }
+            Some(QualifiedName::List(..)) => {
+                d.report(
+                    DiagnosticKind::UnrecognizedVariable(name.basename().clone()),
+                    &name.span(),
+                );
+            }
+            None => {}
+        }
+        self.end_obj()?; // node
+        self.expr(s, d, times, times_id, this_id)?;
+        self.stmts(s, d, body, body_id, Some(this_id))
+    }
+
+    pub fn r#for(
+        &mut self,
+        s: S,
+        d: D,
+        this_id: NodeID,
+        cond: &Expr,
+        incr: &Stmt,
+        body: &[Stmt],
+    ) -> io::Result<()> {
+        let cond_id = self.id.new_id();
+        let incr_id = self.id.new_id();
+        let body_id = self.id.new_id();
+        self.begin_inputs()?;
+        self.input(s, d, "CONDITION", cond, cond_id)?;
+        self.substack("SUBSTACK", Some((!body.is_empty()).then_some(body_id).unwrap_or(incr_id)))?;
+        self.end_obj()?; // inputs
+        self.end_obj()?; // node
+        self.expr(s, d, cond, cond_id, this_id)?;
+        self.stmts_with_next(s, d, body, body_id, Some(incr_id), Some(this_id))?;
+        self.stmt(s, d, incr, incr_id, None, Some(body_id))
+    }
+
     pub fn forever(
         &mut self,
         s: S,

src/codegen/sb3.rs

@@ -71,6 +71,8 @@ pub enum Token {
     Elif,
     #[token("until")]
     Until,
+    #[token("for")]
+    For,
     #[token("forever")]
     Forever,
     #[token("repeat")]