tcl: add SPDX tag

[openocd.git] / tcl / tools / memtest.tcl

diff --git a/tcl/tools/memtest.tcl b/tcl/tools/memtest.tcl
index 02f94d30780ec70bb11933dc799fbdf0367cfdf3..f70f950d73e8be6c58927f45681a256883c11ac5 100644 (file)
--- a/tcl/tools/memtest.tcl
+++ b/tcl/tools/memtest.tcl
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
 # Algorithms by Michael Barr, released into public domain
 # Ported to OpenOCD by Shane Volpe, additional fixes by Paul Fertser
 
@@ -74,7 +76,7 @@ proc memTestDataBus { address } {
 # *
 #***********************************************************************************
 proc memTestAddressBus { baseAddress nBytes } {
-    set addressMask [expr $nBytes - 1]
+    set addressMask [expr {$nBytes - 1}]
     set pattern 0xAAAAAAAA
     set antipattern 0x55555555
 
@@ -83,16 +85,16 @@ proc memTestAddressBus { baseAddress nBytes } {
     echo "addressMask: [convertToHex $addressMask]"
 
     echo "memTestAddressBus: Writing the default pattern at each of the power-of-two offsets..."
-    for {set offset 32} {[expr $offset & $addressMask] != 0} {set offset [expr $offset << 1] } {
-       set addr [expr $baseAddress + $offset]
+    for {set offset 32} {[expr {$offset & $addressMask}] != 0} {set offset [expr {$offset << 1}] } {
+       set addr [expr {$baseAddress + $offset}]
        memwrite32 $addr $pattern
     }
 
     echo "memTestAddressBus: Checking for address bits stuck high..."
     memwrite32 $baseAddress $antipattern
 
-    for {set offset 32} {[expr $offset & $addressMask] != 0} {set offset [expr $offset << 1]} {
-       set addr [expr $baseAddress + $offset]
+    for {set offset 32} {[expr {$offset & $addressMask}] != 0} {set offset [expr {$offset << 1}]} {
+       set addr [expr {$baseAddress + $offset}]
        set data [memread32 $addr]
 
        if {$data != $pattern} {
@@ -103,8 +105,8 @@ proc memTestAddressBus { baseAddress nBytes } {
 
     echo "memTestAddressBus: Checking for address bits stuck low or shorted..."
     memwrite32 $baseAddress $pattern
-    for {set testOffset 32} {[expr $testOffset & $addressMask] != 0} {set testOffset [expr $testOffset << 1] } {
-       set addr [expr $baseAddress + $testOffset]
+    for {set testOffset 32} {[expr {$testOffset & $addressMask}] != 0} {set testOffset [expr {$testOffset << 1}] } {
+       set addr [expr {$baseAddress + $testOffset}]
        memwrite32 $addr $antipattern
 
        set data [memread32 $baseAddress]
@@ -113,8 +115,8 @@ proc memTestAddressBus { baseAddress nBytes } {
            return $pattern
        }
 
-       for {set offset 32} {[expr $offset & $addressMask] != 0} {set offset [expr $offset << 1]} {
-           set addr [expr $baseAddress + $offset]
+       for {set offset 32} {[expr {$offset & $addressMask}] != 0} {set offset [expr {$offset << 1}]} {
+           set addr [expr {$baseAddress + $offset}]
            set data [memread32 $baseAddress]
 
             if {(($data != $pattern) && ($offset != $testOffset))} {
@@ -122,7 +124,7 @@ proc memTestAddressBus { baseAddress nBytes } {
                return $pattern
            }
         }
-       set addr [expr $baseAddress + $testOffset]
+       set addr [expr {$baseAddress + $testOffset}]
        memwrite32 $addr $pattern
     }
 }
@@ -153,12 +155,12 @@ proc memTestDevice { baseAddress nBytes } {
 
     echo "memTestDevice: Filling memory with a known pattern..."
     for {set pattern 1; set offset 0} {$offset < $nBytes} {incr pattern; incr offset 32} {
-       memwrite32 [expr $baseAddress + $offset] $pattern
+       memwrite32 [expr {$baseAddress + $offset}] $pattern
     }
 
     echo "memTestDevice: Checking each location and inverting it for the second pass..."
     for {set pattern 1; set offset 0} {$offset < $nBytes} {incr pattern; incr offset 32} {
-       set addr [expr $baseAddress + $offset]
+       set addr [expr {$baseAddress + $offset}]
        set data [memread32 $addr]
 
        if {$data != $pattern} {
@@ -166,18 +168,18 @@ proc memTestDevice { baseAddress nBytes } {
            return $pattern
        }
 
-       set antiPattern [expr ~$pattern]
-       memwrite32 [expr $baseAddress + $offset] $antiPattern
+       set antiPattern [expr {~$pattern}]
+       memwrite32 [expr {$baseAddress + $offset}] $antiPattern
     }
 
     echo "memTestDevice: Checking each location for the inverted pattern and zeroing it..."
     for {set pattern 1; set offset 0} {$offset < $nBytes} {incr pattern; incr offset 32} {
-       set antiPattern [expr ~$pattern & ((1<<32) - 1)]
-       set addr [expr $baseAddress + $offset]
+       set antiPattern [expr {~$pattern & ((1<<32) - 1)}]
+       set addr [expr {$baseAddress + $offset}]
        set data [memread32 $addr]
        set dataHex [convertToHex $data]
        set antiPatternHex [convertToHex $antiPattern]
-       if {[expr $dataHex != $antiPatternHex]} {
+       if {$dataHex != $antiPatternHex} {
            echo "FAILED memTestDevice_antipattern: Address: [convertToHex $addr], antiPattern: $antiPatternHex, Returned: $dataHex, offset: $offset"
            return $pattern
        }