For v2003.06.01 Release $Revision: 1.49 $ Support: ------- Language : C - C++ Features : Component Testing - Code Coverage - Performance Profiling - Memory Profiling - Trace Tested Against: ------------ Host Machine : RS 6000 AIX 4.3 - RS 6000 5.L v5.2 Compiler : IBM C and C++ Compilers Version 4.3.0.1 - IBM C and C++ Compilers Version 5.0.2.0 Linker : IBM Linker Version 4.3.0.1 - IBM Linker Version 5.0.2.0 Debugger : IBM Debugger dbx Version 3.1 OS : Native Target : Native Please define the environment variable 'USE_ATOMIC' to 1 if you have compilation errors on sys/atomic_op.h. You can easily do that in the project settings (Build->Execution->Environment variables) c o exe -g -g Compiler used COMPILER xlC Preprocessor used PREPROCESSOR xlC Linker used LINKER xlC Debugger used DEBUGGER dbx Exit Code of the Process should be shown in the Memory Profile EXIT_CODE_IN_MEMORY_PROFILE on Comma-separated list of root paths to standard include files. e.g.: /usr/include STD_INCLUDE /usr/include cc o exe -g -qstaticinline -g -qstaticinline Compiler used COMPILER xlC Preprocessor used PREPROCESSOR xlC Linker used LINKER xlC Debugger used DEBUGGER dbx Exit Code of the Process should be shown in the Memory Profile EXIT_CODE_IN_MEMORY_PROFILE on Comma-separated list of root paths to standard include files. e.g.: /usr/include STD_INCLUDE /usr/include sub atl_cc($$$$\@\@) { my ( $lang,$src,$out,$cflags,$Defines,$Includes) = @_; my $defines = ""; foreach $D ( @$Defines ) { $defines .= " \"-D$D\"" ; } my $includes = ""; foreach $I ( @$Includes ) { $includes .= " \"-I$I\"" ; } my $COMP = $Ini{'COMPILER'}; if ( !$COMP ) { print "Error: no compiler known for target (lang:\"$lang\")\n"; return 1; } SystemP( "$COMP -c \"$src\" $defines $includes $cflags -o \"$out\""); } sub atl_cpp($$$$\@\@) { my ( $lang,$src,$out,$cflags,$Defines,$Includes) = @_; my $defines = ""; foreach $D ( @$Defines ) { $defines .= " \"-D$D\"" ; } my $includes = ""; foreach $I ( @$Includes ) { $includes .= " \"-I$I\"" ; } my $COMP = $Ini{'PREPROCESSOR'}; if ( !$COMP ) { print "Error: no compiler known for target (lang:\"$lang\")\n"; return 1; } $FixedLine = "temporary.fix" ; my $status=0; my ($dir,$base,$ext) =SplitFileName($src); $status=SystemP( "$COMP -E \"$src\" $defines $includes $cflags > $FixedLine" ); # define the environment variable 'USE_ATOMIC' to 1 if you have compilation errors on sys/atomic_op.h if ($ENV{'USE_ATOMIC'}) { PatchPrepro(); } if ( $status!=0 ) { unlink ( $FixedLine ); return $status; } $status=SystemP( "$BINDIR/fixlines \"$FixedLine\" \"$out\"" ); unlink ( $FixedLine ); return $status; } sub PatchPrepro { my $eol=""; open(IN,$FixedLine); open(OU,">tmp.i"); while($line=<IN>) { if ( ($line=~/^\#pragma/) && ($line=~/\\$/) ) { while ($line=~/\\$/) { $eol.=chop($line) ;chop($line); $line.=<IN>; } print OU $line,$eol; $eol=""; } else { print OU $line; } } close(IN); close(OU); rename ("tmp.i",$FixedLine); } 1; sub atl_link($\@$\@$) { my ($exe,$Objects,$ldflags,$LibPath,$libs) = @_; my $LINK = $Ini{'LINKER'}; my $objects = ""; foreach $O ( @$Objects ) { $objects .= " \"$O\"" ; } my $libpath = ""; foreach $L ( @$LibPath ) { $libpath .= " \"-L$L\"" ; } SystemP( "$LINK -o \"$exe\" $ldflags $objects $libpath $libs"); } 1; sub atl_exec($$$) { my ($exe,$out,$parameters) = @_; unlink( $out ); $status = SystemP( "\"$exe\" $parameters" ); return $status; } sub atl_execdbg($$$) { my ($exe,$out,$parameters) = @_; unlink( $out ); my $Debugger = $Ini{'DEBUGGER'}; SystemP( "xterm -e $Debugger \"$exe\"" ); return 0; } 1; use File::Copy; sub postGen { my $dir=shift; my $xlCver = 0; #Test if AIX return(0) if( ! ($^O =~ /aix/i)); #Get xlC version system("lslpp -l | grep \"xlC.adt.include\" > $dir/xlC.ver"); open(IN, "$dir/xlC.ver"); <IN> =~ /\s*([0-9])\.[0-9]\.[0-9]\.[0-9]\s*/; $xlCver = $1; close(IN); unlink("$dir/xlC.ver"); # Copy perllauncher to metcc copy("$ENV{'TESTRTDIR'}/bin/rs6000/aix/perllauncher", "$dir/cmd/metcc"); chmod(0755,"$dir/cmd/metcc"); require("$SCRIPTDIR/Fcts.pl"); $ENV{'ATLTGT'}="$dir"; $INIFILE="tpcpp.ini"; DecodeIniFile(); open(OU,">$dir/empty.cpp");print OU "int main(void){\nint __ibmcpp__=__IBMCPP__;\nreturn(0);}\n";close(OU); $Status=system("$Ini{'COMPILER'} $Ini{'CPPFLAGS'} $Ini{'CFLAGS'} -# $dir/empty.cpp >$dir/result.cc 2>$dir/result.err"); $Status=system("$Ini{'COMPILER'} $Ini{'CPPFLAGS'} $Ini{'CFLAGS'} -E $dir/empty.cpp >$dir/result.i"); unlink("$dir/empty.cpp"); return(0) if($Status); # Get compiler defines open(IN,"<$dir/result.cc"); while(<IN>) { @args = split(/,/,$_) if ((/exec/) && (/-D_AIX/)); } close(IN); unlink("$dir/result.cc"); foreach (@args) { if (/^-D/){ $_ =~ s/^-D//; push(@Defines, $_); } } # Get specific compiler defines open(IN,"<$dir/result.i"); while(<IN>) { if(/__ibmcpp__=(.*);/) { push(@Defines, "__IBMCPP__=$1"); } } close(IN); unlink("$dir/result.i"); # Get standard include paths system("which $Ini{'COMPILER'} >$dir/result.txt 2>$dir/result.err"); my $str = "bin/$Ini{'COMPILER'}"; open(IN,"<$dir/result.txt"); while(<IN>) { if (/$str$/) { $_ =~ s/$str$/include/; push(@Includes, $_); } } close(IN); unlink("$dir/result.txt"); # copy("$dir/ana/atus_c.def","$dir/ana/atus_c.bak"); open(OU,">>$dir/ana/atus_c.def"); foreach(@Defines) { print OU join(" ",("#define",split(/=/,$_),"\n")); } foreach(@Includes) { print OU "#pragma attol incl_std=$_\n"; } close(OU); # copy("$dir/ana/atus_cpp.def","$dir/ana/atus_cpp.bak"); open(OU,">>$dir/ana/atus_cpp.def"); foreach(@Defines) { print OU join(" ",("#define",split(/=/,$_),"\n")); } foreach(@Includes) { print OU "#pragma attol incl_std=$_\n"; } close(OU); # copy("$dir/ana/atl.hpp","$dir/ana/atl.hpp.bak"); open(OU,">>$dir/ana/atl.hpp"); foreach(@Defines) { print OU join(" ",("#define",split(/=/,$_),"\n")); } close(OU); # copy("$dir/ana/atct.def","$dir/ana/atct.bak"); open(OU,">>$dir/ana/atct.def"); foreach(@Defines) { print OU join(" ",("#define",split(/=/,$_),"\n")); } foreach(@Includes) { print OU "#pragma attol incl_std=$_\n"; } close(OU); # copy("$dir/ana/atl.opp","$dir/ana/atl.opp.bak"); open(OU,">>$dir/ana/atl.opp"); if ($xlCver >= 6) { # Patch for Visual Age version 6 print OU "--template_note_code_at_declaration\n"; print OU "--gen_new_specialization\n"; # print OU "--postcondition_before_return\n"; } else { # Patch for Visual Age before version 6 print OU "--no_explicit\n--no_restrict\n"; print OU "--no_bool\n--no_typename\n"; } foreach(@Includes) { print OU "--sys_include=$_\n"; } close(OU); # Patch for RTRT_DEFINE_NEW_DELETE if ($xlCver >= 6) { open(IN,"$dir/lib/custom.h"); open(OU,">$dir/lib/custom.h.tmp"); while(<IN>) { print OU "#define _TESTRT_VA6\n" if (/Do not delete this comment/); print OU; } print OU "#undef _TESTRT_VA6\n"; close(IN); close(OUT); unlink ("$dir/lib/custom.h"); rename ("$dir/lib/custom.h.tmp", "$dir/lib/custom.h"); } unlink("$dir/result.err") if (-z "$dir/result.err"); } 1; ########################################################################## # # # # Rational Test RealTime # # # ####### # -*- metcc command -*- # # # # # ################################################################################ use FileHandle ; STDOUT->autoflush(1); # Where the Product is installed $SCRIPTDIR = $ENV{'TESTRTDIR'} . "/lib/scripts/"; require $SCRIPTDIR . "metcclib.pl"; my $compCmd=0; ################################################################################ sub ParseArgs { my $i = 0; foreach $arg (@ARGV) { &MetccDebug ("\$arg[$i] = [$arg]\n"); if($compCmd) #bcomes 1 after that compiler name has been analysed by getMetccOptions { my @file_list = glob($arg); if (-f $arg) { FileArg ($arg) } elsif (scalar(@file_list)>0 && -f @file_list[0]) { foreach $file (@file_list) { FileArg ($file) } } else { # Compiler options: if ($arg =~ /-D(.*)/) { pushDefinesList ($1); } elsif ($arg =~ /-I(.*)/) { pushIncludeDirs ($1); } elsif ($arg =~ /-std_define\=(.*)/) { pushStandardDefine ($1); } elsif($arg eq "--") { &MetccFatalError ("Command string separator (--) found more than once\n"); } else { pushCompilerOptions ($arg); } } } else { $compCmd=getMetccOptions($i,$arg); #analyse all metcc option and get compiler name then return 1 } $i += 1; } } ################################################################################ # Maybe something to print first &MetccEnvironment; # Let's start here &EnterInScript; # First parse command-line &ParseArgs; &MetccCheckArgs(); # Then compute the metrics on sources &ComputeCMetrics; &ComputeCPPMetrics; 0; # ################################################################################ ##!perl -w ########################################################################## # # # # Rational Test RealTime # # # ####### # -*- Source Instrumentation launcher -*- # # # # # ################################################################################ #$Id: caix.xdp,v 1.49 2003/12/10 12:59:50 build Exp $ ################################################################################ # useful for stdout/stderr direct viewing inside 'console' of studio window # better: we have stdout/stderr lines in right order and not stder before stdout use FileHandle ; STDOUT->autoflush(1); die "Environment variable TESTRTDIR not found. Exiting.\n" if(!defined($ENV{'TESTRTDIR'})); # NO TRANSLATION $TESTRTDIR="$ENV{'TESTRTDIR'}"; $TARGETDIR=$ENV{'ATLTGT'}; $SCRIPTDIR="$TESTRTDIR/lib/scripts/"; require $SCRIPTDIR . "attolcclib.pl"; my $flagMarks="[-]"; #possible option marks for the compiler command my $flagMark="-"; #flag mark used by the script in generated cmd my $forceOutMark="o"; #end by: " " (white space if the file name is separated, or nothing if the file is joined) $DefineFlag=$flagMark."D"; # can be used by additional treatment. my $noLinkFlag="c";#this var may be "" if it does not exist. with -nolink option the link phase is done when object or library files are met on cmd line #list of known extensions @asmExtList=qw(S s); @cExtList=qw(c); @cppExtList=qw(C CC cc CPP cpp c++ CXX cxx); @objExtList=qw(o O obj OBJ so); my @libExtList=qw(a lib LIB); @objFiles=(); $PreproFlags=""; $CompilFlags=""; $LinkFlags=""; @compOriginal=(); my $compiler; ################################################################################ sub ParseCompilerArgs(@) { my @argv=@_; my $i=0; my $ret=0; $compiler=shift(@argv); while(@argv) { $_=shift(@argv); $i++; #debug ("\$arg[$i] = [$_]\n"); #add \ when " encountered $_=~s/\"/\\\"/g; #add cot for args having space if((/ /) && !(/\"$/)) {$_ = $cot.$_.$cot;} push(@compOriginal,$_); #it is a flag if(/^$flagMarks(.+)$/) { my $flag=$1; my $trtmt; #debug("flag:$flag"); if($flag eq $noLinkFlag) {NoLink();next;} if($flag =~/^o/) { my $OFile; if($flag =~/^o$/) {#the filename is on the next arg $OFile=shift(@argv); push(@compOriginal,$OFile); } elsif($flag =~/^o(.+)$/) { $OFile=$1; } $OFile=~s/^\"//; #suppress begin cot if any $OFile=~s/\"$//; #suppress end cot if any #register the requested name of the object file to generate and/or its directory #to register a directory the path must ends by a path separator my ($d,$n,$e) = SplitFileName($OFile); OutFileFound($OFile) if(grep(/^$e$/,@objExtList)); #anyway forceOut file may be append to the link command $LinkFlags .=$flagMark.$forceOutMark.$OFile.$sp; next; # remove this option because used by launcher } elsif($flag =~/^[EP]$/) { $ret=1;# no instrumentation at all } elsif($flag =~/^[DUI]$/) { #for these flags the next arg must not be interpreted $flag .= takeNextArg(shift(@argv)); } elsif($flag =~/^\+$/) { force_language(2);# force instrumentation as C++ } # should make a treatment and/or remove this flag from one of command lines ? # $trtmt="pcl";#set $trtmt to exclude this flag from commands line # p means: this option must not be part of the preprocessing command # c means: this option must not be part of the compilation command # l means: this option must not be part of the link command #debug("trtmt:$trtmt") if($trtmt); if(!($trtmt =~/p/)) { $PreproFlags .=$flagMark.$flag.$sp; diffBetweenPreproAndCompil() if($ret =~/c/); } if(!($trtmt =~/c/)) { $CompilFlags .=$flagMark.$flag.$sp; } if(!($trtmt =~/l/)) { $LinkFlags .=$flagMark.$flag.$sp; } } else { #it is not a flag, is it a file? my $f=$_; $f=~s/^\"//; #suppress begin cot if any $f=~s/\"$//; #suppress end cot if any my ($dir,$name,$ext) = SplitFileName($f); $ext=~s/\"$//; #suppress cot if any if((grep(/^$ext$/,@asmExtList)) || (grep(/^$ext$/,@cExtList)) || (grep(/^$ext$/,@cppExtList))) { #debug("src:$_"); SourceFileFound($_); push(@objFiles,$dir.$name.".$OBJEXT"); next; } elsif(grep(/^$ext$/,@objExtList)) { #debug("obj:$_"); push(@objFiles,$_); $Link=1; next; } elsif(grep(/^$ext$/,@libExtList)) { #debug("lib:$_"); $LinkFlags .=$_.$sp; $Link=1; next; } else { #it is not a file #debug("cmd:$_"); $PreproFlags .=$_.$sp; $CompilFlags .=$_.$sp; $LinkFlags .=$_.$sp; } } } # End while return $ret;#return 0=OK, 1=start the stdCompil command then exit } ########################################################################### # takeNextArg sub takeNextArg($) { my ($fn)=@_; if($fn=~ / /) {$fn = $cot.$fn.$cot;} push(@compOriginal,$fn); return $sp.$fn; } ########################################################################### # preprocessing sub preprocessing($$$) { my ($lang,$src,$out)=@_; print ">preprocessing of $src to $out\n"; unlink($out); return atl_cpp($lang,$src,$out,$PreproFlags,"",""); } ########################################################################### # compilation sub compilation($$$) { my ($ext,$src,$out)=@_; print ">compilation of $src to $out\n"; my $ret=SystemL($compiler,$flagMark.$noLinkFlag,$src,split(/ /,$CompilFlags),split(/ /,$flagMark.$forceOutMark.$out)); return $ret if($ret); return 0 if(-r $out); return 1; } ########################################################################### # Link sub Link($) { my ($tpo)=@_; print ">Link with $tpo\n"; return SystemL($compiler, @objFiles,$tpo,split(/ /,$LinkFlags)); } ########################################################################### # standard compilation using Original cmd line sub stdCompil() { SystemL($compiler,$sp,$compOriginal); } ################################################################################ # First parse command-line # Then instrument sources Attolcc(); 0; # ################################################################################ /* Insert any includes */ /* Do not delete this comment */ #if defined(__cplusplus) && defined(_TESTRT_VA6) } /* end of preceeding extern "C" block (from TP.cpp) */ #include <new> extern "C" { #define RTRT_DEFINE_NEW_DELETE \ void *operator new ( size_t size ) throw (std::bad_alloc) \ { return _atp_malloc ( size ); } \ void *operator new[] ( size_t size ) throw (std::bad_alloc) \ { return _atp_malloc ( size ); } \ void operator delete ( void *ptr ) throw() \ { _atp_free ( ptr ); } \ void operator delete[] ( void *ptr ) throw () \ { _atp_free ( ptr ); } #endif a##b static static extern extern "C" virtual char unsigned char short unsigned short long unsigned long unsigned long ((RTRT_U_INT32)p) RTRT_NONE RTRT_STD RTRT_USR void usr_exit(RTRT_INT32 x) { /* Code here your own exit function, returning x */ ; } RTRT_NONE RTRT_USR char *usr_date() { /* Code here your own get date function */ return ((char *)0); } RTRT_NONE RTRT_STD RTRT_USR void *usr_memcpy(void *dest,const void *src,RTRT_SIZE_T s) { int i; /* Code here your memcpy function */ i=0; for(i=0;i<s;i++) ((char *)(dest))[i]=((char *)(src))[i]; return dest; } RTRT_NONE RTRT_STD RTRT_USR void *usr_gethostname(char *p) { /* Code here your gethostname function */ /* The p parameter is a 50-bytes long allocated pointer */ } RTRT_NONE RTRT_STD RTRT_USR int usr_rdv(char *p) { /* Code here your rendez-vous function */ /* The p parameter contains the name of the rendez-vous */ /* THis function should block until all the members are at the same point */ } RTRT_NONE RTRT_STD RTRT_USR int usr_atexit(void (handler)(void)) { /* Code here your atexit function */ /* The p parameter contains the name of a function that should be */ /* called at normal program termination */ } RTRT_NONE RTRT_STD RTRT_USR char *usr_getenv(char *s) { /* Code here your getenv function */ /* The s parameter contains the name of the environment variable */ /* that should be retrieved from the environment */ } RTRT_NONE RTRT_STD RTRT_USR int usr_getpid() { /* Code here your getpid function */ return(0); } RTRT_NONE RTRT_STD RTRT_USR void usr_signal(int sig,void (handler)(int)) { /* Code here your signal function */ /* The sig parameter contains the signal number to be registered */ /* The f parameter is a function pointer to the handler */ } RTRT_NONE RTRT_USR void _atl_stack_jump(void *,short); #define STACK_GOING_UP 0 #define STACK_GOING_DOWN 1 #include <setjmp.h> void RTRT_longjmp(jmp_buf env,int val) { /* First parameter contains the SP register address */ _atl_stack_jump((void *)((env)[3]),STACK_GOING_DOWN); longjmp(env,val); } void RTRT__longjmp(jmp_buf env,int val) { /* First parameter contains the SP register address */ _atl_stack_jump((void *)((env)[3]),STACK_GOING_DOWN); _longjmp(env,val); } void RTRT_siglongjmp(sigjmp_buf env,int val) { /* First parameter contains the SP register address */ _atl_stack_jump((void *)((env)[3]),STACK_GOING_DOWN); siglongjmp(env,val); } #define longjmp RTRT_longjmp #define _longjmp RTRT__longjmp #define siglongjmp RTRT_siglongjmp int main(int argc,char *argv[]) { return(0); 6 15 15 RTRT_NONE RTRT_STD RTRT_USR FILE * RTRT_FILE_TYPE usr_init(char *fileName) { /* Open the file named name */ return((FILE *) fopen(fileName,"w")); } RTRT_FILE_TYPE usr_open(char *fileName) { /* Open the file named name */ return((FILE *) fopen(fileName,"w")); } void usr_writeln(RTRT_FILE_TYPE f,char *s) { /* Print the string str into file and add a newline character */ fprintf(f,"%s",s); } void usr_close(RTRT_FILE_TYPE f) { /* Close the file */ fclose(f); } RTRT_NONE RTRT_STD RTRT_USR void usr_error(const char *s) { /* Code the error function here */ } RTRT_STD RTRT_USR RTRT_NONE void *usr_malloc(RTRT_SIZE_T size) { /* Code here your own allocation function here */ } void usr_free(void *ptr) { /* Code here your own free function here */ } RTRT_USR RTRT_NONE void *lowlevel_malloc(RTRT_SIZE_T size) { /* Code the low level allocation function here */ return(__libc_malloc(size)); } void *lowlevel_calloc(RTRT_SIZE_T x,RTRT_SIZE_T y) { /* Code the low level allocation function here */ return(__libc_calloc(x,y)); } void *lowlevel_realloc(void *ptr,RTRT_SIZE_T s) { /* Code the low level allocation function here */ return(__libc_realloc(ptr,s)); } void lowlevel_free(void *ptr) { /* Code the low level allocation function here */ __libc_free(ptr); } RTRT_NONE RTRT_USR #include "atpapi.h" void *RTRT_memPartAlloc(int id,unsigned n) { void *r; unsigned x=_PurifyLTHeapActualSize(n); r=memPartAlloc(id,x); return(_PurifyLTHeapAction(_PurifyLT_API_ALLOC,r,n,0)); } void memPartFree(int id,char *ptr) { void *r=_PurifyLTHeapAction(_PurifyLT_API_FREE,ptr,0,0)); memPartFree(id,ret); } #define memPartAlloc RTRT_memPartAlloc #define memPartFree RTRT_memPartFree RTRT_NONE RTRT_STD RTRT_USR clock_t void usr_clock(RTRT_CLOCK_TYPE *p) { /* Code here the funtion which reads the clock */ /* and sets (*p) to the current clock value */ (*p)=clock(); } void usr_clock_init(void) { /* This function will be called only once when starting the program */ /* You may code here clock resolution computation */ } RTRT_U_INT32 4 "Ticks" "3" (c) ((r)=((a)-(b))) RTRT_U_INT32 "3" (c) 1000 void usr_sleep(RTRT_TIME_TYPE p) { /* Code here the funtion which sleeps for a while */ /* p contains the duration, represented in a RTRT_TIME_TYPE item */ } RTRT_STD RTRT_SOLARIS RTRT_USR RTRT_NONE thread_t thread_self() thread_equals((t1),(t2)) thread_exit((int)(v)); thread_mutex_t v; thread_mutex_init(&v) thread_mutex_lock(&v) thread_mutex_unlock(&v) thread_mutex_destroy(&v) thread_key_t key; thread_key_create(key,NULL); thread_key_delete(key); v=thread_getspecifics(key); thread_setspecifics(key,v); We must write: #define _ATO_in_exception 0 As we have --postcondition_before_return in atl.opp /* Add your code */ #define _ATO_in_exception 0 /* #define __STRICT_ANSI__ #define __MATH__ 1 #define __STR__ 1 #define __XLC121__ 1 */ #define __cplusplus 1 #define __STRICT_ANSI__ /* #define __MATH__ 1 #define __STR__ 1 #define __XLC121__ 1 #define __CHAR_UNSIGNED__ 1 */ #pragma attol exit_instr = "exit", "longjmp", "_longjmp", "siglongjmp" #ifdef NEED_PREPRO_DEFS #endif /* NEED_PREPRO_DEFS */ #define _Builtin #define __builtin #define _Cdecl #define _cdecl #define __cdecl #define __declspec #define _Export export #define __export export #define __except #define _Far16 #define __far16 #define _Far32 #define __far32 #define _Fastcall #define __fastcall #define __finally finally #define _Import #define __import typedef long int __int64; #define _Inline inline #define __inline inline typedef char __int8; typedef short __int16; typedef int __int32; #define __leave #define _Optlink #define __optlink #define _Pascal #define __pascal #define _Packed #define __packed #define __stdcall #define _System #define __system #define __thread #define __try try #define __unaligned #define externalref extern extern char *__vastart(char *); extern "C" void _attol_dump(int); --postcondition_before_return --simulate_called_routines --simulate_virtual_methods --old_for_init --no_alternative_tokens --no_const_string_literal --no_class_name_injection --old_specialization --no_type_info_in_namespace_std --targ_size_t_int_kind 8 --template_cctor_param_with_params --class_member_in_constant_expression_allowed --diag_suppress 77,111,161,177,262,284,307,336,337,375,493,693 --diag_suppress 830,815,837,864 --diag_warning 147 --inline_not_yet_defined