Dim STRING mydata

mydata(1) = 1234    ' force an integer into the first 8 bytes/chars of string
mydata(9) = 2 * PI  ' force a float into next 8 bytes of string
mydata(17) = SQR(2) ' 8 more bytes for another float
mydata(25) = "Useful math constants" ' add a string starting from the 25th posn

CONST root2 = 17
diagonal = side * mydata(root2)

diagonal = side * mydata.root2

CONST title = 25
mydata$.title,32 = "Useful math constants"   ' max 32 characters fit here

Sub MM.Prompt
Local pn$ length 8 = "asm01"
Local esc$ length 1 = Chr$(27)
Local c.normal$ length 3 = esc$ + "[m"
Local c.underline$ length 4 = esc$ + "[4m"
Local id$ length 16 = MM.Info(ID)

 Select Case id$
 Case "E66118C4E36"
   id$ = "moe"
 Case "E6612483CB0"
   id$ = "dallax"
 Case "E6612483CB2"
   id$ = "curly"
 Case "E6614C311B6"
   id$ = "larry"
 Case "E6616407E35"
   id$ = "larry1"
 Case "E6616407E37"
   id$ = "ripley"
 Case "E4611847675"
   id$ = "dallas"
 Case "E6616407E36"
   id$ = "dallas"
 Case "E6616408432"
   id$ = "dallas2"
 Case "4B02317F8D3"
   id$ = "Dallas"
 End Select
 Print pn$ + " " + c.underline$ + id$ + c.normal$ "> ";
End Sub

Sub list.list(s$(), len%)
Local I%
 If len% Then
   For I% = 1 To len%
     machine.log.message(s$(I%))
   Next I%
 EndIf
End Sub

' Error checking is done in the wrapper
' Alters tos as a side effect, since MMBasic arguments
' are by reference.
Function list.push$(a$, s$(), tos%)
 Inc tos%
 s$(tos%) = a$
 list.push$ = s$(tos%)
End Function

' Error checking is done in the wrapper
' Alters tos as a side effect, since MMBasic arguments
' are by reference.
Function list.pop$(s$(), tos%)
 list.pop$ = s$(tos%)
 tos% = tos% - 1
End Function

'
' Symbol Table
'

' 12Feb25 MPS - The symbol table class inherits
' stack methods, and Tiny10's Lookup, Locate,
' InTable, and AddEntry methods. Oddly, the first
' three when translated to MMBasic appear to be
' synonyms.
'   Also, Tiny used an array of strings, and parallel
' array of single characters to hold the identifier,
' and type respectively. MMBasic may as well use a
' single string with field 1 the identifier,
' field 2 the type, and field 3 the value. No single char limitation.

' type Symbol = string[8];
' Const MaxEntry = 100;
' VAR ST   : array[1..MaxEntry] of Symbol;
'     SType: array[1..MaxEntry] of char;
' Then a type is used to create a pointer and pass
' it around ...
'     SymTab = array[1..1000] of Symbol;
'     TabPtr = ^SymTab;

Dim symtab.unread$
Dim symtab.stack_pointer% = 0
Dim symtab.stack_depth% = 100
Dim symtab.stack$(symtab.stack_depth%)

Sub symtab.init(s$)
 symtab.unread$ = s$
 symtab.stack_clear()
End Sub

' See K&R, _C Programming Language_, 1978 P75
Sub symtab.stack_clear()
 symtab.stack_pointer% = 0
End Sub

Sub symtab.list()
 list.list(symtab.stack$(), symtab.stack_pointer%)
End Sub

Function symtab.push$(a$)
 If symtab.stack_pointer% < symtab.stack_depth% Then
   symtab.push$ = list.push$(a$,symtab.stack$(),symtab.stack_pointer%)
 Else
   machine.log.message("error: symtab stack full")
   symtab.stack_clear()
   symtab.push$ = ""
 EndIf
End Function

Function symtab.pop$()
 If symtab.stack_pointer% Then
   symtab.pop$ = list.pop$(symtab.stack$(),symtab.stack_pointer%)
 Else
   machine.log.message("error: symbol table empty")
   symtab.stack_clear()
   symtab.pop$ = ""
 EndIf
End Function

Function symtab.top_of_stack$()
 If symtab.stack_pointer% Then
   symtab.top_of_stack$ = symtab.stack$(symtab.stack_pointer%)
 Else
   machine.log.message("error: symbol table also empty")
   symtab.stack_clear()
   symtab.top_of_stack$ = ""
 EndIf
End Function

' Tiny - symtab.Lookup(T: TabPtr; s: string; n: integer): integer;
' Lookup, Locate, and InTable are synonyms?
Function symtab.Lookup%(sym$)
Local index% = symtab.stack_pointer%
Local s$ = Field$(sym$,1,":")
Local found% = 0
 Do While (index% > 0) And (Not found%)
   If s$ = symtab.GetIdentifier$(index%) Then
     Inc found%
   Else
     index% = index% - 1
   EndIf
 Loop
 symtab.Lookup% = index%
End Function

' Locate a symbol in the symbol table
' Returns the index of the entry.  Zero if Not present.
' Translated Tiny - Lookup and Locate are synonyms?
Function symtab.Locate%(s$)
  symtab.Locate% = symtab.Lookup(s$)
End Function

' Look For Symbol in Table
Function symtab.InTable%(s$)
  symtab.InTable% = symtab.Lookup%(s$)
End Function

' s$ is the new symbol name, t$ it's type, and v$ it's initial value
Sub symtab.AddEntry(s$, t$, v$)
Local buffer$
 If symtab.InTable%(s$) Then
   cradle.Abort("Duplicate Identifier " + s$)
 Else
   buffer$ = symtab.push$(s$ + ":" + t$ + ":" + v$)
 EndIf
End Sub

Sub symtab.ChangeValue(index%, new_value$)
Local entry$ = symtab.stack$(index%)
Local identifier$ = Field$(entry$, 1, ":")
Local type$ = Field$(entry$, 2, ":")
 symtab.stack$(index%) = identifier$ + ":" + type$ + ":" + new_value$
End Sub

Function symtab.GetIdentifier$(index%)
Local entry$ = symtab.stack$(index%)
Local identifier$ = Field$(entry$, 1, ":")
 symtab.GetIdentifier$ = identifier$
End Function

Function symtab.GetType$(index%)
Local entry$ = symtab.stack$(index%)
Local type$ = Field$(entry$, 2, ":")
 symtab.GetType$ = type$
End Function

Function symtab.GetValue$(index%)
Local symbol$ = symtab.stack$(index%)
Local value$ = Field$(symbol$, 3, ":")
 symtab.GetValue$ = value$
End Function