www.pudn.com > sn068s.zip > GENFLAGS.C

#include  
 
#ifdef DJGPP_CPU 
#define GLOBAL_DIRECTIVE ".globl" 
#define BYTE_DIRECTIVE ".byte" 
#define OUTPUT_EXTENSION ".S" 
#else 
#define GLOBAL_DIRECTIVE "global" 
#define BYTE_DIRECTIVE "db" 
#define OUTPUT_EXTENSION ".asm" 
#endif 
 
const unsigned NATIVE_SPC_FLAG_C = 1; 
const unsigned NATIVE_SPC_FLAG_V = 2; 
const unsigned NATIVE_SPC_FLAG_I = 4; 
const unsigned NATIVE_SPC_FLAG_B = 8; 
const unsigned NATIVE_SPC_FLAG_H = 0x10; 
const unsigned NATIVE_SPC_FLAG_P = 0x20; 
const unsigned NATIVE_SPC_FLAG_Z = 0x40; 
const unsigned NATIVE_SPC_FLAG_N = 0x80; 
 
const unsigned REAL_SPC_FLAG_C = 1; 
const unsigned REAL_SPC_FLAG_Z = 2; 
const unsigned REAL_SPC_FLAG_I = 4; 
const unsigned REAL_SPC_FLAG_H = 8; 
const unsigned REAL_SPC_FLAG_B = 0x10; 
const unsigned REAL_SPC_FLAG_P = 0x20; 
const unsigned REAL_SPC_FLAG_V = 0x40; 
const unsigned REAL_SPC_FLAG_N = 0x80; 
 
const int SYMMETRIC_FLAGS_SPC = -1; 
 
unsigned char flags_native_to_SPC(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & NATIVE_SPC_FLAG_C) temp |= REAL_SPC_FLAG_C; 
 if (flags & NATIVE_SPC_FLAG_Z) temp |= REAL_SPC_FLAG_Z; 
 if (flags & NATIVE_SPC_FLAG_I) temp |= REAL_SPC_FLAG_I; 
 if (flags & NATIVE_SPC_FLAG_H) temp |= REAL_SPC_FLAG_H; 
 if (flags & NATIVE_SPC_FLAG_B) temp |= REAL_SPC_FLAG_B; 
 if (flags & NATIVE_SPC_FLAG_P) temp |= REAL_SPC_FLAG_P; 
 if (flags & NATIVE_SPC_FLAG_V) temp |= REAL_SPC_FLAG_V; 
 if (flags & NATIVE_SPC_FLAG_N) temp |= REAL_SPC_FLAG_N; 
 
 return temp; 
} 
 
unsigned char flags_SPC_to_native(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & REAL_SPC_FLAG_C) temp |= NATIVE_SPC_FLAG_C; 
 if (flags & REAL_SPC_FLAG_Z) temp |= NATIVE_SPC_FLAG_Z; 
 if (flags & REAL_SPC_FLAG_I) temp |= NATIVE_SPC_FLAG_I; 
 if (flags & REAL_SPC_FLAG_H) temp |= NATIVE_SPC_FLAG_H; 
 if (flags & REAL_SPC_FLAG_B) temp |= NATIVE_SPC_FLAG_B; 
 if (flags & REAL_SPC_FLAG_P) temp |= NATIVE_SPC_FLAG_P; 
 if (flags & REAL_SPC_FLAG_V) temp |= NATIVE_SPC_FLAG_V; 
 if (flags & REAL_SPC_FLAG_N) temp |= NATIVE_SPC_FLAG_N; 
 
 return temp; 
} 
 
const unsigned NATIVE_65c816_FLAG_C = 1; 
const unsigned NATIVE_65c816_FLAG_V = 2; 
const unsigned NATIVE_65c816_FLAG_M = 4; 
const unsigned NATIVE_65c816_FLAG_1 = 4; 
const unsigned NATIVE_65c816_FLAG_X = 8; 
const unsigned NATIVE_65c816_FLAG_B = 8; 
const unsigned NATIVE_65c816_FLAG_D = 0x10; 
const unsigned NATIVE_65c816_FLAG_I = 0x20; 
const unsigned NATIVE_65c816_FLAG_Z = 0x40; 
const unsigned NATIVE_65c816_FLAG_N = 0x80; 
 
const unsigned REAL_65c816_FLAG_C = 1; 
const unsigned REAL_65c816_FLAG_Z = 2; 
const unsigned REAL_65c816_FLAG_I = 4; 
const unsigned REAL_65c816_FLAG_D = 8; 
const unsigned REAL_65c816_FLAG_X = 0x10; 
const unsigned REAL_65c816_FLAG_B = 0x10; 
const unsigned REAL_65c816_FLAG_M = 0x20; 
const unsigned REAL_65c816_FLAG_1 = 0x20; 
const unsigned REAL_65c816_FLAG_V = 0x40; 
const unsigned REAL_65c816_FLAG_N = 0x80; 
 
const int SYMMETRIC_FLAGS_65c816_E0 = -1; 
const int SYMMETRIC_FLAGS_65c816_E1 = 0; 
 
unsigned char flags_native_to_65c816_E0(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & NATIVE_65c816_FLAG_C) temp |= REAL_65c816_FLAG_C; 
 if (flags & NATIVE_65c816_FLAG_Z) temp |= REAL_65c816_FLAG_Z; 
 if (flags & NATIVE_65c816_FLAG_I) temp |= REAL_65c816_FLAG_I; 
 if (flags & NATIVE_65c816_FLAG_D) temp |= REAL_65c816_FLAG_D; 
 if (flags & NATIVE_65c816_FLAG_X) temp |= REAL_65c816_FLAG_X; 
 if (flags & NATIVE_65c816_FLAG_M) temp |= REAL_65c816_FLAG_M; 
 if (flags & NATIVE_65c816_FLAG_V) temp |= REAL_65c816_FLAG_V; 
 if (flags & NATIVE_65c816_FLAG_N) temp |= REAL_65c816_FLAG_N; 
 
 return temp; 
} 
 
unsigned char flags_65c816_to_native_E0(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & REAL_65c816_FLAG_C) temp |= NATIVE_65c816_FLAG_C; 
 if (flags & REAL_65c816_FLAG_Z) temp |= NATIVE_65c816_FLAG_Z; 
 if (flags & REAL_65c816_FLAG_I) temp |= NATIVE_65c816_FLAG_I; 
 if (flags & REAL_65c816_FLAG_D) temp |= NATIVE_65c816_FLAG_D; 
 if (flags & REAL_65c816_FLAG_X) temp |= NATIVE_65c816_FLAG_X; 
 if (flags & REAL_65c816_FLAG_M) temp |= NATIVE_65c816_FLAG_M; 
 if (flags & REAL_65c816_FLAG_V) temp |= NATIVE_65c816_FLAG_V; 
 if (flags & REAL_65c816_FLAG_N) temp |= NATIVE_65c816_FLAG_N; 
 
 return temp; 
} 
 
unsigned char flags_native_to_65c816_E1(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & NATIVE_65c816_FLAG_C) temp |= REAL_65c816_FLAG_C; 
 if (flags & NATIVE_65c816_FLAG_Z) temp |= REAL_65c816_FLAG_Z; 
 if (flags & NATIVE_65c816_FLAG_I) temp |= REAL_65c816_FLAG_I; 
 if (flags & NATIVE_65c816_FLAG_D) temp |= REAL_65c816_FLAG_D; 
 if (flags & NATIVE_65c816_FLAG_B) temp |= REAL_65c816_FLAG_B; 
 temp |= REAL_65c816_FLAG_1; 
 if (flags & NATIVE_65c816_FLAG_V) temp |= REAL_65c816_FLAG_V; 
 if (flags & NATIVE_65c816_FLAG_N) temp |= REAL_65c816_FLAG_N; 
 
 return temp; 
} 
 
unsigned char flags_65c816_to_native_E1(unsigned char flags){ 
 unsigned char temp = 0; 
 
 if (flags & REAL_65c816_FLAG_C) temp |= NATIVE_65c816_FLAG_C; 
 if (flags & REAL_65c816_FLAG_Z) temp |= NATIVE_65c816_FLAG_Z; 
 if (flags & REAL_65c816_FLAG_I) temp |= NATIVE_65c816_FLAG_I; 
 if (flags & REAL_65c816_FLAG_D) temp |= NATIVE_65c816_FLAG_D; 
 // 65c816 B flag ONLY needs to be clear in stack after IRQ/NMI 
 temp |= NATIVE_65c816_FLAG_B; 
 temp |= NATIVE_65c816_FLAG_1; 
 if (flags & REAL_65c816_FLAG_V) temp |= NATIVE_65c816_FLAG_V; 
 if (flags & REAL_65c816_FLAG_N) temp |= NATIVE_65c816_FLAG_N; 
 
 return temp; 
} 
 
void generate_flags_table(FILE *out, char *label, 
                          unsigned char (*translator)(unsigned char flags)){ 
 int i; 
 
 fprintf(out, "%s:\n", label); 
 for (i = 0; i < 256; i++){ 
  if ((i & 7) == 0) fprintf(out, "%s ", BYTE_DIRECTIVE); 
  fprintf(out, "%4u", (*translator)(i)); 
  if ((i & 7) != 7) fprintf(out, ","); 
  else fprintf(out, "\n"); 
 } 
 fprintf(out, "\n"); 
} 
 
int main(int argc, char **argv){ 
 FILE *out; 
 
 out = fopen("CPUflags" OUTPUT_EXTENSION, "wt"); 
 if (!out){ 
  printf("Failure creating 65c816 CPU flag conversion tables\n"); 
  return -1; 
 } 
 
 if (SYMMETRIC_FLAGS_65c816_E0){ 
  fprintf(out, "%s %s,%s\n", GLOBAL_DIRECTIVE, "_E0_Setup_Flags_Table", "_E0_Restore_Flags_Table"); 
  fprintf(out, "%s:\n", "_E0_Setup_Flags_Table"); 
  generate_flags_table(out, "_E0_Restore_Flags_Table", 
   flags_native_to_65c816_E0); 
 } else { 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_E0_Setup_Flags_Table"); 
  generate_flags_table(out, "_E0_Setup_Flags_Table", 
   flags_native_to_65c816_E0); 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_E0_Restore_Flags_Table"); 
  generate_flags_table(out, "_E0_Restore_Flags_Table", 
   flags_65c816_to_native_E0); 
 } 
 
 if (SYMMETRIC_FLAGS_65c816_E1){ 
  fprintf(out, "%s %s,%s\n", GLOBAL_DIRECTIVE, "_E1_Setup_Flags_Table", "_E1_Restore_Flags_Table"); 
  fprintf(out, "%s:\n", "_E1_Setup_Flags_Table"); 
  generate_flags_table(out, "_E1_Restore_Flags_Table", 
   flags_native_to_65c816_E1); 
 } else { 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_E1_Setup_Flags_Table"); 
  generate_flags_table(out, "_E1_Setup_Flags_Table", 
   flags_native_to_65c816_E1); 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_E1_Restore_Flags_Table"); 
  generate_flags_table(out, "_E1_Restore_Flags_Table", 
   flags_65c816_to_native_E1); 
 } 
 
 out = freopen("SPCflags" OUTPUT_EXTENSION, "wt", out); 
 if (!out){ 
  printf("Failure creating SPC700 CPU flag conversion tables\n"); 
  return -1; 
 } 
 
 if (SYMMETRIC_FLAGS_SPC){ 
  fprintf(out, "%s %s,%s\n", GLOBAL_DIRECTIVE, "_SPC_Setup_Flags_Table", "_SPC_Restore_Flags_Table"); 
  fprintf(out, "%s:\n", "_SPC_Setup_Flags_Table"); 
  generate_flags_table(out, "_SPC_Restore_Flags_Table", 
   flags_native_to_SPC); 
 } else { 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_SPC_Setup_Flags_Table"); 
  generate_flags_table(out, "_SPC_Setup_Flags_Table", 
   flags_native_to_SPC); 
  fprintf(out, "%s %s\n", GLOBAL_DIRECTIVE, "_SPC_Restore_Flags_Table"); 
  generate_flags_table(out, "_SPC_Restore_Flags_Table", 
   flags_SPC_to_native); 
 } 
 
 fclose(out); 
 
#ifndef DJGPP_CPU 
 out = fopen("CPUflags" ".i", "wt"); 
 if (!out){ 
  printf("Failure creating 65c816 CPU flag table import include file\n"); 
  return -1; 
 } 
 
 fprintf(out, "%s %s,%s\n", "extern", "_E0_Setup_Flags_Table", "_E0_Restore_Flags_Table"); 
 fprintf(out, "%s %s,%s\n", "extern", "_E1_Setup_Flags_Table", "_E1_Restore_Flags_Table"); 
 fclose(out); 
 
 out = fopen("SPCflags" ".i", "wt"); 
 if (!out){ 
  printf("Failure creating SPC700 CPU flag table import include file\n"); 
  return -1; 
 } 
 fprintf(out, "%s %s,%s\n", "extern", "_SPC_Setup_Flags_Table", "_SPC_Restore_Flags_Table"); 
 fclose(out); 
#endif 
 
 return 0; 
}