indeksno naslavljanje na F2

ass3/zbirnik/parsing/input.asm

@@ -1,4 +1,5 @@
 arithr START 0 .komentar1
+    SHIFTR A, 10, X
     LDS #11  .komentar2
     LDT #5
     .komentar3

ass3/zbirnik/parsing/input_invalid.asm

@@ -1,4 +1,6 @@
 arithr START 0 .komentar1
+TEST SHIFTR A, 10, X . testing 0
+TEST SVC 10, X . testing
     LDS #11  .komentar2
     LDT #5
     .komentar3

ass3/zbirnik/parsing/pregledovalnik.go

@@ -77,6 +77,8 @@ func (f format_F1) Temp() {}
 func (f format_F2_n) Temp() {}
 func (f format_F2_r) Temp() {}
 func (f format_F2_rn) Temp() {}
+func (f format_F2_rr) Temp() {}
+
 
 var register string = `A|X|L|B|S|T|F`
 
@@ -93,6 +95,7 @@ type format_F2_n struct {
     format int
     velikost int
     n string
+    x bool // indeksno naslavljanje
 }
 
 type format_F2_r struct {
@@ -110,6 +113,7 @@ type format_F2_rn struct {
     velikost int
     r1 string
     n string
+    x bool
 }
 
 type format_F2_rr struct {
@@ -159,7 +163,7 @@ func check_F1(el string, AST *[]ukaz) bool {
 }
 
 func check_F2_n(el string, AST *[]ukaz) bool {
-    match_F2_n, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+SVC ((#?|@?)[0-9]+)[\t ]*(\..*)?$\n`, el)
+    match_F2_n, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+SVC ((#?|@?)[0-9]+)(, X)?[\t ]*(\..*)?$\n`, el)
     if err != nil {
         fmt.Println("Error while matching string.")
     }
@@ -174,9 +178,16 @@ func check_F2_n(el string, AST *[]ukaz) bool {
         } else {
             nov_ukaz.oznaka = ""
         }
-        re_par := regexp.MustCompile(`[\t ]+(#?|@?)[0-9]+`)
+        re_par := regexp.MustCompile(`[\t ]+(#?|@?)[0-9]+,?`)
-        nov_ukaz.n = strings.Trim(re_par.FindString(el), "\t ")
+        temp := strings.Trim(re_par.FindString(el), "\t ")
-        //fmt.Println(nov_ukaz)
+        if temp[len(temp) - 1] == ',' {
+            nov_ukaz.x = true
+            nov_ukaz.n = strings.TrimRight(temp, ",")
+        } else {
+            nov_ukaz.x = false
+            nov_ukaz.n = temp
+        }
+        fmt.Println("F2_n ", el[:len(el) - 1], nov_ukaz)
         *AST = append(*AST, nov_ukaz)
         return true
     }
@@ -210,7 +221,7 @@ func check_F2_r(el string, AST *[]ukaz) bool {
 }
 
 func check_F2_rn(el string, AST *[]ukaz) bool {
-    match_F2_rn, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+[A-Za-z]+ (`+register+`), ((#?|@?)[0-9]+)[\t ]*(\..*)?$\n`, el)
+    match_F2_rn, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+[A-Za-z]+ (`+register+`), ((#?|@?)[0-9]+)(, X)?[\t ]*(\..*)?$\n`, el)
     if err != nil {
         fmt.Println("Error while matching string.")
     }
@@ -228,9 +239,44 @@ func check_F2_rn(el string, AST *[]ukaz) bool {
         nov_ukaz.opcode = ukazna_tabela[strings.Trim(re_op.FindString(el), "\t ")]
         re_par1 := regexp.MustCompile(`[\t ]+[A-Za-z]+ (`+register+`)`)
         nov_ukaz.r1 = strings.Split(strings.Trim(re_par1.FindString(el), "\t \n"), " ")[1]
-        re_par2 := regexp.MustCompile(`(`+register+`), ((#?|@?)[0-9]+)`)
+        re_par2 := regexp.MustCompile(`(`+register+`), ((#?|@?)[0-9]+),?`)
-        nov_ukaz.n = strings.Split(re_par2.FindString(el), " ")[1]
+        temp := strings.Split(re_par2.FindString(el), " ")[1]
-        fmt.Println("F2_rn: ", nov_ukaz)
+        if temp[len(temp) - 1] == ',' {
+            nov_ukaz.x = true
+            nov_ukaz.n = strings.TrimRight(temp, ",")
+        } else {
+            nov_ukaz.x = false
+            nov_ukaz.n = temp
+        }
+        fmt.Println("F2_rn: ", el[:len(el) - 1], nov_ukaz)
+        *AST = append(*AST, nov_ukaz)
+        return true
+    }
+    return false
+}
+
+func check_F2_rr(el string, AST *[]ukaz) bool {
+    match_F2_rr, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+[A-Za-z]+ (`+register+`), (`+register+`)[\t ]*(\..*)?$\n`, el)
+    if err != nil {
+        fmt.Println("Error while matching string.")
+    }
+    if match_F2_rr {
+        var nov_ukaz format_F2_rr
+        nov_ukaz.format = 2
+        nov_ukaz.velikost = 2
+        if !(strings.HasPrefix(el, " ") || strings.HasPrefix(el, "\t")) {
+            re := regexp.MustCompile(`(?m)^[A-Z-a-z_]+`) 
+            nov_ukaz.oznaka = re.FindString(el)   
+        } else {
+            nov_ukaz.oznaka = ""
+        }       
+        re_op := regexp.MustCompile(`[\t ]+[A-Za-z]+`)
+        nov_ukaz.opcode = ukazna_tabela[strings.Trim(re_op.FindString(el), "\t ")]
+        re_par1 := regexp.MustCompile(`[\t ]+[A-Za-z]+ (`+register+`)`)
+        nov_ukaz.r1 = strings.Split(strings.Trim(re_par1.FindString(el), "\t \n"), " ")[1]
+        re_par2 := regexp.MustCompile(`(`+register+`), (`+register+`)`)
+        nov_ukaz.r2 = strings.Split(re_par2.FindString(el), " ")[1]
+        //fmt.Println("F2_rr: ", nov_ukaz)
         *AST = append(*AST, nov_ukaz)
         return true
     }
@@ -240,8 +286,6 @@ func check_F2_rn(el string, AST *[]ukaz) bool {
 // Pregledovalnik bere vhodne vrstice in jih razgradi na posamezne enote.
 // Razpoznane elemente okvalificira (oznaka / mnemonik / operand / komentar) 
 // //<zbirniski stavek> ::== [<oznaka stavka>] <ločilo> <mnemonik> <ločilo> {<operand> <ločilo>} [<komentar>]
-
-//TODO ideja kaj ce bi prvo leve labele razresil/odstranil in potem regex za ukaze
 func main() {
     inputbyte, err := os.ReadFile("input_invalid.asm")
     if err != nil {
@@ -265,10 +309,13 @@ func main() {
             continue
         }
         if check_F2_r(el, &AST) {
-            continue; 
+            continue 
         } 
         if check_F2_rn(el, &AST) {
-            continue; 
+            continue 
+        }    
+        if check_F2_rr(el, &AST) {
+            continue
         }
         //match_F2, err := regexp.MatchString(`(?m)^[A-Za-z_]*[\t ]+[A-Za-z_]+[\t ](((`+register+`), (`+register+`))|((`+register+`), (#?|@?)[0-9]+)|(`+register+`))[\t ]*(\..*)?$\n`, el)
     }

ass3/zbirnik/parsing/test.go

@@ -5,6 +5,10 @@ import (
 )
 
 func main() {
-    i := 0xB4
+    i := "tes,"
-    fmt.Println(i)
+    if i[len(i)-1] == ',' {
+        fmt.Println("hi")
+    } else {
+        fmt.Println("world")
+    }
 }