typedef enum _Data
{
data1,
data2,
data3

} Data;

    

typedef enum _MEDIA_TYPE {
  Unknown,
  F5_1Pt2_512,
  F3_1Pt44_512,
  F3_2Pt88_512,
  F3_20Pt8_512,
  F3_720_512,
  F5_360_512,
  F5_320_512,
  F5_320_1024,
  F5_180_512,
  F5_160_512,
  RemovableMedia,
  FixedMedia,
  F3_120M_512,
  F3_640_512,
  F5_640_512,
  F5_720_512,
  F3_1Pt2_512,
  F3_1Pt23_1024,
  F5_1Pt23_1024,
  F3_128Mb_512,
  F3_230Mb_512,
  F8_256_128,
  F3_200Mb_512,
  F3_240M_512,
  F3_32M_512 
} MEDIA_TYPE;

    

data1 = 1
data2 = 2
data3 = 3    

macro enum [stuff] {
      common
              local x
             x=0
 forward
             x=x+1
               stuff = x
}

enum data1, data2, data3

display data1+'0',data2+'0',data3+'0'    

enum MEDIA_TYPE,\
                data1,\
                data2 

struct DISK_GEOMETRY
   .MediaType MEDIA_TYPE ?

ends
    

include 'win32ax.inc'

macro enum var,[stuff] {
 common
              local x
             x=0
         struc var \{. dd ?\}
    forward
             x=x+1
               stuff = x
}

enum MEDIA_TYPE,\
                data1,\
                data2 

struct DISK_GEOMETRY
   MediaType MEDIA_TYPE
ends    

macro enum start,step,[items]
{
   common
        local count
        count=start
   forward
        items=count
        count=count+step
}

enum $0,1,\
     T_INT,T_VOID,T_IF,T_WHILE,T_DO,T_ELSE,T_WRITE,T_READ,T_RETURN,T_ERR,T_EOT

enum $10,1,\
     T_COMMA,T_MUL,T_LPAR,T_RPAR,T_LBRA,T_RBRA,T_PLUS,T_MINUS,T_SEMICOLON,T_LTE,T_GTE,T_NEQ,T_EQ

enum $20,1,\
     T_LT,T_GT,T_NOT,T_ASSIGN,T_NUM,T_ID,T_DIV    

I was not referring specifically about "enum",
but about many messages about macros, and more broadly about the general interest for macros.
I don't like the using of macros, for me this way is not really the assembly language.
I think anything can be carried out without macros.
For me, the use of macros is really the opposite of a real assembly language programming.
Again, it's just my view, ... and sorry, i'm off topic (sticky opinion ? )

(sorry for my bad english, i do my best, it's not easy for me)

macro export dllname,[label,string]
 { common
    local module,addresses,names,ordinal,count
    count = 0
   forward
    count = count+1
   common
    dd 0,0,0,RVA module,1
    dd count,count,RVA addresses,RVA names,RVA ordinal
    addresses:
   forward
    dd RVA label
   common
    names:
   forward
    local name
    dd RVA name
   common
    ordinal: count = 0
   forward
    dw count
    count = count+1
   common
    module db dllname,0
   forward
    name db string,0
   common
    local x,y,z,str1,str2,v1,v2
    x = count shr 1
    while x > 0
     y = x
     while y < count
      z = y
      while z-x >= 0
       load v1 dword from names+z*4
       str1=($-RVA $)+v1
       load v2 dword from names+(z-x)*4
       str2=($-RVA $)+v2
       while v1 > 0
        load v1 from str1+%-1
       load v2 from str2+%-1
       if v1 <> v2
    break
      end if
       end while
       if v1<v2
    load v1 dword from names+z*4
        load v2 dword from names+(z-x)*4
    store dword v1 at names+(z-x)*4
     store dword v2 at names+z*4
 load v1 word from ordinal+z*2
       load v2 word from ordinal+(z-x)*2
   store word v1 at ordinal+(z-x)*2
    store word v2 at ordinal+z*2
       else
 break
       end if
       z = z-x
      end while
      y = y+1
     end while
     x = x shr 1
    end while }

    

Why do you want absolutely create high-level language directives in assembler ?

There are purists which shun use of macros - I certainly do [shun] when it comes to optimization for execution speed.