gencpp.c

Bug Summary

File:	src/gencpp.c
Warning:	line 4071, column 67 Access to field 'parents' results in a dereference of a null pointer (loaded from field 'methods')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name gencpp.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/kfp/aldor/aldor/aldor/src -fcoverage-compilation-dir=/home/kfp/aldor/aldor/aldor/src -resource-dir /usr/local/lib/clang/18 -D PACKAGE_NAME="aldor" -D PACKAGE_TARNAME="aldor" -D PACKAGE_VERSION="1.4.0" -D PACKAGE_STRING="aldor 1.4.0" -D PACKAGE_BUGREPORT="aldor@xinutec.org" -D PACKAGE_URL="" -D PACKAGE="aldor" -D VERSION="1.4.0" -D YYTEXT_POINTER=1 -D HAVE_STDIO_H=1 -D HAVE_STDLIB_H=1 -D HAVE_STRING_H=1 -D HAVE_INTTYPES_H=1 -D HAVE_STDINT_H=1 -D HAVE_STRINGS_H=1 -D HAVE_SYS_STAT_H=1 -D HAVE_SYS_TYPES_H=1 -D HAVE_UNISTD_H=1 -D STDC_HEADERS=1 -D HAVE_LIBREADLINE=1 -D HAVE_READLINE_READLINE_H=1 -D HAVE_READLINE_HISTORY=1 -D HAVE_READLINE_HISTORY_H=1 -D USE_GLOOP_SHELL=1 -D GENERATOR_COROUTINES=0 -D HAVE_DLFCN_H=1 -D LT_OBJDIR=".libs/" -I . -D VCSVERSION="2c53e759f1e00e345f8b172e7139debda72fda13" -internal-isystem /usr/local/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-empty-body -Wno-enum-compare -Wno-missing-field-initializers -Wno-unused -Wno-unused-parameter -Wno-error=format -Wno-error=type-limits -Wno-error=strict-aliasing -Wno-sign-compare -Wno-error=shift-negative-value -Wno-error=clobbered -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2026-01-15-223856-845667-1 -x c gencpp.c
1#include "axltop.h"
2#include "genc.h"
3#include "gencpp.h"
4#include "stab.h"
5#include "store.h"
6/*
*  2006/Dec/20
*
*  Including cconfig.h to gain access to CC_SF_is_double
*/
11#include "cconfig.h"
12/*
*  Define a local macro for the C data type being used to represent
*  a single float.  We cannot just go and include the normal definition
*  because that becomes a tangle of conflicting definitions from all the
*  other files that are included as a result.
*/
18#ifdef CC_SF_is_double
19#  define SF_STRING"float" "double"
20#else
21#  define SF_STRING"float" "float"
22#endif

24localstatic String itoa_(int);

26/* ----------- GLOBAL OBJECTS ----------- */

28String CurrentClassAldor = NULL((void*)0);
29String CurrentClassCpp   = NULL((void*)0);
30const int theTRUE  = 1;
31const int theFALSE = 0;

33String commonOperators[] = { "+", "-", "/" };
34int CO_size = sizeof(commonOperators)/sizeof(String);

36/* Some types can not be used in an export statement */
37String typesToSkip[] = { "HInt", "Bool", "Char", "SFlo", "XByte" };
38int tTS_size = sizeof(typesToSkip)/sizeof(String);

40String infixOps[] = { "+", "-", "/", "*", "mod", "rem", "quo", "by", "^", 
	     "/\\", "\\/", "=", "~", "~=", "<", "<=", ">", ">=" };
42int IO_size = sizeof(infixOps)/sizeof(String);

44String cppKeywords[] = { "case", "switch", "class" };
45int CK_size = sizeof(cppKeywords)/sizeof(String);

47int globalFuncCounter = 0;
48const int TabZero = 0;

50String *basicAldorTypes;
51int bAT_size;
52String *basicCppTypes; 
53int basicHasBeenUsrDefined = 0;    /* basic type correspondence not defined yet */
54int discriminationReturnType = 0;  /* no discrimination on return type */

56#define CPPOPT_BASICFILE"basicfile=" "basicfile="           /* file containing basic type correspondence */
57#define CPPOPT_DISCRETYP"discrim-return" "discrim-return"       /* discrimination on return type for overloading */
58#define CPPOPT_NODISCRETYP"no-discrim-return" "no-discrim-return"  /* no discrimination (default) */

60/* ----------- BASIC TYPES default ------------- */

62static String defaultBasicAldorTypes[] = { 
"SingleInteger", "String", "Character", "SingleFloat", "DoubleFloat", 
"Pointer", "()", "Word", "Ptr", "Bool", "Byte", "SInt", "Char", 
"Arr", "Rec", "BInt", "DFlo" };
66static int def_bAT_size = sizeof(defaultBasicAldorTypes)/sizeof(String);

68static String defaultBasicCppTypes[]   = { 
"int", "char *", "char", SF_STRING"float", "double*",
"void *", "void", "FiWord", "FiPtr", "FiBool", "FiByte", "FiSInt", "FiChar",
"FiArr", "FiRec", "FiBInt", "FiDFlo" };

73/* ----------- DIRECTLY USED FROM genCpp -------------- */

75/* THE MAIN FUNCTION */

77void genCpp(AbSyn ab, String dir, String file) {
/* From a sequence, two jobs are done:
   1- Determination of the "type" of the node
   2- Code generation
*/

FILE *as_file, *cc_file;

if (!ab) {
1
Assuming 'ab' is non-null→
2
←
Taking false branch→
  fprintf(stderrstderr, "C++ generation can not proceed.\nAbstract Syntax tree not available.\n");
  return;
}

if (!basicHasBeenUsrDefined) InitBasicTypesArray(NULL((void*)0));
3
←
Assuming 'basicHasBeenUsrDefined' is not equal to 0→
4
←
Taking false branch→
CreateOutputFiles(dir,file,&cc_file,&as_file);

if (SequenceCheck(ab)) return;
5
←
Taking false branch→

/*  PreDeclarationOfClasses(ab,cc_file); This should not be needed anymore */
ExportGen(ab,cc_file,as_file);
6
←
Calling 'ExportGen'→
CodeGen(ab,cc_file,as_file); 

fclose(as_file);
fclose(cc_file);
101}

103int cppOption(String opt) {
String s;

if ((s = strIsPrefix(CPPOPT_BASICFILE"basicfile=", opt))) {
  if (InitBasicTypesArray(s) == -1) return -1;
  basicHasBeenUsrDefined = theTRUE;
  return 0;
} 

if (strEqual(CPPOPT_DISCRETYP"discrim-return",opt)) {
  discriminationReturnType = theTRUE;
  return 0;
}

if (strEqual(CPPOPT_NODISCRETYP"no-discrim-return",opt)) {
  discriminationReturnType = theFALSE;
  return 0;
}

return -1;
123}

125void updateBasicTypes(String s, int typeNumber) {
String current;
int lg, i, previndex;

lg = strlen(s);

/* spaces in the front */
i = 0;
while ((s[i] == ' ') && (i < lg)) i++;

/* type */
previndex = i;
while ((s[i] != ' ') && (i < lg)) i++;
basicAldorTypes[typeNumber] = strAlloc(i-previndex+1);
i = previndex;
current = basicAldorTypes[typeNumber];
while ((s[i] != ' ') && (i < lg)) {
  if (s[i] != '\n') {
    *current = s[i];
    current++;
  }
  i++;
}
*current = '\0';

/* spaces in the middle */
while ((s[i] == ' ') && (i < lg)) i++;

/* type */
previndex = i;
while ((s[i] != ' ') && (i < lg)) i++;
basicCppTypes[typeNumber] = strAlloc(i-previndex+1);
i = previndex;
current = basicCppTypes[typeNumber];
while ((s[i] != ' ') && (i < lg)) {
  if (s[i] != '\n') {
    *current = s[i];
    current++;
  }
  i++;
}
*current = '\0';
167}

169int InitBasicTypesArray(String file) {
/* If parameter is NULL, then no '-P' option has been used */
/* returned value: 0 -> ok, -1 -> problem */

FILE *basic = NULL((void*)0);
int numberOfTypes, i;
String s = strAlloc(1000);

/* Open the file */

if (file) {
  basic = fopen(file,"r");
  if (!basic) return -1;
}
else { /* no '-P' option, we have to do it ourselves */
  /* Try 'basic.typ' in the current directory */
  basic = fopen("./basic.typ","r");
  if (!basic) { /* no user defined basic types */
    /* Try in the standard directory */
    if (compRootDir) { 
String s = strPrintf("%s/include/basic.typ",compRootDir);
basic = fopen(s,"r");
    }
    if (!basic) {   /* argh ! no standard defined basic types */
/* we use the default hard-coded one */
fprintf(stderrstderr,"Unable to find basic.typ\n");
fprintf(stderrstderr,"Using default basic types correspondence\n");
basicAldorTypes = defaultBasicAldorTypes;
bAT_size = def_bAT_size;
basicCppTypes = defaultBasicCppTypes;
return 0; /* no more work to do */
    }
  }
}
  
/* Create the list */

/* 1st: how many lines in the file ? */
numberOfTypes = 0;
while (!feof(basic)) {
  IgnoreResult(fgets(s,1000,basic))if (fgets(s,1000,basic));;
  numberOfTypes++;
}
numberOfTypes--; /* there is always one extra loop, don't know why */

/* 2nd: allocation of memory */
basicAldorTypes = (String *) malloc(numberOfTypes*sizeof(String));
basicCppTypes = (String *) malloc(numberOfTypes*sizeof(String));
bAT_size = numberOfTypes;

/* 3rd: filling the arrays */
rewind(basic);
for (i = 0; i < numberOfTypes; i++) {
  IgnoreResult(fgets(s,1000,basic))if (fgets(s,1000,basic));;
  updateBasicTypes(s, i);
}

226#if !defined(NDEBUG)
fprintf(stderrstderr, " Basic types correspondence:\n");
for (i = 0; i < numberOfTypes; i++)
  fprintf(stderrstderr," [%s] and [%s]\n",basicAldorTypes[i],basicCppTypes[i]);
230#endif

strFree(s);
fclose(basic);
return 0;
235}


238void CreateOutputFiles(String dir, String file, FILE **cc, FILE **as) {
/*
  Nothing special here, we create the C++ and the Aldor files
  to output the generated code ...
*/

String s;

s = strPrintf("%s/%s_cc.h",dir,file);
*cc = fopen(s,"w+");
strFree(s);
s = strPrintf("%s/%s_as.as",dir,file);
*as = fopen(s,"w+");
strFree(s);

/* Output the headers (#include) */
fprintf(*as,"#include \"%s.as\"\n",file);
255}

257int SequenceCheck(AbSyn ab) {
/* A simple check to be sure we deal with a sequence */
if (abTag(ab)((ab)->abHdr.tag) != AB_Sequence) {
  fprintf(stderrstderr,"Should be sequence ! (node code = %d)\n",abTag(ab)((ab)->abHdr.tag));
  return 1;
}
return 0;
264}


267int DeterminationTypeOf(AbSyn ab) {
/* 
   Depending on the structure of the subtree, it is possible to
   determine a correspondence with C++ types (classes, abstract
   classes, templates, variable, function) 
*/
int typof;

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Define:
  typof = GettypDefine(ab);
  break;
case AB_Assign:
  typof = AC_VAR;
  break;
case AB_Local:
  typof = AC_VAR;
  break;
case AB_Default:
  typof = AC_VAR;
  break;
default:
  typof = AC_NONE;
  break;
}

return typof;
294}

296/* --------------------------------------------------------- */
297/*            HERE COMES THE THREE MAIN FUNCTIONS            */
298/*                                                           */
299/*    1. PreDeclarationOfClasses => class A;                 */
300/*    2. ExportGen => extern "C" and import from Foreign C   */
301/*    3. CodeGen   => classes generation and stubs           */
302/* --------------------------------------------------------- */

304void PreDeclarationOfClasses(AbSyn ab, FILE *cc) {
AbSyn tmp;
int typof,i;

/* C++ and Aldor code generation for predeclaration of classes in C++ */
for (i=0; i < abArgc(ab)((ab)->abHdr.argc); i++) {
  tmp = abSeqArg(ab,i)((ab)->abSequence.argv[(i)]);

  typof = DeterminationTypeOf(tmp);

  /* Code generation */
  switch (typof) {
  case AC_NONE:
    break;
  case AC_CLASS:
    fprintf(cc,"class %s;\n",abIdStr(abDeclareId(abDefineLhs(tmp)))((((((tmp)->abDefine.lhs))->abDeclare.id))->abId.sym
->str));
    if (abTag(abDeclareType(abDefineLhs(tmp)))((((((tmp)->abDefine.lhs))->abDeclare.type))->abHdr.
tag) == AB_With) 
fprintf(cc,"class ALDORCategory%s;\n",abIdStr(abDeclareId(abDefineLhs(tmp)))((((((tmp)->abDefine.lhs))->abDeclare.id))->abId.sym
->str));
    break;
  case AC_ABS_CLASS:
    fprintf(cc,"class %s;\n",abIdStr(abDeclareId(abDefineLhs(tmp)))((((((tmp)->abDefine.lhs))->abDeclare.id))->abId.sym
->str));
    break;
  default:
    break;
  }
}
330}

332void DebugGen(int typof) {
333#if !defined(NDEBUG)
switch (typof) {
case AC_NONE:
  break;
case AC_FUNCTION:
  fprintf(stderrstderr,"Function generation\n");
  break;
case AC_CLASS:
  fprintf(stderrstderr,"Class generation\n");
  break;
case AC_TEMPL_CLASS:
  fprintf(stderrstderr,"Template class generation\n");
  break;
case AC_ABS_CLASS:
  fprintf(stderrstderr,"Abstract class generation\n");
  /* Should not be necessary ... well maybe for the default section ...*/
  break;
case AC_ABS_TMPL_CLASS:
  fprintf(stderrstderr,"Abstract template class generation\n");
  /* Should not be necessary ... well maybe for the default section ...*/
  break;
case AC_VAR:
  fprintf(stderrstderr,"Variable generation\n");
  break;
default:
  break;
}
360#endif
361}

363void ExportGen(AbSyn ab, FILE *cc, FILE *as) {
AbSyn tmp;
int typof,i;

367#if !defined(NDEBUG)
fprintf(stderrstderr,"\n\n    IMPORT/EXPORT GENERATION    \n\n");
369#endif

fprintf(as,"export {\n");
fprintf(cc,"#include <foam_c.h>\n");
fprintf(cc,"extern \"C\" {\n");

globalFuncCounter = 0;

/* C++ and Aldor code generation for C interface */
for (i=0; i < abArgc(ab)((ab)->abHdr.argc); i++) {
7
←
Assuming 'i' is < field 'argc'→
8
←
Loop condition is true.  Entering loop body→
11
←
Assuming 'i' is < field 'argc'→
12
←
Loop condition is true.  Entering loop body→
15
←
Assuming 'i' is < field 'argc'→
16
←
Loop condition is true.  Entering loop body→
  tmp = abSeqArg(ab,i)((ab)->abSequence.argv[(i)]);

  typof = DeterminationTypeOf(tmp);

  /* Debug */
  DebugGen(typof);

  /* Code generation */
  switch (typof) {
9
←
Control jumps to 'case AC_NONE:'  at line 388→
13
←
Control jumps to 'case AC_VAR:'  at line 405→
17
←
Control jumps to 'case AC_TEMPL_CLASS:'  at line 396→
  case AC_NONE:
    break;
10
←
 Execution continues on line 378→
  case AC_FUNCTION:
    GenExportFunction(tmp,as,cc);
    break;
  case AC_CLASS:
    GenExportClass(tmp,!BL_IsTmpltheTRUE,as,cc);
    break;
  case AC_TEMPL_CLASS:
    GenExportClass(tmp,BL_IsTmpltheTRUE,as,cc);
18
←
Calling 'GenExportClass'→
    break;
  case AC_ABS_CLASS:
    /* Should not be necessary ... well maybe for the default section ...*/
    break;
  case AC_ABS_TMPL_CLASS:
    /* Should not be necessary ... well maybe for the default section ...*/
    break;
  case AC_VAR:
    break;
14
←
 Execution continues on line 378→
  default:
    break;
  }
}

fprintf(as,"} to Foreign C;\n");
fprintf(cc,"}\n");
414}

416void CodeGen(AbSyn ab, FILE *cc, FILE *as) {
AbSyn tmp;
int typof,i;

420#if !defined(NDEBUG)
fprintf(stderrstderr,"\n\n    CODE GENERATION    \n\n");
422#endif

globalFuncCounter = 0;

for (i=0; i < abArgc(ab)((ab)->abHdr.argc); i++) {
  tmp = abSeqArg(ab,i)((ab)->abSequence.argv[(i)]);

  typof = DeterminationTypeOf(tmp);

  /* Debug */
  DebugGen(typof);

  /* Code generation */
  switch (typof) {
  case AC_NONE:
    break;
  case AC_FUNCTION:
    GenFunction(tmp,as,cc);
    break;
  case AC_CLASS:
    GenClassesForDomains(tmp,theFALSE,as,cc);
    break;
  case AC_TEMPL_CLASS:
    GenClassesForDomains(tmp,theTRUE,as,cc);
    break;
  case AC_ABS_CLASS:
    GenClassForCategories(tmp,theFALSE,as,cc);
    break;
  case AC_ABS_TMPL_CLASS:
    GenClassForCategories(tmp,theTRUE,as,cc);
    break;
  case AC_VAR:
    break;
  default:
    break;
  }
}
459}

461/* ------------------------------------------------------------------- BUILDING CLASSES ---------- */

463/* ---------- ERROR ---------- */

465Class *errorBuildClass(Class *cl) {
FreeClass(cl);
return NULL((void*)0);
468}

470/* ---------- END ERROR ---------- */

472/* ---------- ID HANDLING ---------- */

474void BuildParentIdAbs(Ident *id, AbSyn ab) {
/* abTag(ab) should be AB_Apply */
String tmp;

if (abHasTag(ab,AB_Apply)((ab)->abHdr.tag == (AB_Apply))) id->basic = abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str);
else id->basic = abIdStr(ab)((ab)->abId.sym->str); /* ab is an abId */
tmp = BldId(ab);
if (!tmp) {
  id->typeAldor = strPrintf("%s",abIdStr(ab)((ab)->abId.sym->str));
  id->typeCpp   = strPrintf("%s<PercentType>",abIdStr(ab)((ab)->abId.sym->str));
  id->export = id->basic;
}
else {
  id->typeAldor = strPrintf("%s(%s)",abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),tmp);
  id->typeCpp   = strPrintf("%s<PercentType,%s>",abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),tmp);
  id->export = id->basic;
  strFree(tmp);
}
492}

494void BuildExtraClassId(Class *mother, Class *cl, int isTmpl) {
if (!isTmpl) {
  cl->id.export = cl->id.basic;
  cl->id.typeAldor = strPrintf("%s",cl->id.basic);
  cl->id.typeCpp   = strPrintf("%s<%s>",cl->id.basic,mother->id.typeCpp);
}
else {
  if ((!tfIsMulti(cl->params)(((cl->params)->tag) == TF_Multiple)) && (!tfIsDeclare(cl->params)(((cl->params)->tag) == TF_Declare))) {
    cl->id.export = cl->id.basic;
    cl->id.typeAldor = strPrintf("%s",cl->id.basic);
    cl->id.typeCpp   = strPrintf("%s<%s>",cl->id.basic,mother->id.typeCpp);
  }
  else if (tfIsDeclare(cl->params)(((cl->params)->tag) == TF_Declare)) {
    String str = symString(tfDeclareId(cl->params))((tfDeclareId(cl->params))->str);

    cl->id.export = strPrintf("%s%s", cl->id.basic, str);
    cl->id.typeCpp = strPrintf("%s<%s,%s>", cl->id.basic, mother->id.typeCpp, str);
    cl->id.typeAldor = strPrintf("%s(%s)", cl->id.basic, str);
  } 
  else {
    String str;
    String str_tmp = InitStr()strAlloc(500);
    size_t i,j;
    j = tfMultiArgc(cl->params);

    /* Create strings for the identifiers used for import/export, in C++, in Aldor */

    /* export */
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
    }
    cl->id.export = strCopy(str_tmp);

    /* typeCpp */
    str_tmp[0] = 0;
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    str_tmp = STRCAT(str_tmp,"<");
    str_tmp = STRCAT(str_tmp,mother->id.typeCpp);
    if (j) str_tmp = STRCAT(str_tmp,",");
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
if (i < j-1) str_tmp = STRCAT(str_tmp,",");
    }
    str_tmp = STRCAT(str_tmp,">");
    cl->id.typeCpp = strCopy(str_tmp);

    /* typeAldor */
    str_tmp[0] = 0;
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    str_tmp = STRCAT(str_tmp,"(");
    if (j) str_tmp = STRCAT(str_tmp,",");
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
if (i < j-1) str_tmp = STRCAT(str_tmp,",");
    }
    str_tmp = STRCAT(str_tmp,")");
    cl->id.typeAldor = strCopy(str_tmp);

    strFree(str_tmp);
  }
}
559}

561void BuildClassId(Class *cl, int isTmpl) {
if (!isTmpl37.1
'isTmpl' is 1
)
38
←
Taking false branch→
  cl->id.export = cl->id.typeAldor = cl->id.typeCpp = cl->id.basic;
else {
  size_t i,j;
  String str;

  /* Compute the lengths of the strings export and type ... */
  if ((!tfIsMulti(cl->params)(((cl->params)->tag) == TF_Multiple)) && (!tfIsDeclare(cl->params)(((cl->params)->tag) == TF_Declare))) 
39
←
Assuming field 'tag' is not equal to TF_Multiple→
40
←
Assuming field 'tag' is not equal to TF_Declare→
41
←
Taking true branch→
    cl->id.export = cl->id.typeAldor = cl->id.typeCpp = cl->id.basic;
  else if (tfIsDeclare(cl->params)(((cl->params)->tag) == TF_Declare)) {
    str = symString(tfDeclareId(cl->params))((tfDeclareId(cl->params))->str);
    cl->id.export = strPrintf("%s%s", cl->id.basic, str);
    cl->id.typeCpp = strPrintf("%s<%s>", cl->id.basic, str);
    cl->id.typeAldor = strPrintf("%s(%s)", cl->id.basic, str);
  } else {
    String str_tmp = InitStr()strAlloc(500);
    j = tfMultiArgc(cl->params);

    /* Create strings */
    
    /* export */
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
    }
    cl->id.export = strCopy(str_tmp);

    /* typeCpp */
    str_tmp[0] = 0;
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    str_tmp = STRCAT(str_tmp,"<");
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
if (i < j-1) str_tmp = STRCAT(str_tmp,",");
    }
    str_tmp = STRCAT(str_tmp,">");
    cl->id.typeCpp = strCopy(str_tmp);

    /* typeAldor */
    str_tmp[0] = 0;
    str_tmp = STRCAT(str_tmp,cl->id.basic);
    str_tmp = STRCAT(str_tmp,"(");
    for (i = 0; i < j; i++) {
str = symString(tfDeclareId(tfMultiArgN(cl->params,i)))((tfDeclareId(tfFollowArg(cl->params, i)))->str);
str_tmp = STRCAT(str_tmp,str);
if (i < j-1) str_tmp = STRCAT(str_tmp,",");
    }
    str_tmp = STRCAT(str_tmp,")");
    cl->id.typeAldor = strCopy(str_tmp);

    strFree(str_tmp);
  }
}
617}
42
←
Returning without writing to 'cl->params', which participates in a condition later→
43
←
Returning without writing to 'cl->methods'→

619String BldId(AbSyn ab) {
String result;
String tmp2 = NULL((void*)0);
int i;

if (!abHasTag(ab,AB_Apply)((ab)->abHdr.tag == (AB_Apply))) return NULL((void*)0);

result = InitStr()strAlloc(500);

for (i = 0; i < abApplyArgc(ab)(((ab)->abHdr.argc)-1); i++) {
  switch (abTag(abApplyArg(ab,i))((((ab)->abApply.argv[i]))->abHdr.tag)) {
  case AB_Id:
    if (result[0]) result = STRCAT(result,","); /* if (result[0]) then this is not the first time, so we need a comma */
    result = STRCAT(result,abIdStr(abApplyArg(ab,i))((((ab)->abApply.argv[i]))->abId.sym->str));
    break;
  case AB_Apply:
    tmp2 = BldId(abApplyArg(ab,i)((ab)->abApply.argv[i]));
    if (!tmp2) { strFree(result); return NULL((void*)0); }
    if (result[0]) result = STRCAT(result,",");  /* for the comma */
    result = STRCAT(result,abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str));
    result = STRCAT(result,"<");
    result = STRCAT(result,tmp2);
    result = STRCAT(result,">");
    strFree(tmp2);
    break;
  default:
    break;
  }
}
if (!(result[0])) { strFree(result); return NULL((void*)0); }
tmp2 = strCopy(result);
strFree(result);
return tmp2;
652}

654void BuildParentId(Ident *id, AbSyn ab) {
/* abTag(ab) should be AB_Apply */
String tmp;

if (abHasTag(ab,AB_Apply)((ab)->abHdr.tag == (AB_Apply))) {
  id->basic = abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str);
  id->export = id->basic;
  tmp = BldId(ab);
  if (tmp) {
    id->typeAldor = strPrintf("%s(%s)",abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),tmp);
    id->typeCpp = strPrintf("%s<%s,%s>",abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),CurrentClassCpp,tmp);
    strFree(tmp);
  }
}
else {
  id->basic = abIdStr(ab)((ab)->abId.sym->str); /* ab is an abId */
  id->export = id->basic;
  id->typeAldor = strPrintf("%s",abIdStr(ab)((ab)->abId.sym->str));
  id->typeCpp = strPrintf("%s<%s>",abIdStr(ab)((ab)->abId.sym->str),CurrentClassCpp);
}
674}

676/* ---------- END ID HANDLING ---------- */

678/* ---------- MAIN FUNCTIONS ---------- */

680void getParentsAbs(Class *cl, TForm tf, int isTmpl) {
AbSyn ab;
Ident *id;
int i;

switch (tfTag(tf)((tf)->tag)) {
case TF_Multiple:
  return;
case TF_General:
  if (!tfHasExpr(tf)((tf)->__absyn != 0)) return;
  ab = tfGetExpr(tf)((tf)->__absyn);
  switch (abTag(ab)((ab)->abHdr.tag)) {
  case AB_Id:
    id = alloc(Ident)(Ident *) stoAlloc(0,sizeof(Ident));
    BuildParentIdAbs(id,ab);
    Append(cl->parents,CT_PARENT,id);
    break;
  case AB_Apply:
    id = alloc(Ident)(Ident *) stoAlloc(0,sizeof(Ident));
    BuildParentIdAbs(id,ab);
    Append(cl->parents,CT_PARENT,id);
    break;
  default:
    break;
  }
  break;
case TF_With:
  getParentsAbs(cl,tfWithBase(tf)tfFollowArg(tf, 0),isTmpl);
  break;
case TF_Join:
  for (i=0; i < tfJoinArgc(tf)((tf)->argc); i++) getParentsAbs(cl,tfJoinArgN(tf,i)tfFollowArg(tf, i),isTmpl);
  break;
default:
  fprintf(stderrstderr,"Error in building class (getParents): %d\n",tfTag(tf)((tf)->tag));
  break;
}
716}

718Class *BuildAbstractClass(AbSyn ab, int isTmpl) {
/* 
   1. BuildAbstractClass is working for abTag(ab) == AB_Define
   
   2. abDefine has two parts:
   a) lhs => declaration (~ header == X: Category)
   b) rhs => definition  (~ body   == Join(Y,Z) with {...})  
 
   3. BuildClass allocates CurrentClass
*/

Class *cl;
TForm tf;

if (abTag(ab)((ab)->abHdr.tag) != AB_Define) return NULL((void*)0);

cl = InitClass();

/* ---- id */
cl->id.basic = abIdStr(abDeclareId(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abDeclare.id))->abId.sym->
str);

/* ---- Body ---- */
tf = abTUnique(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.type.unique);

/* -- params */
if (isTmpl) {
  cl->params = tfMapArg(tf)tfFollowArg(tf, 0);
  if (ToSkipClass(cl)) {
    FreeClass(cl);
    return NULL((void*)0);
  }
}

/* -- methods */
if (isTmpl) tf=tfMapRet(tf)tfFollowArg(tf, 1);
tf = tfFollowDefDecl(tf);

if (!tfIsThird(tf)(((tf)->tag) == TF_Third)) return errorBuildClass(cl);

if (!tfThdExports(tf)) {
  /* we are in this case when this is a template abstract class */
  if (!tfArgc(tf)((tf)->argc)) return errorBuildClass(cl);
  tf = tfThirdRestrictions(tf)tfFollowArg(tf, 0);
  if (!tfIsWith(tf)(((tf)->tag) == TF_With)) return errorBuildClass(cl);
  tf = tfTUnique(tf)((((tf)->__absyn))->abHdr.type.unique);
  if (!tfIsThird(tf)(((tf)->tag) == TF_Third)) return errorBuildClass(cl);
  if (!tfThdExports(tf)) return errorBuildClass(cl);
} 

/* Here tfThdExports(tf) contains all the definitions of the methods */
cl->methods = tf;

/* ---- id */
BuildClassId(cl,isTmpl);

CurrentClassCpp = "PercentType";
CurrentClassAldor = cl->id.typeAldor;

/* -- Inheritance */

tf = abTUnique(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.type.unique);

if (isTmpl) tf = tfMapRet(tf)tfFollowArg(tf, 1);
tf = tfFollowDefDecl(tf);
tf = tfThirdRestrictions(tf)tfFollowArg(tf, 0);
getParentsAbs(cl,tf,isTmpl);


/* ---- free some memory */
if (Empty(cl->extraClasses)) { stoFree(cl->extraClasses); cl->extraClasses = NULL((void*)0);} 
if (Empty(cl->parents)) { stoFree(cl->parents); cl->parents = NULL((void*)0);} /* we KNOW that cl->parents != NULL */

return cl;
791}

793Class *buildExtraClass(Class *cl, TForm tf, int isTmpl) {
String str_tmp;
String str_tmp2;
TForm tmp;
Class *extra = InitClass();

/* id */
extra->id.basic = strPrintf("ALDORCategory%s%d",cl->id.basic,cl->classCounter);

/* params */
if (isTmpl) extra->params = cl->params;

/* id is back */
BuildExtraClassId(cl,extra,isTmpl);

/* inheritance */
str_tmp = CurrentClassAldor;
str_tmp2 = CurrentClassCpp;
CurrentClassAldor = extra->id.typeAldor;
CurrentClassCpp = "PercentType";
getParents(extra,tfWithBase(tf)tfFollowArg(tf, 0),isTmpl);
CurrentClassAldor = str_tmp;
CurrentClassCpp = str_tmp2;

/* body */
tmp = tfWithWithin(tf)tfFollowArg(tf, 1);
if (!tfIsThird(tmp)(((tmp)->tag) == TF_Third)) {
  tmp = tfTUnique(tmp)((((tmp)->__absyn))->abHdr.type.unique);
  tmp = tfFollowDefDecl(tmp);
}
if (!tfIsThird(tmp)(((tmp)->tag) == TF_Third)) extra->methods = NULL((void*)0);
else extra->methods = tmp;

/* ---- free some memory */
if (Empty(extra->extraClasses)) { stoFree(extra->extraClasses); extra->extraClasses = NULL((void*)0); }
if (Empty(extra->parents))      { stoFree(extra->parents); extra->parents = NULL((void*)0); } /* we KNOW that extra->params != NULL */

return extra;
831}

833void getParents(Class *cl, TForm tf, int isTmpl) {
Class *extra;
AbSyn ab;
Ident *id;
int i;

switch (tfTag(tf)((tf)->tag)) {
47
←
Control jumps to 'case TF_With:'  at line 860→
case TF_Multiple:
  return;
case TF_General:
  if (!tfHasExpr(tf)((tf)->__absyn != 0)) return;
  ab = tfGetExpr(tf)((tf)->__absyn);
  switch (abTag(ab)((ab)->abHdr.tag)) {
  case AB_Id:
    id = alloc(Ident)(Ident *) stoAlloc(0,sizeof(Ident));
    BuildParentId(id,ab);
    Append(cl->parents,CT_PARENT,id);
    break;
  case AB_Apply:
    id = alloc(Ident)(Ident *) stoAlloc(0,sizeof(Ident));
    BuildParentId(id,ab);
    Append(cl->parents,CT_PARENT,id);
    break;
  default:
    break;
  }
  break;
case TF_With:
  extra = buildExtraClass(cl,tf,isTmpl);
48
←
Value assigned to field 'methods'→
  if (extra) {
49
←
Assuming 'extra' is null→
50
←
Taking false branch→
51
←
 Execution continues on line 862→
    Append(cl->extraClasses,CT_EXTRA,extra);      /* Create extra Class Il peut y avoir plusieurs extra classes */
    cl->classCounter++;
    Append(cl->parents,CT_PARENT,&(extra->id));
  }
  break;
case TF_Join:
  for (i=0; i < tfJoinArgc(tf)((tf)->argc); i++) getParents(cl,tfJoinArgN(tf,i)tfFollowArg(tf, i),isTmpl);
  break;
default:
  fprintf(stderrstderr,"Error in building class (getParents): %d\n",tfTag(tf)((tf)->tag));
  break;
}
875}

877Class *BuildClass(AbSyn ab, int isTmpl) {
/* 
   1. BuildClass is working for abTag(ab) == AB_Define
   
   2. abDefine has two parts:
   a) lhs => declaration (~ header == X: some category)
   b) rhs => definition  (~ body   == Y add {...})  
 
   3. BuildClass allocates CurrentClass
*/

/* Variables declaration */
Class *cl;
TForm tf, tmp;

/* Source code */
if (abTag(ab)((ab)->abHdr.tag) != AB_Define) return NULL((void*)0);
20
←
Taking false branch→

cl = InitClass();

/* ---- id */
cl->id.basic = abIdStr(abDeclareId(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abDeclare.id))->abId.sym->
str);

/* ---- Body */
tf = abTUnique(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.type.unique);

/* params */
if (isTmpl20.1
'isTmpl' is 1
) {
21
←
Taking true branch→
  cl->params = tfMapArg(tf)tfFollowArg(tf, 0);
  if (ToSkipClass(cl)) {
22
←
Calling 'ToSkipClass'→
32
←
Returning from 'ToSkipClass'→
33
←
Taking false branch→
    FreeClass(cl);
    return NULL((void*)0);
  }
}

/* Methods */
tmp = tf;
if (isTmpl33.1
'isTmpl' is 1
) tmp = tfMapRet(tmp)tfFollowArg(tmp, 1);
34
←
Taking true branch→
tmp = tfTUnique(tfFollowDefDecl(tmp))((((tfFollowDefDecl(tmp))->__absyn))->abHdr.type.unique
);
tmp = tfFollowDefDecl(tmp);

if (!tfIsThird(tmp)(((tmp)->tag) == TF_Third)) return errorBuildClass(cl);
35
←
Assuming field 'tag' is equal to TF_Third→
36
←
Taking false branch→

cl->methods = tmp;

/* ---- id */
BuildClassId(cl,isTmpl);
37
←
Calling 'BuildClassId'→
44
←
Returning from 'BuildClassId'→

CurrentClassAldor = cl->id.typeAldor;
CurrentClassCpp = cl->id.typeCpp;

/* Parents */
tmp = tf;
if (isTmpl44.1
'isTmpl' is 1
) tmp = tfMapRet(tmp)tfFollowArg(tmp, 1);
45
←
Taking true branch→
tmp = tfFollowDefDecl(tmp);
getParents(cl,tmp,isTmpl);
46
←
Calling 'getParents'→
52
←
Returning from 'getParents'→

/* ---- free some memory */
if (Empty(cl->extraClasses)) {stoFree(cl->extraClasses); cl->extraClasses = NULL((void*)0);} 
53
←
Taking true branch→
if (Empty(cl->parents)) {stoFree(cl->parents); cl->parents = NULL((void*)0);} /* we KNOW that cl->parents != NULL */
54
←
Taking true branch→

return cl;
939}

941/* ---------- END MAIN FUNCTIONS ---------- */

943/* -------------------------------------------------------------- END BUILDING CLASSES ---------- */

945/* 
946%   ------------------------------------------------
947%                 Determination part
948%   ------------------------------------------------
949*/


952cpp_types detCppType(AbSyn ab) {
TForm tf;

if (!ab) return AC_NONE;

tf = abTUnique(ab)((ab)->abHdr.type.unique); /* get the tform */

tf = tfFollowDefDecl(tf); /* get the interesting cell */

if (tfIsMap(tf)(((tf)->tag) == TF_Map)) {
  tf = tfMapRet(tf)tfFollowArg(tf, 1); /* get the return type of the Map */

  tf = tfFollowDefDecl(tf); /* get the interesting cell */

  /* param category ? */
  if (tfIsThird(tf)(((tf)->tag) == TF_Third)) return AC_ABS_TMPL_CLASS;

  /* param domain ? */
  tf = tfFollowDefDecl(tfTUnique(tf)((((tf)->__absyn))->abHdr.type.unique));
  if (tfIsThird(tf)(((tf)->tag) == TF_Third)) return AC_TEMPL_CLASS;

  /* still here ? well it is a function */
  return AC_FUNCTION;
}

/* tf is not a TF_Map */

/* category ? */
if (tfIsThird(tf)(((tf)->tag) == TF_Third)) return AC_ABS_CLASS;

/* domain ? */
tf = tfFollowDefDecl(tfTUnique(tf)((((tf)->__absyn))->abHdr.type.unique));
if (tfIsThird(tf)(((tf)->tag) == TF_Third)) return AC_CLASS;

/* still here ? well it is a constant */
return AC_CST;
988}

990cpp_types GettypDefine(AbSyn ab) {

if (abTag(ab)((ab)->abHdr.tag) == AB_Local) return AC_VAR;
if (abTag(ab)((ab)->abHdr.tag) == AB_Default) return AC_VAR;
if (abTag(ab)((ab)->abHdr.tag) != AB_Define) return AC_NONE;
/* if the object is not a definition then we can't determine the type */

997#if !defined(NDEBUG)
if (abTag(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.tag) == AB_Declare)
  fprintf(stderrstderr,"%s ",abIdStr(abDeclareId(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abDeclare.id))->abId.sym->
str));
1000#endif

return detCppType(abDefineLhs(ab)((ab)->abDefine.lhs));
1003}

1005/* Bugs and to do:
If SInt is specified without '$Machine' (using 'import from Machine;' for example), then
1007the program doesn't translate SInt to FiSInt
Multiple return with a % in the list of returned things => just crash I think
overloading discrimine sur type de retour
function pointers
default parameters
value parameters for domains (like SI or SF)
global variable
Overloading resolved only on return type is not handled.
1015*/

1017int scanForBelongsTo(String *paramList, int lgList, String toCompare) {
int i;
for (i=0 ; i < lgList; i++)
  if (!strcmp(toCompare,paramList[i])) return theTRUE;
return theFALSE;
1022}

1024int abBelongsTo(AbSyn ab, String *paramList, int lgList) {

int i;

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Id:
  return scanForBelongsTo(paramList,lgList,abIdStr(ab)((ab)->abId.sym->str));
case AB_Apply:
  if (scanForBelongsTo(paramList,lgList,abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str))) return theTRUE;
  for (i = 0; i < abApplyArgc(ab)(((ab)->abHdr.argc)-1); i++)
    if (abBelongsTo(abApplyArg(ab,i)((ab)->abApply.argv[i]),paramList,lgList)) return theTRUE;
  return theFALSE;
case AB_Nothing:
  return theFALSE;
case AB_Comma:
  for (i=0; i < abArgc(ab)((ab)->abHdr.argc); i++)
    if (abBelongsTo(abCommaArg(ab,i)((ab)->abComma.argv[(i)]),paramList,lgList)) return theTRUE;
  return theFALSE;
case AB_Qualify:
  if (abBelongsTo(ab->abQualify.what,paramList,lgList)) return theTRUE;
  if (abBelongsTo(ab->abQualify.origin,paramList,lgList)) return theTRUE;
  return theFALSE;
case AB_Declare:
  if (abBelongsTo(abDeclareType(ab)((ab)->abDeclare.type),paramList,lgList)) return theTRUE;
  return theFALSE;
default:
  return theFALSE;
}    

1053}

1055int BelongsTo(TForm type, String *paramList, int lgList) {
/* two cases: either we get an absyn from the type,
   or it is a multiple value (A,B,C) */
AbSyn ab = tfGetExpr(type)((type)->__absyn);
int i, lg;

if (ab) return abBelongsTo(ab,paramList,lgList);

if (!tfIsMulti(type)(((type)->tag) == TF_Multiple)) return theFALSE; /* we don't know how to check so it doesn't belong to it */
lg = tfMultiArgc(type);
for (i = 0; i < lg; i++)
  if (BelongsTo(tfMultiArgN(type,i)tfFollowArg(type, i),paramList,lgList)) return theTRUE;
return theFALSE;
1068}

1070int HasDependentTypes(TForm tf) {
int paramNb, returnNb;
int actualParamNb, actualReturnNb;
TForm args, rets;
String *argsList;
String *retsList;

/*
  We want to check if a function uses dependent types,
  (e.g f: (E: Type, a: E) -> E). If yes, then we will skip the function.
  To do that, we are going to consider the String values of the names
  of parameters. Here we store in an array the names of all parameters
  and then for each parameter and returned type, we check if its type
  is or uses any element of the array.
  To deal with things like:
  g: (a: E, E: Type) -> E
  we need to store all the parameters names, that is why we use an array.
*/

/* We get a pointer to the arguments and the number of arguments */
if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return theFALSE;
args = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(args)(((args)->tag) == TF_Multiple) ? tfMultiArgc(args) : 1;

/* We get a pointer to the returned values and the number of returned values */
rets = tfMapRet(tf)tfFollowArg(tf, 1);
returnNb = tfIsMulti(rets)(((rets)->tag) == TF_Multiple) ? tfMultiArgc(rets) : 1;

/* Let's fill the array for parameters */
actualParamNb = 0; 
argsList = NULL((void*)0);
if (paramNb) {
  argsList = (String *)stoAlloc(int0((int) 0),paramNb*sizeof(String));
  if (paramNb == 1) {
    if (tfIsDeclare(args)(((args)->tag) == TF_Declare)) argsList[actualParamNb++] = symString(tfDeclareId(args))((tfDeclareId(args))->str);
    /* should be a "tfDeclare", but it may be a function prototype, so if
it is not a tfDeclare we don't do anything */
  } else {
    int i;
    for (i=0 ; i<paramNb; i++) {
TForm tmp = tfMultiArgN(args,i)tfFollowArg(args, i);
if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) argsList[actualParamNb++] = symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str);
/* should be a "tfDeclare", but it may be a function prototype, so if
  it is not a tfDeclare we don't do anything */
    }
  }
  

  /* Let's check the type of the parameters */
  if (paramNb == 1) {
    if (tfIsDeclare(args)(((args)->tag) == TF_Declare))
if (BelongsTo(tfDeclareType(args)tfFollowArg(args, 0),argsList,actualParamNb)) {
 if (argsList) stoFree(argsList); 
 return theTRUE;
}
    /* should be a "tfDeclare", but it may be a function prototype, so if
it is not a tfDeclare we don't do anything */
  } else {
    int i;
    for (i=0 ; i<paramNb; i++) {
TForm tmp = tfMultiArgN(args,i)tfFollowArg(args, i);
if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) 
 if (BelongsTo(tfDeclareType(tmp)tfFollowArg(tmp, 0),argsList,actualParamNb)) {
   if (argsList) stoFree(argsList); 
   return theTRUE;
 }
/* should be a "tfDeclare", but it may be a function prototype, so if
  it is not a tfDeclare we don't do anything */
    }
  }
}


actualReturnNb = 0;
retsList = NULL((void*)0);
if (returnNb) {

  int i;
  retsList = (String *)stoAlloc(int0((int) 0),(actualParamNb+returnNb)*sizeof(String));
  
  /* we merge the list of parameters and the list of returned values */
  if (argsList) {
    for (i=0; i < actualParamNb; i++) retsList[i] = argsList[i];
    stoFree(argsList);
    argsList = NULL((void*)0);
  }

  actualReturnNb = actualParamNb;

  /* Filling array for return values */
  if (returnNb == 1) {
    if (tfIsDeclare(rets)(((rets)->tag) == TF_Declare)) retsList[actualReturnNb++] = symString(tfDeclareId(rets))((tfDeclareId(rets))->str);
    /* should be a "tfDeclare", but it may be a function prototype, so if
it is not a tfDeclare we don't do anything */
  } else {
    int i;
    for (i=0 ; i<returnNb; i++) {
TForm tmp = tfMultiArgN(rets,i)tfFollowArg(rets, i);
if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) retsList[actualReturnNb++] = symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str);
/* should be a "tfDeclare", but it may be a function prototype, so if
  it is not a tfDeclare we don't do anything */
    }
  }

  /* Let's check the return value */
  if (returnNb == 1) {
    if (BelongsTo(rets,retsList,actualReturnNb)) {
if (retsList) stoFree(retsList); 
return theTRUE;
    }
    /* should be a "tfDeclare", but it may be a function prototype, so if
it is not a tfDeclare we don't do anything */
  } else {
    int i;
    for (i=0 ; i<returnNb; i++) {
TForm tmp = tfMultiArgN(rets,i)tfFollowArg(rets, i);
if (BelongsTo(tmp,retsList,actualReturnNb)) {
 if (retsList) stoFree(retsList); 
 return theTRUE;
}
/* should be a "tfDeclare", but it may be a function prototype, so if
  it is not a tfDeclare we don't do anything */
    }
  }
}

/* Free the memory */
if (argsList) stoFree(argsList);
if (retsList) stoFree(retsList);

return theFALSE;

1202}

1204int CheckSkipClassParam(TForm tf) {
/* Does tf describe an appropriate parameter for a class ? */
/* return: theTRUE -> ok, we don't skip
           theFALSE -> not ok, we skip
*/

/* Rules:
      TF_Type => OK
TF_General
      -> Look at tfUnique in absyn of tf
             -> TF_Third => OK
      -> else NOT OK
      else NOT OK

We should thus allow regular categories and parameterized categories.
We don't allow function pointers, value, or inline categories.
*/

AbSyn ab;
TForm tmp;

if (tfIsType(tf)(((tf)->tag) == TF_Type)) return theTRUE;
if (!tfIsGeneral(tf)(((tf)->tag) == TF_General)) return theFALSE;
ab = tfGetExpr(tf)((tf)->__absyn);
if (!ab) return theFALSE; /* should not happen, it is safer to skip */
tmp = abTUnique(ab)((ab)->abHdr.type.unique);
if (!tmp) return theFALSE; /* should not happen, it is safer to skip */
tmp = tfFollowDefDecl(tmp);
if (!tmp) return theFALSE; /* should not happen, it is safer to skip */
if (!tfIsThird(tmp)(((tmp)->tag) == TF_Third)) return theFALSE; /* something we don't handle */
return theTRUE; /* TF_Third corresponds to a regular or parameterized non-inline category */
1235}

1237int ToSkipClass(Class *cl) {
/* precondition: the class cl has to be built */

/* We check if the parameters of a class are suitable 
   for the interface, we skip everything which is not
   of type non-inline category (we don't handle things like:
       A(E: with { .... }) ...
*/
/* 
   Return: theTRUE -> to skip
           theFALSE -> no skip
*/

TForm tf = cl->params;

/* if the type is not parameterized, nothing has to be done here */
if (!tf) return theFALSE;
23
←
Assuming 'tf' is non-null→

/* 
   parameters are either tfDeclare (1 param) or tfMulti (0 or more than 1 param)
   if not it is safer to skip that 
*/
if (!tfIsDeclare(tf)(((tf)->tag) == TF_Declare) && !tfIsMulti(tf)(((tf)->tag) == TF_Multiple)) return theTRUE;
24
←
Assuming field 'tag' is not equal to TF_Declare→
25
←
Assuming field 'tag' is equal to TF_Multiple→
26
←
Taking false branch→

if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare))
27
←
Taking false branch→
  return (!CheckSkipClassParam(tfDeclareType(tf)tfFollowArg(tf, 0)));
else {
  int i = 0;
  int sizeMulti = tfMultiArgc(tf);

  for ( i=0 ; i < sizeMulti ; i++) {
28
←
Assuming 'i' is >= 'sizeMulti'→
29
←
Loop condition is false. Execution continues on line 1273→
    TForm tmp = tfMultiArgN(tf,i)tfFollowArg(tf, i);
    if (!tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) return theTRUE; /* should not happen, safer to skip */
    if (!CheckSkipClassParam(tfDeclareType(tmp)tfFollowArg(tmp, 0))) return theTRUE;
  }
}
return theFALSE;
30
←
Returning without writing to '->params', which participates in a condition later→
31
←
Returning without writing to '->methods'→
1274}

1276int ToSkip(TForm tf) {
int paramNb, returnNb;
TForm args, rets;

/*
  We want to check if a function uses forbidden types,
  for that we use the array typesToSkip.
*/

/* We get a pointer to the arguments and the number of arguments */
if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return theFALSE;
args = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(args)(((args)->tag) == TF_Multiple) ? tfMultiArgc(args) : 1;

/* We get a pointer to the returned values and the number of returned values */
rets = tfMapRet(tf)tfFollowArg(tf, 1);
returnNb = tfIsMulti(rets)(((rets)->tag) == TF_Multiple) ? tfMultiArgc(rets) : 1;

if (paramNb) {
  if (paramNb == 1) {
    if (tfIsDeclare(args)(((args)->tag) == TF_Declare)) {
if (BelongsTo(tfDeclareType(args)tfFollowArg(args, 0),typesToSkip,tTS_size)) return theTRUE;
    } else {
if (BelongsTo(args,typesToSkip,tTS_size)) return theTRUE;
    }
    /* should be a "tfDeclare", but it may be a function prototype, so if
it is not a tfDeclare we don't do anything */
  } else {
    int i;
    for (i=0 ; i<paramNb; i++) {
TForm tmp = tfMultiArgN(args,i)tfFollowArg(args, i);
if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) {
 if (BelongsTo(tfDeclareType(tmp)tfFollowArg(tmp, 0),typesToSkip,tTS_size)) return theTRUE;
} else {
 if (BelongsTo(tmp,typesToSkip,tTS_size)) return theTRUE;
}
    }
  }
}

if (!returnNb) return theFALSE;

if (returnNb == 1) {
  if (tfIsDeclare(rets)(((rets)->tag) == TF_Declare)) {
    if (BelongsTo(tfDeclareType(rets)tfFollowArg(rets, 0),typesToSkip,tTS_size)) return theTRUE;
  } else {
    if (BelongsTo(rets,typesToSkip,tTS_size)) return theTRUE;
  }
} else {
  int i;
  for (i=0 ; i<returnNb; i++) {
    TForm tmp = tfMultiArgN(rets,i)tfFollowArg(rets, i);
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) {
if (BelongsTo(tfDeclareType(tmp)tfFollowArg(tmp, 0),typesToSkip,tTS_size)) return theTRUE;
    } else {
if (BelongsTo(tmp,typesToSkip,tTS_size)) return theTRUE;
    }
  }
}

return theFALSE;
1337}

1339/* ---------- FUNCTION SIGNATURES ---------- */

1341String GenAldorFnSig(TForm tf, String name, Class *cl, int tab, int isExported, int usePercent, int useTmplParms) {
String str_tmp,result;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

if (HasDependentTypes(tf)) return NULL((void*)0);
if (ToSkip(tf)) return NULL((void*)0);

result = InitStr()strAlloc(500);

/* Function id */
result = sprintTab(result,tab);
str_tmp = GenAldorFuncName(name,cl,isExported);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); result = STRCAT(result,": ");
strFree(str_tmp);

/* Parameters */
str_tmp = GenAldorParams(tf,cl,BL_WithTypetheTRUE,!BL_WithNametheTRUE,!BL_InBodytheTRUE,usePercent,useTmplParms);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); 
strFree(str_tmp);

/* Return values */
str_tmp = TFormToAldor(tfMapRet(tf)tfFollowArg(tf, 1),usePercent);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result," -> "); 
result = STRCAT(result,str_tmp); 
result = STRCAT(result,";\n");
strFree(str_tmp);

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
1375}

1377String GenCppFnSig(TForm tf, String name, Class *cl, int tab, int isExported) {
String str_tmp;
TForm tmp;
String result;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

if (HasDependentTypes(tf)) return NULL((void*)0);
if (ToSkip(tf)) return NULL((void*)0);

result = InitStr()strAlloc(500);

result = sprintTab(result,tab);  

/* return */
tmp = tfMapRet(tf)tfFollowArg(tf, 1);
if (tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple)) result = STRCAT(result,"void"); /* means multiple return or no return */
else if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { strFree(result); return NULL((void*)0); }
else if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { strFree(result); return NULL((void*)0); }
else {
  /* If we have function pointers, this is a special case */
  if (tfIsFuncPtr(tmp))
    result = STRCAT(result, "void *");
  else {
    str_tmp = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    if (AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn)))
result = STRCAT(result,"void *"); 
    /* currently (maybe for a long time !) it is void * and not the actual type,
because: 1) it is easier 2) we don't need any type checking ... */
    else
result = STRCAT(result,str_tmp); 
    strFree(str_tmp);
  }
}

result = STRCAT(result," ");

str_tmp = createFnIdExternC(name,cl);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

str_tmp = GenCppParams(tf,cl,BL_WithTypetheTRUE,!BL_WithNametheTRUE,BL_IsStatictheTRUE,!BL_AbstracttheTRUE,BL_ExporttheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); result = STRCAT(result,";\n");
strFree(str_tmp);

if (strstr(result, "fputc") != NULL((void*)0))
{
  str_tmp = InitStr()strAlloc(500);
  STRCAT(str_tmp, "extern int fputc();\n");
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
1434}

1436/* ---------- END FUNCTION SIGNATURES ---------- */

1438/* ---------- STUBS ---------- */

1440String GenAldorStubs(TForm tf, String name, Class *cl, int Global, int tab) {
String result,str_tmp;
int isInfix;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

if (HasDependentTypes(tf)) return NULL((void*)0);
if (ToSkip(tf)) return NULL((void*)0);

result = InitStr()strAlloc(500);

/* function id */
result = sprintTab(result,tab);  
str_tmp = GenAldorFuncName(name,cl,BL_ExportedtheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

/* params */
str_tmp = GenAldorParams(tf,cl,BL_WithTypetheTRUE,BL_WithNametheTRUE,!BL_InBodytheTRUE,!BL_UsePercenttheTRUE,BL_UseTmplParmstheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); result = STRCAT(result,": ");
strFree(str_tmp);

/* return */
str_tmp = TFormToAldor(tfMapRet(tf)tfFollowArg(tf, 1),theFALSE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); result = STRCAT(result," == ");
strFree(str_tmp);

/* body */

/* -- header */
result = STRCAT(result,"{ \n");
result = sprintTab(result,tab+1);
if (!Global) {
  str_tmp = OutputDomNameAldor(cl->id.typeAldor);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"import from "); result = STRCAT(result,str_tmp); result = STRCAT(result,";\n");
  strFree(str_tmp);
  result = sprintTab(result,tab+1);
}

/* -- id */

/* ---- output */
isInfix = IsInfixOperator(name);

if (!isInfix) {

  String s = AldorifySpeSym(name);
  result = STRCAT(result,s);
  strFree(s);

  /* -- params */
  str_tmp = GenAldorParams(tf,cl,!BL_WithTypetheTRUE,BL_WithNametheTRUE,BL_InBodytheTRUE,!BL_UsePercenttheTRUE,BL_UseTmplParmstheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);

} else { /* Operator is infix */

  int nbParams,cnt;
  tf = tfMapArg(tf)tfFollowArg(tf, 0);
  nbParams = tfIsMulti(tf)(((tf)->tag) == TF_Multiple) ? tfMultiArgc(tf) : 1;

  /* nbParams == 1 or 2 */
  if (nbParams == 1) {
    result = STRCAT(result,name);
    cnt = 0;
    str_tmp = GenAldorOneParam(tf,!BL_WithTypetheTRUE,BL_WithNametheTRUE,cnt,!BL_UsePercenttheTRUE);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result," ("); result = STRCAT(result,str_tmp); result = STRCAT(result,")");
    strFree(str_tmp);
  } 
  else if (nbParams != 2) { strFree(result); return NULL((void*)0); }
  else { 
    /* output first param */
    cnt = 0;
    str_tmp = GenAldorOneParam(tfMultiArgN(tf,(Length) 0)tfFollowArg(tf, (Length) 0),!BL_WithTypetheTRUE,BL_WithNametheTRUE,cnt,!BL_UsePercenttheTRUE);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,"("); result = STRCAT(result,str_tmp); result = STRCAT(result,") ");
    strFree(str_tmp);
    
    /* output name */
    result = STRCAT(result, name);

    /* output second param */
    cnt = 1;
    str_tmp = GenAldorOneParam(tfMultiArgN(tf,1)tfFollowArg(tf, 1),!BL_WithTypetheTRUE,BL_WithNametheTRUE,cnt,!BL_UsePercenttheTRUE);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result," ("); result = STRCAT(result,str_tmp); result = STRCAT(result,")");
    strFree(str_tmp);
  }

}

result = STRCAT(result,";\n");
result = sprintTab(result,tab);
result = STRCAT(result,"}\n");

return result;
1541}

1543/* ---------- END STUBS ---------- */

1545/* ---------- GLOBAL FUNCTIONS ---------- */

1547/* Check multiple return, params, ... for function pointers */

1549/* Create the String corresponding to function pointer parameters */
1550String GenCppFunc_ParamsRetFnPtr(TForm tf, Class *cl, int isStatic, int abstract, int export) {
TForm retType;
String result, str_tmp, str_tmp2;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);
retType = tfMapRet(tf)tfFollowArg(tf, 1);
if (!tfIsFuncPtr(retType)) {
  /* base case */
  str_tmp = GenCppParams(tf,cl,BL_WithTypetheTRUE,!BL_WithNametheTRUE,isStatic,abstract,export);
  if (!str_tmp) return NULL((void*)0);
  result = InitStr()strAlloc(500);
  result = STRCAT(result,")"); result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
else {
  str_tmp2 = GenCppFunc_ParamsRetFnPtr(tfMapRet(tf)tfFollowArg(tf, 1),cl,isStatic,abstract,export);
  str_tmp = GenCppParams(tf,cl,BL_WithTypetheTRUE,!BL_WithNametheTRUE,isStatic,abstract,export);
  if (!str_tmp) return NULL((void*)0);
  result = InitStr()strAlloc(500);
  result = STRCAT(result,")"); result = STRCAT(result,str_tmp);
  result = STRCAT(result,str_tmp2);
  strFree(str_tmp);
  strFree(str_tmp2);
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
1578}

1580/* Create the String corresponding to a function pointer return value */
1581String GenCppFunc_RetFnPtr(TForm tf) {
String result;
String str_tmp;
TForm retType;
AbSyn ab;

if (!tfIsFuncPtr(tf)) {
  /* base case: if ab is not a function pointer, 
     then we translate directly */
  ab = tfGetExpr(tf)((tf)->__absyn);
  if (!ab) return NULL((void*)0);
  str_tmp = AbSynToCpp(ab);
  if (!str_tmp) return NULL((void*)0);
  result = InitStr()strAlloc(500);
  result = STRCAT(result,str_tmp); 
  if (AbSynIsUserDef(ab)) result = STRCAT(result,"*");
  strFree(str_tmp);
}
else {
  /* general case: if the return type is a function pointer,
     we call recursively the function */
  retType = tfMapRet(tf)tfFollowArg(tf, 1);
  str_tmp = GenCppFunc_RetFnPtr(retType);
  if (!str_tmp) return NULL((void*)0);
  result = InitStr()strAlloc(500);
  result = STRCAT(result,str_tmp); result = STRCAT(result,"(*");
  strFree(str_tmp);
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
1613}

1615String GenCppFunc(TForm tf, String name, Class *cl, int tab) {
TForm tmp;
String result, typeToAddToName = NULL((void*)0);
String str_tmp;
int flagIsFnPtr = theFALSE;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map))           return NULL((void*)0);
if (HasDependentTypes(tf))  return NULL((void*)0);
if (ToSkip(tf))             return NULL((void*)0);

result = InitStr()strAlloc(500);

result = sprintTab(result,tab);

/* Return */
tmp = tfMapRet(tf)tfFollowArg(tf, 1);
flagIsFnPtr = theFALSE;
if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { strFree(result); return NULL((void*)0); }
else if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { strFree(result); return NULL((void*)0); }
else if (tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple)) {
  result = STRCAT(result,"void ");
  if (discriminationReturnType) {
    typeToAddToName = InitStr()strAlloc(500);
    typeToAddToName = STRCAT(typeToAddToName,"void");
  }
}
else {
  /* There will be no discrimation on the return type, if the return type
     is a function pointer */
  if (tfIsFuncPtr(tmp)) {
    flagIsFnPtr = theTRUE;
    str_tmp = GenCppFunc_RetFnPtr(tmp);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
  }
  else {
    str_tmp = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    if (discriminationReturnType) {
typeToAddToName = InitStr()strAlloc(500);
typeToAddToName = STRCAT(typeToAddToName,str_tmp);
    }
    result = STRCAT(result,str_tmp); result = STRCAT(result," ");
    if (AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn))) {
result = STRCAT(result,"*");
if (discriminationReturnType) typeToAddToName = STRCAT(typeToAddToName,"*");
    }
    strFree(str_tmp);
  }
}

/* Function name */
str_tmp = createFnIdForCPP(name,NULL((void*)0));
if (!str_tmp) result = STRCAT(result,name);
else { result = STRCAT(result,name); strFree(str_tmp); }

if (discriminationReturnType) {
  String ToAdd = transOperatorLike(typeToAddToName);
  result = STRCAT(result,"_");
  result = STRCAT(result,ToAdd);
  strFree(typeToAddToName);
  strFree(ToAdd);
}

/* Params */
str_tmp = GenCppParams(tf,NULL((void*)0),BL_WithTypetheTRUE,BL_WithNametheTRUE,BL_IsStatictheTRUE,!BL_AbstracttheTRUE,!BL_ExporttheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp); 
strFree(str_tmp); 

/* Parameters of the return type if the return type is a function pointer */
if (flagIsFnPtr) {
  str_tmp = GenCppFunc_ParamsRetFnPtr(tmp,NULL((void*)0),BL_IsStatictheTRUE,!BL_AbstracttheTRUE,!BL_ExporttheTRUE);
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}

/* Body */
str_tmp = GenCppBodyForMethods(tf,name,NULL((void*)0));
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
1701}

1703void GenFunction(AbSyn ab, FILE *as, FILE *cc) {
String toOutputAS, toOutputCC;
String name;
TForm tf;

/* --- Init --- */
tf = abTUnique(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.type.unique);
name = abIdStr(abDefineLhs(abDeclareId(ab)))((((((ab)->abDeclare.id))->abDefine.lhs))->abId.sym->
str);
CurrentClassAldor = "Global";
CurrentClassCpp = "Global";

/* --- Aldor --- */
toOutputAS = GenAldorStubs(tf,name,NULL((void*)0),BL_GlobaltheTRUE,TabZero);

/* --- C++ --- */
toOutputCC = GenCppFunc(tf,name,NULL((void*)0),TabZero);

CurrentClassAldor = NULL((void*)0);
CurrentClassCpp = NULL((void*)0);

if (toOutputAS && toOutputCC) { 
  fprintf(as,"%s",toOutputAS); 
  fprintf(cc,"%s",toOutputCC); 
  strFree(toOutputAS);
  strFree(toOutputCC);
  globalFuncCounter++;
} else {
  if (toOutputAS) strFree(toOutputAS);
  if (toOutputCC) strFree(toOutputCC);
}
1733}

1735/* ---------- END GLOBAL FUNCTIONS ---------- */

1737/* ---------- HEADER ---------- */

1739void GenCppConstructors(Class *cl, int tab, FILE *cc) {
printTab(cc,tab);
fprintf(cc,"%s() { ptr = 0; }\n",cl->id.basic);
printTab(cc,tab);
fprintf(cc,"%s(%s",cl->id.basic,cl->id.typeCpp);
fprintf(cc," *orig) { ptr = orig; }\n");
printTab(cc,tab);
fprintf(cc,"%s(void *orig) { ptr = reinterpret_cast<%s",cl->id.basic,cl->id.typeCpp);
fprintf(cc," *>(orig); }\n");
1748}

1750void GenCppDestructor(String name, int tab, FILE *cc) {
printTab(cc,tab);
fprintf(cc,"virtual ~%s() {}\n",name);
1753}

1755void GenCppAccessToRealObj(Class *cl, int tab, FILE *cc) {
printTab(cc,tab);
fprintf(cc,"friend %s",cl->id.typeCpp);
fprintf(cc," *realObject(%s",cl->id.typeCpp);
fprintf(cc," *ob) { return ob->ptr; }\n");
1760}

1762void GenCppGiveType(Class *cl, int tab, FILE *cc) {
printTab(cc,tab);
fprintf(cc,"static void *givetype() { return ");
fprintf(cc,"ALDOR_givetype_%s(",cl->id.export);
if (cl->params) {
  int i;
  TForm tmp = cl->params;
  int paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare))
fprintf(cc,"%s::givetype()",symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
  } 
  else 
    for (i=0;i<paramNb;i++) {
TForm tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare))
 fprintf(cc,"%s::givetype()",symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
if (i < paramNb-1) fprintf(cc,",");
    }
}
fprintf(cc,"); }\n");
1783}

1785void GenHeaderForClass(Class *cl, FILE *cc) {
TForm tmp;
int paramNb;
int i;

/* template */
if (cl->params) {
  fprintf(cc,"template <");
  tmp = cl->params;
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) 
fprintf(cc,"class %s",symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
  }
  else 
    for (i=0;i<paramNb;i++) {
TForm tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) 
 fprintf(cc,"class %s",symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
if (i < paramNb-1) fprintf(cc,",");
    }
  fprintf(cc,">\n");
}

/* class */
fprintf(cc,"class %s",cl->id.basic);
if (NotEmpty(cl->parents)) {
  fprintf(cc,": ");
  Rewind(cl->parents);
  while (!EOList(cl->parents)) {
    Ident *id = (Ident *)GetItem(cl->parents);
    fprintf(cc," virtual public %s",id->typeCpp);
    GotoNext(cl->parents);
    if (!EOList(cl->parents)) fprintf(cc,",");
  }
}

/* standard members */
fprintf(cc," {\n");
fprintf(cc,"\t%s *ptr;\n",cl->id.typeCpp);
fprintf(cc,"public:\n");
GenCppConstructors(cl,1,cc);
GenCppDestructor(cl->id.basic,1,cc);
GenCppAccessToRealObj(cl,1,cc);
GenCppGiveType(cl,1,cc);
1830}

1832/* ---------- END HEADER ---------- */

1834/* ---------- CLASS ---------- */

1836void GenExtraClass(Class *cl, Class *extra, FILE *cc) {
String str_tmp;
String saveCurrent;
SymeList meths;
Syme meth;

saveCurrent = CurrentClassCpp;
CurrentClassCpp = "PercentType";

/* parameters of the class */
str_tmp = GCFC_HeaderTmpl(cl);
if (!str_tmp) return; 
fprintf(cc,"%s",str_tmp);
strFree(str_tmp);

/* header */
fprintf(cc,"class %s",extra->id.basic);

/* inheritance */
str_tmp = GCFC_HeaderInher(extra);
if (!str_tmp) return; 
fprintf(cc,"%s",str_tmp);
strFree(str_tmp);

fprintf(cc," {\n");
fprintf(cc,"public:\n");
fprintf(cc,"\tvirtual ~%s() {}\n",extra->id.basic);

/* methods */  

if (!extra->methods) { 
  fprintf(cc,"};\n"); 
  CurrentClassCpp = saveCurrent; 
  return; 
}

extra->methCounter = 0;
meths = tfThdExports(extra->methods) ? tfThdExports(extra->methods):tfParents(extra->methods)((extra->methods)->parents);
for (; meths; meths = meths->rest) {
  meth = meths->first;

  str_tmp = GCFC_Methods(extra,meth);
  if (!str_tmp) continue;
  fprintf(cc,"%s",str_tmp);
  strFree(str_tmp);

  extra->methCounter++;
} 

fprintf(cc,"};\n");
CurrentClassCpp = saveCurrent;
1887}


1890void GenClassesForDomains(AbSyn ab, int isTmpl, FILE *as, FILE *cc) {

/*
  Class generation
  ===================
  Creation of an intermediate "Class" structure
  Code generation
  Intermediate struct is freed
*/


/*
  Regular types:
  -------------
  A: ACat with { .... } == add { ... }
  gets to
  class CategoryA: virtual public ACat {
  public:
  ....
  };
  class A: virtual public CategoryA {
  public:
  ...
  };
   
  Parameterized types:
  -------------------
  A(T: TCat): ACat(T) with { .... } == add { ... }
  gets to
  template <class T>
  class CategoryA: virtual public ACat {
  public:
  ....
  };
  template <class T>
  class A: virtual public CategoryA<T> {
  public:
  ...
  };
*/


Class  *cl;
SymeList meths;
String str_tmp;

cl =  BuildClass(ab,isTmpl);
if (!cl) return;

/* ----- Generation ------ */

/* /// ALDOR stubs for methods /// */
if (cl->methods) {
  cl->methCounter = 0;
  meths = tfThdExports(cl->methods) ? tfThdExports(cl->methods):tfParents(cl->methods)((cl->methods)->parents);
  for (; meths; meths = meths->rest) {
    str_tmp = GenAldorStubs(symeType(meths->first),symString(symeId(meths->first))((((meths->first)->id))->str),cl,!BL_GlobaltheTRUE,TabZero);
    if (str_tmp) { fprintf(as,"%s",str_tmp); strFree(str_tmp); cl->methCounter++; }
  }
}

/* /// C++ classes /// */

/* Extra Class Generation */

if (NotEmpty(cl->extraClasses)) {
  for (Rewind(cl->extraClasses); !EOList(cl->extraClasses); GotoNext(cl->extraClasses))
    GenExtraClass(cl,(Class *)GetItem(cl->extraClasses),cc);
}

/* Header */
GenHeaderForClass(cl,cc);

/* methods */
if (cl->methods)
  GenMethodsForClass(cl,cc);

/* End of the class */
fprintf(cc,"};\n");

/* Free the memory */
CurrentClassAldor = NULL((void*)0);
CurrentClassCpp = NULL((void*)0);
FreeClass(cl);
1974}


1977/*
 
 ----------------------------------------------------
 ----------- GENERATION ABS.CLASS/CLASS ------------- 
 ----------------------------------------------------
 
 */

1985String GCFC_HeaderTmpl(Class *cl) {
String str_tmp, result = InitStr()strAlloc(500);
TForm tmp = cl->params;
int paramNb;

/* To replace % in the declaration ... */
result = STRCAT(result,"template <class PercentType"); 

/* For parameterized types */
if (tmp) {
  result = STRCAT(result,",");
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) {
result = STRCAT(result,"class ");
result = STRCAT(result,symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
    }
  }
  else {
    int i;
    for (i=0;i<paramNb;i++) {
TForm tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) {
 result = STRCAT(result,"class ");
 result = STRCAT(result,symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
}
if (i < paramNb-1) result = STRCAT(result,",");
    }
  }
}

/* end of template part */
result = STRCAT(result,">\n");

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2022}

2024String GCFC_HeaderInher(Class *cl) {
MyList *parents = cl->parents;
String str_tmp, result = InitStr()strAlloc(500);

if (NotEmpty(parents)) {
  result = STRCAT(result,": ");
  Rewind(parents);
  while (!EOList(parents)) {
    Parent *par = (Parent *)GetItem(parents);
    result = STRCAT(result," virtual public ");
    result = STRCAT(result,par->id.typeCpp);
    GotoNext(parents);
    if (!EOList(cl->parents)) result = STRCAT(result,",");
  }
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2043}

2045String GCFC_Methods(Class *cl, Syme method) {
String str_tmp, result;
int flagIsFnPtr = theFALSE;
String typeToAddToName = NULL((void*)0);
int isStatic = theFALSE;
TForm tmp;

/* Check if method has to be output */
if (!method) return NULL((void*)0);
if (strEqual(symString(symeId(method))((((method)->id))->str),"%%")) return NULL((void*)0);
if (HasDependentTypes(symeType(method)))      return NULL((void*)0);
if (ToSkip(symeType(method)))                 return NULL((void*)0);
if (!tfIsMap(symeType(method))(((symeType(method))->tag) == TF_Map))               return NULL((void*)0);

/* Static or not ? */
isStatic = StaticOrNot(tfMapArg(symeType(method))tfFollowArg(symeType(method), 0),cl);
if (isStatic) return NULL((void*)0);

/* Return type */
tmp = tfMapRet(symeType(method))tfFollowArg(symeType(method), 1);

if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit))      return NULL((void*)0);
if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) return NULL((void*)0);

result = InitStr()strAlloc(500);
flagIsFnPtr = theFALSE;

if (tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple)) {
  result = STRCAT(result,"\tvirtual void ");
  if (discriminationReturnType) {
    typeToAddToName = InitStr()strAlloc(500);
    typeToAddToName = STRCAT(typeToAddToName,"void");
  }
}
else if (tfIsFuncPtr(tmp)) {
  flagIsFnPtr = theTRUE;
  str_tmp = GenCppFunc_RetFnPtr(tmp);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"\tvirtual "); 
  result = STRCAT(result,str_tmp);
} 
else {
  str_tmp = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  if (discriminationReturnType) {
    typeToAddToName = InitStr()strAlloc(500);
    typeToAddToName = STRCAT(typeToAddToName,str_tmp);
  }
  result = STRCAT(result,"\tvirtual ");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result," ");
  if (AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn))) {
    result = STRCAT(result,"*");
    if (discriminationReturnType) typeToAddToName = STRCAT(typeToAddToName,"*");
  }
  strFree(str_tmp);
}

/* Function name */
str_tmp = createFnIdForCPP(symString(symeId(method))((((method)->id))->str),cl);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result," "); result = STRCAT(result,str_tmp);
strFree(str_tmp);

if (discriminationReturnType) {
  String ToAdd = transOperatorLike(typeToAddToName);
  result = STRCAT(result,"_");
  result = STRCAT(result,ToAdd);
  strFree(typeToAddToName);
  strFree(ToAdd);
}

/* Parameters */
str_tmp = GenCppParams(symeType(method),cl,BL_WithTypetheTRUE,!BL_WithNametheTRUE,isStatic,BL_AbstracttheTRUE,!BL_ExporttheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

/* Parameters of the return type if the return type is a function pointer */
if (flagIsFnPtr) {
  str_tmp = GenCppFunc_ParamsRetFnPtr(tmp,cl,BL_IsStatictheTRUE,BL_AbstracttheTRUE,!BL_ExporttheTRUE);
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
result = STRCAT(result," = 0;\n");

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2134}

2136void GenClassForCategories(AbSyn ab, int isTmpl, FILE *as, FILE *cc) {

/*
  Class generation
  ===================
  Creation of an intermediate "Class" structure
  Code generation
  Intermediate struct is freed
*/

Class  *cl;
SymeList meths;
Syme meth;
String str_tmp;

/* ----- Creation of struct ----- */

cl = BuildAbstractClass(ab,isTmpl);
if (!cl) return;

/* There should be no aldor code generated because, there is no function
   call and so no stub needed */

/* C++ class generation */

/* ---- HEADER */

/* Header params */
str_tmp = GCFC_HeaderTmpl(cl);
if (!str_tmp) { 
  FreeClass(cl); 
  CurrentClassAldor = NULL((void*)0); 
  CurrentClassCpp = NULL((void*)0); 
  return; 
}
fprintf(cc,"%s",str_tmp);
strFree(str_tmp);

/* Header name of class */
fprintf(cc,"class %s",cl->id.basic);

/* Header inheritance */
str_tmp = GCFC_HeaderInher(cl);
if (!str_tmp) { 
  FreeClass(cl); 
  CurrentClassAldor = NULL((void*)0); 
  CurrentClassCpp = NULL((void*)0); 
  return; 
}
fprintf(cc,"%s",str_tmp);
strFree(str_tmp);

/* Header standard */
fprintf(cc," {\n");
fprintf(cc,"public:\n");
fprintf(cc,"\tvirtual ~%s() {}\n",cl->id.basic);

/* ---- METHODS */

/* no method ? */
if (!cl->methods) { 
  fprintf(cc,"};\n"); 
  CurrentClassAldor = NULL((void*)0); 
  CurrentClassCpp = NULL((void*)0); 
  FreeClass(cl); 
  return;
}

/* output methods */
cl->methCounter = 0;
meths = tfThdExports(cl->methods) ? tfThdExports(cl->methods):tfParents(cl->methods)((cl->methods)->parents);
for (; meths; meths = meths->rest) {
  meth = meths->first;
  
  str_tmp = GCFC_Methods(cl,meth);
  if (!str_tmp) continue;
  fprintf(cc,"%s",str_tmp);
  strFree(str_tmp);

  cl->methCounter++;
} 

/* the end */
fprintf(cc,"};\n");
CurrentClassAldor = NULL((void*)0);
CurrentClassCpp = NULL((void*)0);
FreeClass(cl);
2223}

2225/* ---------- END CLASS ---------- */

2227/* ---------- EXPORT / IMPORT ---------- */

2229void GenExportClass(AbSyn ab, int isTmpl, FILE *as, FILE *cc) {

Class *cl;
SymeList l;
Syme item;
String toOutputAS, toOutputCC;

cl = BuildClass(ab,isTmpl);
19
←
Calling 'BuildClass'→
55
←
Returning from 'BuildClass'→
if (!cl55.1
'cl' is non-null
) return;
56
←
Taking false branch→

/* tfTag(cl->methods) => TF_Third */
/* two cases: cl->methods->parents or cl->methods->thdExports */

if (!(cl->methods)) l = NULL((void*)0);
57
←
Assuming field 'methods' is null→
58
←
Taking true branch→
else l = tfThdExports(cl->methods) ? tfThdExports(cl->methods):tfParents(cl->methods)((cl->methods)->parents);

for (; l; l = l->rest) {
59
←
Loop condition is false. Execution continues on line 2270→

  item = l->first;
  if (strEqual(symString(symeId(item))((((item)->id))->str),"%%")) continue;
  
  /* --- ALDOR Export --- */
  toOutputAS = GenAldorFnSig(symeType(item),symString(symeId(item))((((item)->id))->str),
	       cl,1,BL_ExportedtheTRUE,!BL_UsePercenttheTRUE,BL_UseTmplParmstheTRUE);
  
  /* --- C++ extern --- */
  if (toOutputAS) 
    toOutputCC = GenCppFnSig(symeType(item),symString(symeId(item))((((item)->id))->str),cl,1,BL_ExportedtheTRUE);
  else
    toOutputCC = 0;
  
  if (toOutputAS && toOutputCC) {
    fprintf(as,"%s",toOutputAS); 
    fprintf(cc,"%s",toOutputCC); 
    strFree(toOutputAS);
    strFree(toOutputCC);
    cl->methCounter++;
  }
}

/* "givetype" function for the class */
GenGiveTypeForExport(cl,as,cc);
60
←
Calling 'GenGiveTypeForExport'→

/* Memory stuff */
FreeClass(cl);
2274}


2277void GenExportFunction(AbSyn ab, FILE *as, FILE *cc) {
String toOutputAS, toOutputCC;
TForm tf;
String name;

/* --- Init --- */
tf = abTUnique(abDefineLhs(ab))((((ab)->abDefine.lhs))->abHdr.type.unique);
name = abIdStr(abDefineLhs(abDeclareId(ab)))((((((ab)->abDeclare.id))->abDefine.lhs))->abId.sym->
str);

/* --- ALDOR Export --- */
toOutputAS = GenAldorFnSig(tf,name,NULL((void*)0),1,BL_ExportedtheTRUE,!BL_UsePercenttheTRUE,BL_UseTmplParmstheTRUE);

/* --- C++ extern --- */  
toOutputCC = GenCppFnSig(tf,name,NULL((void*)0),1,BL_ExportedtheTRUE);

if (toOutputAS && toOutputCC) { 
  fprintf(as,"%s",toOutputAS); 
  fprintf(cc,"%s",toOutputCC); 
  strFree(toOutputAS);
  strFree(toOutputCC);
  globalFuncCounter++;
} else {
  if (toOutputAS) strFree(toOutputAS);
  if (toOutputCC) strFree(toOutputCC);
} 
2302}

2304/* ---------- END EXPORT / IMPORT ---------- */

2306/* ---------- METHODS ---------- */

2308String GenCppBodyForMethods(TForm tf, String name, Class *cl) {
int isStatic;
int returnIsUsrDef;		/* if the return type is a user defined type then we need a 'new' */
int returnIsFnPtr;
AbSyn ab;
String result,str_tmp;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

result = InitStr()strAlloc(500);

/* Static or not ? */
if (!cl) isStatic = theTRUE;
else isStatic = StaticOrNot(tfMapArg(tf)tfFollowArg(tf, 0),cl);

/* body */
ab = tfGetExpr(tfMapRet(tf))((tfFollowArg(tf, 1))->__absyn);
returnIsUsrDef = AbSynIsUserDef(ab);
returnIsFnPtr = tfIsFuncPtr(tfMapRet(tf)tfFollowArg(tf, 1));
result = STRCAT(result," { ");

/* -- if multiple return, declare appropriate variables */
if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  str_tmp = GenCppMultiRetLocalDecl(tf,BL_WithTypetheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"\n");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result,"\n");
}

/* -- call the stub */
if (!AbSynIsVoid(ab) && !tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) result = STRCAT(result,"return ");

if (returnIsUsrDef) {
  str_tmp = AbSynToCpp(ab);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"new "); result = STRCAT(result,str_tmp); result = STRCAT(result,"(");
  strFree(str_tmp);
}
else if (returnIsFnPtr) {
  str_tmp = outputCppFnPtrParms(tfMapRet(tf)tfFollowArg(tf, 1),cl,theTRUE,theFALSE,!BL_UsePercenttheTRUE,!BL_ExporttheTRUE, NULL((void*)0));
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"(");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result,")");
  strFree(str_tmp);
}

str_tmp = createFnIdExternC(name,cl);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

if (!cl)
  str_tmp = GenCppParams_Global_Body(tf,name);
else
  str_tmp = GenCppParams_Body(tf,name,cl,isStatic);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

if (returnIsUsrDef) result = STRCAT(result,")");

result = STRCAT(result,"; ");

/* -- Multiple return: assign real variables */
if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  str_tmp = GenCppMultiRetAssign(tf);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
}

result = sprintTab(result,1);
result = STRCAT(result,"}\n");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2385}

2387String GenCppBodyStaticPercentForMethods(Syme meth, Class *cl, int posPercent, int export) {
int returnIsUsrDef;		/* if the return type is a user defined type then we need a 'new' */
AbSyn ab;
String result,str_tmp;
TForm tf = symeType(meth);
String name = symString(symeId(meth))((((meth)->id))->str);

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

result = InitStr()strAlloc(500);

/* body */
ab = tfGetExpr(tfMapRet(tf))((tfFollowArg(tf, 1))->__absyn);
returnIsUsrDef = AbSynIsUserDef(ab);
result = STRCAT(result," { ");

/* -- if multiple return, declare appropriate variables */
if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  str_tmp = GenCppMultiRetLocalDecl(tf,BL_WithTypetheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"\n");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result,"\n");
}

/* -- call the stub */
if (!AbSynIsVoid(ab) && !tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) result = STRCAT(result,"return ");

if (export && returnIsUsrDef) {
  str_tmp = AbSynToCpp(ab);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"new "); result = STRCAT(result,str_tmp); result = STRCAT(result,"(");
  strFree(str_tmp);
}

/* -- object */
if (export) {
  str_tmp = createFnIdExternC(name,cl);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
} else {
  String str_tmp2 = createFnIdForCPP(name,cl);
  str_tmp = itoa_(posPercent-1);
  result = STRCAT(result,"parm");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result,"->");
  result = STRCAT(result,str_tmp2);
  strFree(str_tmp2);
  strFree(str_tmp);
}

if (export)
  str_tmp = GenCppParamsBody_VirtualForStatic(tf,cl,posPercent);
else
  str_tmp = GenCppParamsStaticPercent(tf,cl,!BL_WithTypetheTRUE,BL_WithNametheTRUE,posPercent,export);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

if (export && returnIsUsrDef) result = STRCAT(result,")");

result = STRCAT(result,"; ");

/* -- Assign real variables */
if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  str_tmp = GenCppMultiRetAssign(tf);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
}

result = sprintTab(result,1);
result = STRCAT(result,"}\n");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2463}

2465String GenTwisterFunction(Class *cl, Syme meth, int posPercent) {
String result, str_tmp;
TForm tmp;

result = InitStr()strAlloc(500);

/* generation of the extra "twister" function */
result = STRCAT(result,"protected:\n\tvirtual ");

/* Return type */
tmp = tfMapRet(symeType(meth))tfFollowArg(symeType(meth), 1);
if (tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple)) result = STRCAT(result,"void ");
else {
  str_tmp = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  result = STRCAT(result," ");
  if (AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn)))
    result = STRCAT(result," *");
  strFree(str_tmp);
}

/* Function name */
str_tmp = createFnIdForCPP(symString(symeId(meth))((((meth)->id))->str),cl);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result," "); result = STRCAT(result,str_tmp);
strFree(str_tmp);

/* Parameters */
str_tmp = GenCppParamsStaticPercent(symeType(meth),cl,BL_WithTypetheTRUE,BL_WithNametheTRUE,posPercent,!BL_ExportedtheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

/* Body */
str_tmp = GenCppBodyStaticPercentForMethods(meth,cl,posPercent,BL_ExportedtheTRUE);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);

/* the end */
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2509}


2512void GenMethodsForClass(Class *cl, FILE *cc) {
String str_tmp;
SymeList meths;
Syme meth;
TForm tmp;
String result, typeToAddToName = NULL((void*)0);
int isStatic, posPercent;
int flagIsFnPtr = theFALSE;

if (!cl->methods) return;

result = InitStr()strAlloc(500);

cl->methCounter = 0;
meths = tfThdExports(cl->methods) ? tfThdExports(cl->methods):tfParents(cl->methods)((cl->methods)->parents);
for (; meths; meths = meths->rest) {
  meth = meths->first;

  if (strEqual(symString(symeId(meth))((((meth)->id))->str),"%%")) { *result = '\0'; continue; }
  if (HasDependentTypes(symeType(meth))) { *result = '\0'; continue; }
  if (ToSkip(symeType(meth))) { *result = '\0'; continue; }
  if (!tfIsMap(symeType(meth))(((symeType(meth))->tag) == TF_Map)) { *result = '\0'; continue; }

  /* Static or not ? */
  isStatic = StaticOrNot(tfMapArg(symeType(meth))tfFollowArg(symeType(meth), 0),cl);
  posPercent = PercentsInParms(tfMapArg(symeType(meth))tfFollowArg(symeType(meth), 0),cl);

  /* Static or virtual */
  result = STRCAT(result, isStatic ? "\tstatic " : "\tvirtual ");

  /* Return type */
  tmp = tfMapRet(symeType(meth))tfFollowArg(symeType(meth), 1);
  flagIsFnPtr = theFALSE;
  if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { *result = '\0'; continue; }
  else if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { *result = '\0'; continue; }
  else if (tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple)) {
    result = STRCAT(result,"void ");
    if (discriminationReturnType) {
typeToAddToName = InitStr()strAlloc(500);
typeToAddToName = STRCAT(typeToAddToName,"void");
    }
  }
  else {
    if (tfIsFuncPtr(tmp)) {
flagIsFnPtr = theTRUE;
str_tmp = GenCppFunc_RetFnPtr(tmp);
if (!str_tmp) { *result = '\0'; continue; }
result = STRCAT(result,str_tmp);
    } else {
str_tmp = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));
if (!str_tmp) { *result = '\0'; continue; }
if (discriminationReturnType) {
 typeToAddToName = InitStr()strAlloc(500);
 typeToAddToName = STRCAT(typeToAddToName,str_tmp);
}
result = STRCAT(result,str_tmp);
result = STRCAT(result," ");
if (AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn))) {
 result = STRCAT(result,"*");
 if (discriminationReturnType) typeToAddToName = STRCAT(typeToAddToName,"*");
}
strFree(str_tmp);
    }
  }

  /* Function name */
  str_tmp = createFnIdForCPP(symString(symeId(meth))((((meth)->id))->str),cl);
  if (!str_tmp) { *result = '\0'; continue; }
  result = STRCAT(result," "); result = STRCAT(result,str_tmp);
  strFree(str_tmp);

  if (discriminationReturnType) {
    String ToAdd = transOperatorLike(typeToAddToName);
    result = STRCAT(result,"_");
    result = STRCAT(result,ToAdd);
    strFree(typeToAddToName);
    strFree(ToAdd);
  }

  /* Parameters */
  str_tmp = GenCppParams(symeType(meth),cl,BL_WithTypetheTRUE,BL_WithNametheTRUE,isStatic,BL_AbstracttheTRUE,!BL_ExporttheTRUE);
  if (!str_tmp) { *result = '\0'; continue; }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);

  /* Parameters of the return type if the return type is a function pointer */
  if (flagIsFnPtr) {
    str_tmp = GenCppFunc_ParamsRetFnPtr(tmp,NULL((void*)0),BL_IsStatictheTRUE,!BL_AbstracttheTRUE,!BL_ExporttheTRUE);
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
  }

  /* Body */
  if (!isStatic || !posPercent) {
    str_tmp = GenCppBodyForMethods(symeType(meth),symString(symeId(meth))((((meth)->id))->str),cl);
    if (!str_tmp) { *result = '\0'; continue; }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
  } else {
    /* body for static function with a % at position posPercent */
    str_tmp = GenCppBodyStaticPercentForMethods(meth,cl,posPercent,!BL_ExportedtheTRUE);
    if (!str_tmp) { *result = '\0'; continue; }
    result = STRCAT(result,str_tmp);
    result = STRCAT(result,"\n");
    strFree(str_tmp);

    /* twister function */
    str_tmp = GenTwisterFunction(cl,meth,posPercent);
    if (!str_tmp) { *result = '\0'; continue; }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    result = STRCAT(result,"\npublic:\n");
  }

  fprintf(cc,"%s",result);
  *result = '\0';
  cl->methCounter++;
}
strFree(result);
2631}

2633/* ---------- END METHODS ---------- */

2635/* ---------- MULTIPLE RETURN ---------- */

2637String GenCppMultiRetLocalDecl(TForm tf, int withType) {
int i;
AbSyn tmp;
String str_tmp,str_tmp2;
String result;
int cnt = 0;

if (!tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) return NULL((void*)0);

result = InitStr()strAlloc(500);

tf = tfMapRet(tf)tfFollowArg(tf, 1);

for (i=0; i < tfMultiArgc(tf); i++) {

  tmp = tfGetExpr(tfMultiArgN(tf,i))((tfFollowArg(tf, i))->__absyn);

  switch(abTag(tmp)((tmp)->abHdr.tag)) {
  case AB_Declare:
    if (!abHasTag(abDeclareType(tmp),AB_Id)((((tmp)->abDeclare.type))->abHdr.tag == (AB_Id))) { strFree(result); return NULL((void*)0); }
    str_tmp = RealTypeString(abDeclareType(tmp)((tmp)->abDeclare.type),!BL_ExporttheTRUE);
    if (!strEqual(str_tmp,"void *")) str_tmp[strlen(str_tmp) - 1] = '\0';
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    str_tmp2 = itoa_(cnt);
    if (!withType) {
result = STRCAT(result,"&local");
result = STRCAT(result,str_tmp2);
    } else {
result = STRCAT(result,str_tmp);
result = STRCAT(result," local");
result = STRCAT(result,str_tmp2);
    }
    strFree(str_tmp2);
    cnt++;
    strFree(str_tmp);
    break;
  case AB_Id:
    str_tmp = RealTypeString(tmp,!BL_ExporttheTRUE);
    if (!strEqual(str_tmp,"void *")) str_tmp[strlen(str_tmp) - 1] = '\0';
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    str_tmp2 = itoa_(cnt);
    if (!withType) {
result = STRCAT(result,"&local");
result = STRCAT(result,str_tmp2);
    } else {
result = STRCAT(result,str_tmp);
result = STRCAT(result," local");
result = STRCAT(result,str_tmp2);
    }
    strFree(str_tmp2);
    cnt++;
    strFree(str_tmp);
    break;
  case AB_Apply:
    str_tmp2 = itoa_(cnt);
    if (!withType) {
result = STRCAT(result,"&local");
result = STRCAT(result,str_tmp2);
    } else {
result = STRCAT(result,"void *local");
result = STRCAT(result,str_tmp2);
    }
    strFree(str_tmp2);
    cnt++;
    break;
  default:
    fprintf(stderrstderr,"GenCppMultiRetLocalDecl - Wrong tag - %d\n",abTag(tmp)((tmp)->abHdr.tag));
    strFree(result); return NULL((void*)0);
    break;
  }
  if (!withType && (i < tfMultiArgc(tf) - 1)) result = STRCAT(result,",");
  else if (withType) result = STRCAT(result,";");
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2714}

2716String GenCppMultiRetAssign(TForm tf) {
int i, isUsrDef;
AbSyn tmp;
String str_tmp,str_tmp2,str_tmp3;
String result;
int cnt = 0;
  

if (!tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) return NULL((void*)0);

result = InitStr()strAlloc(500);

result = STRCAT(result,"\n");

cnt = tfMapArgc(tf) - 1;	/* we give numbers to the params by beginning with 0 */
   
tf = tfMapRet(tf)tfFollowArg(tf, 1);

for (i=0; i < tfMultiArgc(tf); i++,cnt++) {

  tmp = tfGetExpr(tfMultiArgN(tf,i))((tfFollowArg(tf, i))->__absyn);
  str_tmp3 = itoa_(i);    
  switch(abTag(tmp)((tmp)->abHdr.tag)) {
  case AB_Declare:
    if (!abHasTag(abDeclareType(tmp),AB_Id)((((tmp)->abDeclare.type))->abHdr.tag == (AB_Id))) { strFree(result); return NULL((void*)0); }
    isUsrDef = AbSynIsUserDef(abDeclareType(tmp)((tmp)->abDeclare.type));
    str_tmp2 = itoa_(cnt);
    if (!isUsrDef) {
result = STRCAT(result,"*parm");
result = STRCAT(result,str_tmp2);
result = STRCAT(result," = local");
result = STRCAT(result,str_tmp3);
result = STRCAT(result,"; ");
    } else {      
str_tmp = AbSynToCpp(abDeclareType(tmp)((tmp)->abDeclare.type));
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,"*parm");
result = STRCAT(result,str_tmp2);
result = STRCAT(result," = new ");
result = STRCAT(result,str_tmp);
result = STRCAT(result,"(local");
result = STRCAT(result,str_tmp3);
result = STRCAT(result,"); ");
strFree(str_tmp);
    }
    strFree(str_tmp2);
    strFree(str_tmp3);
    break;
  case AB_Id:
    isUsrDef = AbSynIsUserDef(tmp);
    str_tmp2 = itoa_(cnt);
    if (!isUsrDef) {
result = STRCAT(result,"*parm");
result = STRCAT(result,str_tmp2);
result = STRCAT(result," = local");
result = STRCAT(result,str_tmp3);
result = STRCAT(result,"; ");
    } else {      
str_tmp = AbSynToCpp(tmp);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,"*parm");
result = STRCAT(result,str_tmp2);
result = STRCAT(result," = new ");
result = STRCAT(result,str_tmp);
result = STRCAT(result,"(local");
result = STRCAT(result,str_tmp3);
result = STRCAT(result,"); ");
strFree(str_tmp);
    }
    strFree(str_tmp2);
    strFree(str_tmp3);
    break;
  case AB_Apply:
    fprintf(stderrstderr,"Function pointers in a multiple return value are not handled ...\n");
    strFree(result); return NULL((void*)0);
    break;
  default:
    fprintf(stderrstderr,"GenCppMultiRetAssign - Wrong tag - %d\n",abTag(tmp)((tmp)->abHdr.tag));
    strFree(result); return NULL((void*)0);
    break;
  }
}

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2802}


2805String GenCppMultiRet(TForm tf, int withType, int withName, int cnt, int export) {
int i;
AbSyn tmp;
String str_tmp,str_tmp2,str_tmp3;
String result;

result = InitStr()strAlloc(500);

tf = tfMapRet(tf)tfFollowArg(tf, 1);

for (i=0; i < tfMultiArgc(tf); i++) {

  tmp = tfGetExpr(tfMultiArgN(tf,i))((tfFollowArg(tf, i))->__absyn);
  str_tmp2 = itoa_(cnt);
  str_tmp3 = itoa_(i);
  switch(abTag(tmp)((tmp)->abHdr.tag)) {
  case AB_Declare:
    if (!abHasTag(abDeclareType(tmp),AB_Id)((((tmp)->abDeclare.type))->abHdr.tag == (AB_Id))) { strFree(result); return NULL((void*)0); }
    str_tmp = RealTypeString(abDeclareType(tmp)((tmp)->abDeclare.type),export);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }

    if (withName && withType) {
result = STRCAT(result,str_tmp);
result = STRCAT(result," parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withName) {
result = STRCAT(result,"parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withType)
result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  case AB_Id:
    str_tmp = RealTypeString(tmp,export);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }

    if (withName && withType) {
result = STRCAT(result,str_tmp);
result = STRCAT(result," parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withName) {
result = STRCAT(result,"parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withType)
result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  case AB_Apply:

    if (withName && withType) {
result = STRCAT(result,"void *parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withName) {
result = STRCAT(result,"parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
cnt++;
    } else if (withType)
result = STRCAT(result,"void *");
    break;
  default:
    fprintf(stderrstderr,"GenCppMultiRet - Wrong tag - %d\n",abTag(tmp)((tmp)->abHdr.tag));
    strFree(result); return NULL((void*)0);
    break;
  }
  if (i < (tfMultiArgc(tf) - 1)) result = STRCAT(result,",");
}
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2885}

2887/* ---------- END MULTIPLE RETURN ---------- */

2889/* ---------- PARAMS HANDLING ---------- */

2891/* -- Common Code for Aldor -- */

2893String outputAldorTmplParms(TForm tf, int usePercent) {
String result, str_tmp;

/* check */
if (!tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) return NULL((void*)0);

/* parameter */ 
result = InitStr()strAlloc(500);
result = STRCAT(result,symString(tfDeclareId(tf))((tfDeclareId(tf))->str));
result = STRCAT(result,": ");
str_tmp = TFormToAldor(tfDeclareType(tf)tfFollowArg(tf, 0),usePercent);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
2910}

2912String outputAldorRegParms(TForm tf, int withType, int withName, int usePercent, String cnt, String result) {
/* return: 0 - no problem / 1 - error */
String str_tmp;

/* Type -> String */
if (tfIsGeneral(tf)(((tf)->tag) == TF_General)) 
  str_tmp = TFormToAldor(tf,usePercent);
else if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) 
  str_tmp = TFormToAldor(tfDeclareType(tf)tfFollowArg(tf, 0),usePercent);
else { 
  strFree(result); 
  return NULL((void*)0); 
}

/* output */
if (!str_tmp) { strFree(result); return NULL((void*)0); }

if (withName && withType) { 
  result = STRCAT(result,"parm");
  result = STRCAT(result,cnt);
  result = STRCAT(result,": "); 
  result = STRCAT(result,str_tmp); 
}
else if (withName) {
  result = STRCAT(result,"parm");
  result = STRCAT(result,cnt);
}
else if (withType) 
  result = STRCAT(result,str_tmp);

strFree(str_tmp);
return result;
2944}

2946/* -- End Common Code for Aldor -- */

2948/* -- Aldor Params -- */

2950String GenAldorParams(TForm tf, Class *cl, int withType, int withName, int inBody, int usePercent, int useTmplParms) {
String str_tmp;
String result,str_tmp2;
int cnt;
int paramNb;
TForm tmp = NULL((void*)0);
TForm tmp2 = NULL((void*)0);
int i;

result = InitStr()strAlloc(500);

result = STRCAT(result,"(");

/* Template params */
if (cl && useTmplParms) {
  tmp = cl->params;
  if (tmp && !inBody) {
    int i;
    paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
    if (paramNb == 1)	{ /* TF_Declare */
str_tmp = outputAldorTmplParms(tmp, usePercent);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result, str_tmp);
strFree(str_tmp);
    }
    else			/* TF_Multiple */
for (i=0;i<paramNb;i++) {
 tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
 str_tmp = outputAldorTmplParms(tmp2, usePercent);
 if (!str_tmp) { strFree(result); return NULL((void*)0); }
 result = STRCAT(result, str_tmp);
 strFree(str_tmp);
 if (i < paramNb-1) result = STRCAT(result,",");
}
  }
}

/* Regular params */
tf = tfMapArg(tf)tfFollowArg(tf, 0);

paramNb = tfIsMulti(tf)(((tf)->tag) == TF_Multiple) ? tfMultiArgc(tf) : 1;
if (paramNb && useTmplParms && cl && tmp && !inBody) result = STRCAT(result,",");
if (paramNb == 1) {		/* TF_Declare ou TF_General */
  result = outputAldorRegParms(tf,withType,withName,usePercent,"0",result);
  if (!result) return NULL((void*)0);
}
else 
  for (i=0,cnt = 0; i < paramNb; i++, cnt++) {
    tmp = tfMultiArgN(tf,i)tfFollowArg(tf, i);
    str_tmp2 = itoa_(cnt);
    result = outputAldorRegParms(tmp,withType,withName,usePercent,str_tmp2,result);
    strFree(str_tmp2);
    if (!result) return NULL((void*)0);
    if (i < paramNb-1) result = STRCAT(result,",");
  }

result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3010}

3012String GenAldorOneParam(TForm tf, int withType, int withName, int cnt, int usePercent) {
String result = NULL((void*)0), str_tmp;

if (tfIsGeneral(tf)(((tf)->tag) == TF_General)) str_tmp = TFormToAldor(tf,usePercent);
else if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) str_tmp = TFormToAldor(tfDeclareType(tf)tfFollowArg(tf, 0),usePercent);
else return NULL((void*)0);

if (!str_tmp) return NULL((void*)0);

if (withName && withType) result = strPrintf("parm%d: %s",cnt,str_tmp);
else if (withName) result = strPrintf("parm%d",cnt);
else if (withType) result = strCopy(str_tmp);

strFree(str_tmp);

return result;
3028}

3030/* -- End Aldor Params -- */

3032/* -- Common Code for C++ -- */

3034String outputCppFnPtrParms(TForm tf, Class *cl, int withType, int withName, int usePercent, int export, String cnt) {
String result, str_tmp;

result = InitStr()strAlloc(500);

if (withName && withType) {
  str_tmp = GenCppFunc_RetFnPtr(tf);
  result = STRCAT(result,str_tmp);
  result = STRCAT(result," parm");
  result = STRCAT(result,cnt);
  strFree(str_tmp);
  str_tmp = GenCppFunc_ParamsRetFnPtr(tf,cl,!usePercent,!BL_AbstracttheTRUE, export); 
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
else if (withName){
  result = STRCAT(result,"parm");
  result = STRCAT(result,cnt);
} 
else if (withType) {
  str_tmp = GenCppFunc_RetFnPtr(tf);
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  str_tmp = GenCppFunc_ParamsRetFnPtr(tf,cl,!usePercent,!BL_AbstracttheTRUE, export);
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
} 

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3065}


3068String outputCppRegParms(TForm tf, Class *cl, int withType, int withName, int usePercent, int export, String cnt, String result) {
/* return: 0 - no problem / 1 - error */
String str_tmp, str_tmp2;
int isUsrDef;
int flagFnPtr = theFALSE;

if (tfIsGeneral(tf)(((tf)->tag) == TF_General)) {
  if (tfIsFuncPtr(tf)) {
    flagFnPtr = theTRUE;
    str_tmp2 = outputCppFnPtrParms(tf, cl, withType, withName, usePercent, export, cnt);
  }
  else
    str_tmp2 = AbSynToCpp(tfGetExpr(tf)((tf)->__absyn));
  isUsrDef = AbSynIsUserDef(tfGetExpr(tf)((tf)->__absyn));
} else if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) {
  if (tfIsFuncPtr(tfDeclareType(tf)tfFollowArg(tf, 0))) {
    flagFnPtr = theTRUE;
    str_tmp2 = outputCppFnPtrParms(tfDeclareType(tf)tfFollowArg(tf, 0), cl, withType, withName, usePercent, export, cnt);
  }
  else
    str_tmp2 = AbSynToCpp(tfGetExpr(tfDeclareType(tf))((tfFollowArg(tf, 0))->__absyn));
  isUsrDef = AbSynIsUserDef(tfGetExpr(tfDeclareType(tf))((tfFollowArg(tf, 0))->__absyn));
} else { 
  strFree(result); 
  return NULL((void*)0); 
}

if (!str_tmp2) { strFree(result); return NULL((void*)0); }

if (flagFnPtr) 
  str_tmp = strCopy(str_tmp2);
else {
  if (!isUsrDef) str_tmp = strCopy(str_tmp2);
  else str_tmp = export ? strCopy("void *") : strPrintf("%s *",str_tmp2);
}

strFree(str_tmp2);

/* output param */
if (!str_tmp) { strFree(result); return NULL((void*)0); }

if (flagFnPtr)
  result = STRCAT(result,str_tmp);
else {
  if (withName && withType) {
    result = STRCAT(result,str_tmp);
    result = STRCAT(result," parm");
    result = STRCAT(result,cnt);
  }
  else if (withName){
    result = STRCAT(result,"parm");
    result = STRCAT(result,cnt);
  } else if (withType)
    result = STRCAT(result,str_tmp);
}

strFree(str_tmp);

return result;
3127}

3129/* -- End Common Code for C++ -- */

3131/* -- C++ Params -- */

3133String GenCppParams(TForm tf, Class *cl, int withType, int withName, int isStatic, int abstract, int export) {

String str_tmp, str_tmp2;
String result;
int cnt = 0;
int paramNb,start;
TForm tmp = NULL((void*)0), tmp2;

result = InitStr()strAlloc(500);

result = STRCAT(result,"(");

/* Template params */
if (cl) {
  tmp = cl->params;
  if (tmp && export) {
    int i;
    paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
    for (i=0;i<paramNb;i++) {
result = STRCAT(result,"void *");
if (i < paramNb-1) result = STRCAT(result,",");
    }
  }
}
  
/* Regular params */
tmp2 = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(tmp2)(((tmp2)->tag) == TF_Multiple) ? tfMultiArgc(tmp2) : 1;
start = 0;

/* First parameter is special */
if (paramNb) {
  /* If the function is a method (i.e not static) then if we are in class the first parameter is not output */
  if (!export && !isStatic) start++;

  /* If some parameters have been output before (for templates) then we need a comma */
  if (cl && tmp && export) result = STRCAT(result,",");
}

if ((paramNb == 1) && (!start)) {
  result = outputCppRegParms(tmp2,cl,withType,withName,!BL_UsePercenttheTRUE, export, "0", result);
  if (!result) return NULL((void*)0);
} else if (paramNb > 1) {
  for (cnt = 0; start < paramNb; start++,cnt++) {
    tmp = tfMultiArgN(tmp2,start)tfFollowArg(tmp2, start);
    if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { strFree(result); return NULL((void*)0); }
    else if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { strFree(result); return NULL((void*)0); }
    str_tmp2 = itoa_(cnt);
    result = outputCppRegParms(tmp,cl,withType,withName,!BL_UsePercenttheTRUE, export, str_tmp2, result);
    strFree(str_tmp2);
    if (!result) return NULL((void*)0);
    if (start < paramNb - 1) result = STRCAT(result,",");
  }
}

if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  if (paramNb) result = STRCAT(result,",");
  str_tmp = GenCppMultiRet(tf,withType,withName,cnt,export);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3199}

3201String GenCppParamsBody_VirtualForStatic(TForm tf, Class *cl, int posPercent) {

String str_tmp;
String result;
int isUsrDef;
int paramNb,start;
TForm tmp = NULL((void*)0), tmp2;

result = InitStr()strAlloc(500);

result = STRCAT(result,"(");

/* Template params */
if (cl->params) {
  int i;
  tmp = cl->params;
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) { 
result = STRCAT(result,symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
result = STRCAT(result,"::givetype()");
    } else { fprintf(stderrstderr,"Error in GenGivetype (tmpl params): %d\n",tfTag(tmp)((tmp)->tag)); }
  } 
  else 
    for (i=0;i<paramNb;i++) {
TForm tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) { 
 result = STRCAT(result,symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
 result = STRCAT(result,"::givetype()");
} else { fprintf(stderrstderr,"Error in GenGivetype (tmpl params): %d\n",tfTag(tmp)((tmp)->tag)); }
if (i < paramNb-1) result = STRCAT(result,",");
    }
}

/* Regular params */
tmp = NULL((void*)0);
tmp2 = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(tmp2)(((tmp2)->tag) == TF_Multiple) ? tfMultiArgc(tmp2) : 1;
  
if (paramNb && (cl->params)) result = STRCAT(result,",");

/* paramNb > 1 because we call this function for the body of the extra protected virtual method
   created if we have a function with a % not in first position */


for (start = 0; start < paramNb; start++) {      
  
  /* Is it the position of the first % parameter ? */
  if (start == posPercent - 1) {
    if (start < (paramNb-1)) result = STRCAT(result,"ptr,");
    else result = STRCAT(result,",ptr");
    continue;
  }
    
  /* get the parameter */
  tmp = tfMultiArgN(tmp2,start)tfFollowArg(tmp2, start);
    
  if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { strFree(result); return NULL((void*)0); }
  if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { strFree(result); return NULL((void*)0); }
    
  isUsrDef = AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn));
  
  /* output param */
  str_tmp = itoa_(start);
  if (isUsrDef) {
    result = STRCAT(result,"realObject(parm");
    result = STRCAT(result,str_tmp);
    result = STRCAT(result,")");
  } else {
    result = STRCAT(result,"parm");
    result = STRCAT(result,str_tmp);
  }
  strFree(str_tmp);
    
  if (start < (paramNb-2)) result = STRCAT(result,",");
  else if ((start == (paramNb-2)) && (posPercent != paramNb)) result = STRCAT(result,",");
}

if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  if (paramNb) result = STRCAT(result,",");
  str_tmp = GenCppMultiRet(tf,!BL_WithTypetheTRUE,BL_WithNametheTRUE,start,!BL_ExportedtheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3290}

3292String GenCppParamsStaticPercent(TForm tf, Class *cl, int withType, int withName, int posPercent, int export) {

String str_tmp, str_tmp2;
String result;
int isUsrDef;
int paramNb,start;
TForm tmp = NULL((void*)0), tmp2;

result = InitStr()strAlloc(500);

result = STRCAT(result,"(");

/* Regular params */
tmp2 = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(tmp2)(((tmp2)->tag) == TF_Multiple) ? tfMultiArgc(tmp2) : 1;
start = 0;

if (posPercent == 1) start++;

if ((paramNb == 1) && (!start)) {
  if (tfIsGeneral(tmp2)(((tmp2)->tag) == TF_General)) {
    str_tmp2 = AbSynToCpp(tfGetExpr(tmp2)((tmp2)->__absyn));
    isUsrDef = AbSynIsUserDef(tfGetExpr(tmp2)((tmp2)->__absyn));
  } else if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) {
    str_tmp2 = AbSynToCpp(tfGetExpr(tfDeclareType(tmp2))((tfFollowArg(tmp2, 0))->__absyn));
    isUsrDef = AbSynIsUserDef(tfGetExpr(tfDeclareType(tmp2))((tfFollowArg(tmp2, 0))->__absyn));
  } else { 
    strFree(result); 
    return NULL((void*)0); 
  }

  if (!str_tmp2) { strFree(result); return NULL((void*)0); }

  str_tmp =  (isUsrDef) ? strPrintf("%s *",str_tmp2) : strCopy(str_tmp2);

  if (withName && withType) { result = STRCAT(result,str_tmp); result = STRCAT(result," parm0");  }
  else if (withName) { result = STRCAT(result,"parm0"); }
  else if (withType) { result = STRCAT(result,str_tmp); }
  strFree(str_tmp);
  strFree(str_tmp2);
} else if (paramNb > 1) {
  for (; start < paramNb; start++) {      

    if (start == posPercent - 1) {
if (export) {
 if (start < (paramNb-1)) result = STRCAT(result,"ptr,");
 else result = STRCAT(result,",ptr");
}
continue;
    }

    tmp = tfMultiArgN(tmp2,start)tfFollowArg(tmp2, start);

    if (tfIsExit(tmp)(((tmp)->tag) == TF_Exit)) { strFree(result); return NULL((void*)0); }
    if (tfIsGenerator(tmp)(((tmp)->tag) == TF_Generator)) { strFree(result); return NULL((void*)0); }

    str_tmp2 = AbSynToCpp(tfGetExpr(tmp)((tmp)->__absyn));

    if (!str_tmp2) { strFree(result); return NULL((void*)0); }
    isUsrDef = AbSynIsUserDef(tfGetExpr(tmp)((tmp)->__absyn));
    
    /* init type name */
    str_tmp = isUsrDef ? strPrintf("%s *",str_tmp2) : strCopy(str_tmp2);
    
    strFree(str_tmp2);

    str_tmp2 = itoa_(start);

    /* output param */
    if (withName && withType) {
result = STRCAT(result,str_tmp);
result = STRCAT(result," parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
    }
    else if (withName){
result = STRCAT(result,"parm");
result = STRCAT(result,str_tmp2);
strFree(str_tmp2);
    }
    else if (withType)
result = STRCAT(result,str_tmp);

    strFree(str_tmp);

    if (start < (paramNb-2)) result = STRCAT(result,",");
    else if ((start == (paramNb-2)) && (posPercent != paramNb)) result = STRCAT(result,",");
  }
}

if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  if (paramNb) result = STRCAT(result,",");
  str_tmp = GenCppMultiRet(tf,withType,withName,start,!BL_ExportedtheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}
result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3393}

3395String GenCppParams_Body(TForm tf, String name, Class *cl, int isStatic) {
TForm tmp;
int cnt = 0;
int start;
int paramNb;
String result, str_tmp;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

result = InitStr()strAlloc(500);

result = STRCAT(result,"(");

/* Template params */
if (cl->params) {
  int i;
  tmp = cl->params;
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) { 
result = STRCAT(result,symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
result = STRCAT(result,"::givetype()");
    } else { fprintf(stderrstderr,"Error in GenGivetype (tmpl params): %d\n",tfTag(tmp)((tmp)->tag)); }
  } 
  else 
    for (i=0;i<paramNb;i++) {
TForm tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) { 
 result = STRCAT(result,symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
 result = STRCAT(result,"::givetype()");
} else { fprintf(stderrstderr,"Error in GenGivetype (tmpl params): %d\n",tfTag(tmp)((tmp)->tag)); }
if (i < paramNb-1) result = STRCAT(result,",");
    }
}

/* First parameter is special */
tmp = tfMapArg(tf)tfFollowArg(tf, 0);
paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
start = 0;
if (paramNb) {
  if (cl->params) result = STRCAT(result,",");
  if (!isStatic) {
    result = STRCAT(result,"ptr");
    start = 1;
    if (paramNb > 1) result = STRCAT(result,",");
  }
}

if ((paramNb == 1) && (start == 0)) {
  AbSyn ab = tfGetExpr(tmp)((tmp)->__absyn);
  int usrdef;
    
  /* user type or not ? if yes => get the real object */
  if ((usrdef=AbSynIsUserDef(ab))) {
    str_tmp = AbSynToCpp(ab);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,"realObject(");
    strFree(str_tmp);
  }
  
  /* output param */
  str_tmp = itoa_(cnt);
  result = STRCAT(result,"parm");
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  cnt++;
    
  if (usrdef) result = STRCAT(result,")");
} 
else if (paramNb > 1) {
  for (; start < paramNb; start++) {
    int usrdef;
    TForm tmp2 = tfMultiArgN(tmp,start)tfFollowArg(tmp, start);
    AbSyn ab = tfGetExpr(tmp2)((tmp2)->__absyn);
	       
    /* user type or not ? if yes => get the real object */
    if ((usrdef=AbSynIsUserDef(ab))) {
str_tmp = AbSynToCpp(ab);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,"realObject(");
strFree(str_tmp);
    }
    
    /* output param */
    str_tmp = itoa_(cnt);
    result = STRCAT(result,"parm");
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    cnt++;
    
    if (usrdef) result = STRCAT(result,")");

    if (start < paramNb-1) result = STRCAT(result,",");
  }
}

/* Extra parameters if multiple return */
if (tfIsMultiReturn(tfMapRet(tf))((((tfFollowArg(tf, 1))->tag) == TF_Multiple) && tfMultiArgc
(tfFollowArg(tf, 1)))) {
  if (paramNb) result = STRCAT(result,","); 
  str_tmp = GenCppMultiRetLocalDecl(tf,!BL_WithTypetheTRUE);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
}

result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3504}

3506String GenCppParams_Global_Body(TForm tf, String name) {
int cnt = 0;
String result, str_tmp;

if (!tfIsMap(tf)(((tf)->tag) == TF_Map)) return NULL((void*)0);

result = InitStr()strAlloc(500);

tf = tfMapArg(tf)tfFollowArg(tf, 0);

result = STRCAT(result,"(");

if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare) || tfIsGeneral(tf)(((tf)->tag) == TF_General)) {
  int usrdef;
  AbSyn ab = tfGetExpr(tf)((tf)->__absyn);

  /* user type or not ? if yes => get the real object */
  if ((usrdef=AbSynIsUserDef(ab))) result = STRCAT(result,"realObject(");
  
  /* output param */
  str_tmp = itoa_(cnt);
  result = STRCAT(result,"parm");
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  cnt++;
  
  if (usrdef) result = STRCAT(result,")");
} 
else if (!tfIsMulti(tf)(((tf)->tag) == TF_Multiple)) { strFree(result); return NULL((void*)0); }
else if (tfMultiArgc(tf)) {
  int i;
  int paramNb = tfMultiArgc(tf);
  
  for (i=0; i<paramNb; i++) {
    int usrdef;
    TForm tmp = tfMultiArgN(tf,i)tfFollowArg(tf, i);
    AbSyn ab = tfGetExpr(tmp)((tmp)->__absyn);

    /* user type or not ? if yes => get the real object */
    if ((usrdef=AbSynIsUserDef(ab))) result = STRCAT(result,"realObject(");
    
    /* output param */
    str_tmp = itoa_(cnt);
    result = STRCAT(result,"parm");
    result = STRCAT(result,str_tmp);
    cnt++;
    
    if (usrdef) result = STRCAT(result,")");
    
    if (i < paramNb - 1) result = STRCAT(result,",");
  }
}

result = STRCAT(result,")");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3563}
3564/* -- End C++ Params -- */

3566/* ---------- END PARAMS ---------- */

3568/* ---------- TYPES ---------- */

3570/* -- Basic -- */

3572int IsBasicType(String s) {
int i;
for (i = 0; i < bAT_size; i++)
  if (strEqual(s,basicAldorTypes[i])) return theTRUE;
return theFALSE;
3577}

3579String MappingTypes(String s) {
int i;

for (i = 0; i < bAT_size; i++)
  if (strEqual(s,basicAldorTypes[i])) return strCopy(basicCppTypes[i]);
return NULL((void*)0);
3585}

3587String MachineToCpp(AbSyn ab) {
if (!abHasTag(ab,AB_Id)((ab)->abHdr.tag == (AB_Id))) return NULL((void*)0);
return (strEqual(abIdStr(ab)((ab)->abId.sym->str),"XByte")) ? strPrintf("FiByte") : strPrintf("Fi%s",abIdStr(ab)((ab)->abId.sym->str));
3590}

3592/* -- End Basic -- */

3594/* -- AbSyn -- */

3596/* Deals with items like A->B->C ... */ 
3597String FunctionPtrToAldor(AbSyn ab, int usePercent) {
/* When the operator of an apply is "->", argc is 2 */
String s1, s2, str_tmp, result;

s1 = AbSynToAldor(abApplyArg(ab,(int) 0)((ab)->abApply.argv[(int) 0]), usePercent); /* Parameter of the function */
if (!s1) return NULL((void*)0);
s2 = AbSynToAldor(abApplyArg(ab,1)((ab)->abApply.argv[1]), usePercent); /* Return type of the function */
if (!s2) { strFree(s1); return NULL((void*)0); }

result = InitStr()strAlloc(500);

/* s1 -> s2 */
result = STRCAT(result,"(");
result = STRCAT(result,s1);
result = STRCAT(result," -> ");
result = STRCAT(result,s2);
result = STRCAT(result,")");

/* to avoid wasting of memory */
str_tmp =  strCopy(result);
strFree(result);

/* result */
return str_tmp;
3621}

3623String ApplyToAldor(AbSyn ab, int usePercent) {
/* l should be initialised */
/* abTag(ab) == AB_Apply */ 
int i;
String result, str_tmp;
int useName = theFALSE;

if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"->")) return FunctionPtrToAldor(ab, usePercent);

result = InitStr()strAlloc(500);
result = STRCAT(result,abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str));
if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"Record")) useName = theTRUE;
result = STRCAT(result,"(");

for (i = 0; i < abApplyArgc(ab)(((ab)->abHdr.argc)-1); i++) {
  AbSyn arg = abApplyArg(ab,i)((ab)->abApply.argv[i]);
  switch (abTag(arg)((arg)->abHdr.tag)) {
  case AB_Id:
    str_tmp = AbSynToAldor(arg,usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  case AB_Apply:
    str_tmp = ApplyToAldor(abApplyArg(ab,i)((ab)->abApply.argv[i]),usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  case AB_Declare:
    if (useName) {
result = STRCAT(result,abIdStr(abDeclareId(arg))((((arg)->abDeclare.id))->abId.sym->str));
result = STRCAT(result,": ");
    }
    str_tmp = AbSynToAldor(abDeclareType(arg)((arg)->abDeclare.type),usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  default:
    strFree(result);
    return NULL((void*)0);
    break;
  }
  if (i < abApplyArgc(ab)(((ab)->abHdr.argc)-1) - 1) result = STRCAT(result,",");
}
result = STRCAT(result,")");
  
str_tmp = strCopy(result);
strFree(result);
  
return str_tmp;
3675}

3677String CommaToAldor(AbSyn ab, int usePercent) {
AbSyn tmp;
String result, str_tmp;
int i;

if (!ab->abHdr.argc) 
  return strCopy("()");

/* create string */
result = InitStr()strAlloc(500);
result = STRCAT(result,"(");
for (i=0; i < abArgc(ab)((ab)->abHdr.argc); i++) {
  tmp = abCommaArg(ab,i)((ab)->abComma.argv[(i)]);
  switch (abTag(tmp)((tmp)->abHdr.tag)) {
  case AB_Id:
  case AB_Declare:
    str_tmp = AbSynToAldor(tmp,usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  case AB_Apply:
    str_tmp = ApplyToAldor(ab,usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    break;
  default:
    fprintf(stderrstderr,"CommaToAldor - Bad Tag - %d\n",abTag(tmp)((tmp)->abHdr.tag));
    break;
  }
  if (i < abArgc(ab)((ab)->abHdr.argc) - 1) result = STRCAT(result,",");
}
result = STRCAT(result,")");

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3715}

3717String QualifyToString(AbSyn ab, int usePercent) {
String result,str_tmp;

if (!abHasTag(ab->abQualify.what,AB_Id)((ab->abQualify.what)->abHdr.tag == (AB_Id))) return NULL((void*)0);
result = InitStr()strAlloc(500);
result = STRCAT(result,abIdStr(ab->abQualify.what)((ab->abQualify.what)->abId.sym->str));
result = STRCAT(result,"$");
str_tmp = AbSynToAldor(ab->abQualify.origin,usePercent);
if (!str_tmp) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,str_tmp);
strFree(str_tmp);
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3731}

3733String AbSynToAldor(AbSyn ab, int usePercent) {

if (!ab) return NULL((void*)0);

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Id:
  if (IsBasicType(abIdStr(ab)((ab)->abId.sym->str))) return strCopy(abIdStr(ab)((ab)->abId.sym->str));
  else {		/* Usr type ... */
    if (strEqual(abIdStr(ab)((ab)->abId.sym->str),"%") && !usePercent)
return OutputDomNameAldor(CurrentClassAldor);
    else if (strEqual(abIdStr(ab)((ab)->abId.sym->str),"%"))
return strCopy("%%");	/* to get a real % because of fprintf ... */
    else
return strCopy(abIdStr(ab)((ab)->abId.sym->str));
  }
  break;
case AB_Apply:
  if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"Enumeration")) return NULL((void*)0);
  return ApplyToAldor(ab,usePercent);
case AB_Nothing:
  return strCopy("()");
case AB_Comma:
  return CommaToAldor(ab,usePercent);
case AB_Qualify:
  return QualifyToString(ab,usePercent);
case AB_Declare:
  return AbSynToAldor(abDeclareType(ab)((ab)->abDeclare.type),usePercent);
default:
  fprintf(stderrstderr,"AbSynToAldor - Don't deal with abTag(ab) == %d\n",abTag(ab)((ab)->abHdr.tag));
  return NULL((void*)0);
}    
3764}

3766String ApplyArgToTmplCpp(AbSyn ab) {
int paramNb, i;
String result, str_tmp;

if (!ab) return NULL((void*)0);
if (!abIsApply(ab)((ab)->abHdr.tag == (AB_Apply))) return NULL((void*)0);
paramNb = abApplyArgc(ab)(((ab)->abHdr.argc)-1);
result = InitStr()strAlloc(500);
result = STRCAT(result,"<");
for (i = 0; i < paramNb; i++) {
  str_tmp = AbSynToCpp(abApplyArg(ab,i)((ab)->abApply.argv[i]));
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  if (i < (paramNb-1)) result = STRCAT(result,",");
}
result = STRCAT(result,">");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
3786}

3788String AbSynToCpp(AbSyn ab) {
String str_tmp, result;

if (!ab) return NULL((void*)0);

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Id:
  str_tmp = MappingTypes(abIdStr(ab)((ab)->abId.sym->str));
  if (!str_tmp) {		/* Usr type ... */
    if (strEqual(abIdStr(ab)((ab)->abId.sym->str),"%")) return strCopy(CurrentClassCpp);
    return strCopy(abIdStr(ab)((ab)->abId.sym->str));
  }
  return str_tmp;
case AB_Apply:
  if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"->")) return NULL((void*)0);
  if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"Enumeration")) return NULL((void*)0);
  /* assuming we have now parameterized types */
  result = InitStr()strAlloc(500);
  str_tmp = strCopy(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str));
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  str_tmp = ApplyArgToTmplCpp(ab);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  strFree(str_tmp);
  str_tmp = strCopy(result);
  strFree(result);
  return str_tmp;
case AB_Nothing:
  return strCopy("void");
case AB_Comma:
  if (!abArgc(ab)((ab)->abHdr.argc)) return strCopy("void");
  fprintf(stderrstderr,"Function pointers with multiple return are not handled\n");
  return NULL((void*)0);
case AB_Define:
  return AbSynToCpp(tfGetExpr(abTUnique(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abHdr.type.unique))->__absyn
));
case AB_Declare:
  return AbSynToCpp(abDeclareType(ab)((ab)->abDeclare.type));
case AB_Qualify:
  if (abHasTag(ab->abQualify.origin,AB_Id)((ab->abQualify.origin)->abHdr.tag == (AB_Id)) && (strEqual(abIdStr(ab->abQualify.origin)((ab->abQualify.origin)->abId.sym->str),"Machine")))
    return MachineToCpp(ab->abQualify.what);
  return strCopy("void *");
default:
  fprintf(stderrstderr,"AbSynToCpp - Don't deal with abTag(ab) == %d\n",abTag(ab)((ab)->abHdr.tag));
  return NULL((void*)0);
}
3834}


3837int AbSynIsUserDef(AbSyn ab) {
/* Tells whether the type is a basic one or a user defined ... */
/* Deal only with AB_Id */

if (!ab) return theFALSE;

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Id:
  return !(IsBasicType(abIdStr(ab)((ab)->abId.sym->str)));
case AB_Apply:
  if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"->")) return theFALSE;
  if (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"Enumeration")) return theFALSE;
  return theTRUE;
case AB_Nothing:
  return theFALSE;
case AB_Comma:
  return theFALSE;		/* To be completed ! */
case AB_Qualify:
  return theFALSE;
case AB_Declare:
  return AbSynIsUserDef(abDeclareType(ab)((ab)->abDeclare.type));
case AB_Define:
  return AbSynIsUserDef(tfGetExpr(abTUnique(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abHdr.type.unique))->__absyn
));
default:
  fprintf(stderrstderr,"AbSynIsUserDef - Don't deal with abTag(ab) == %d\n",abTag(ab)((ab)->abHdr.tag));
  return theFALSE;
}
3864}

3866int AbSynIsVoid(AbSyn ab) {
/* Tells whether the type corresponds to 'void' */
String str_tmp;

if (!ab) return theFALSE;

switch (abTag(ab)((ab)->abHdr.tag)) {
case AB_Id:
  str_tmp = MappingTypes(abIdStr(ab)((ab)->abId.sym->str));
  if (!str_tmp) return theFALSE;
  if (!strEqual(str_tmp,"void")) {
    strFree(str_tmp);
    return theFALSE;
  }
  strFree(str_tmp);
  return theTRUE;    
case AB_Apply:
  return theFALSE;
case AB_Nothing:
  return theTRUE;
case AB_Comma:
  return (!ab->abHdr.argc);	/* We don't deal with multiple return values */
case AB_Define:
  return AbSynIsVoid(tfGetExpr(abTUnique(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abHdr.type.unique))->__absyn
));
case AB_Qualify:
  return theFALSE;
default:
  fprintf(stderrstderr,"AbSynIsVoid - Don't deal with abTag(ab) == %d\n",abTag(ab)((ab)->abHdr.tag));
  return theFALSE;
}
3896}

3898/* -- End AbSyn -- */

3900/* -- TForm -- */

3902String TFormToAldor(TForm tf, int usePercent) {
String str_tmp,result;
AbSyn ab = tfGetExpr(tf)((tf)->__absyn);
int i;
int lg;

if (tfIsExit(tf)(((tf)->tag) == TF_Exit)) return NULL((void*)0);
if (tfIsGenerator(tf)(((tf)->tag) == TF_Generator)) return NULL((void*)0);

if (ab) return AbSynToAldor(ab,usePercent);

/* Function pointer ? */
if (tfIsMap(tf)(((tf)->tag) == TF_Map)) {
  result = InitStr()strAlloc(500);
  str_tmp = TFormToAldor(tfMapArg(tf)tfFollowArg(tf, 0),usePercent);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,"(");
  result = STRCAT(result,str_tmp);
  result = STRCAT(result," -> ");
  strFree(str_tmp);
  str_tmp = TFormToAldor(tfMapRet(tf)tfFollowArg(tf, 1),usePercent);
  if (!str_tmp) { strFree(result); return NULL((void*)0); }
  result = STRCAT(result,str_tmp);
  result = STRCAT(result,")");
  strFree(str_tmp);
  str_tmp = strCopy(result);
  strFree(result);
  return str_tmp;
}

/* Multiple value ? */
if (tfIsMulti(tf)(((tf)->tag) == TF_Multiple)) {
  lg = tfMultiArgc(tf);
  result = InitStr()strAlloc(500);
  result = STRCAT(result,"(");
  for (i = 0; i < lg; i++) {
    str_tmp = TFormToAldor(tfMultiArgN(tf,i)tfFollowArg(tf, i),usePercent);
    if (!str_tmp) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    if (i < lg-1) result = STRCAT(result,",");
  }
  result = STRCAT(result,")");
  str_tmp = strCopy(result);
  strFree(result);
  return str_tmp;
}

return NULL((void*)0);
3951}

3953TForm tfMakeSubst(TForm tf) {
TForm tmp = tfSubst(tfSubstSigma(tf)((tf)->sigma),tf);
if (!tfIsSubst(tmp)(((tmp)->tag) == TF_Subst)) return tmp;
tmp = tfSubstArg(tf)tfFollowArg(tf, 0);
/* I don't remember why this is here, I replace by 'return tmp;'
   if (!tfIsThird(tmp)) return tmp;
   tmp = tfThirdRestrictions(tmp);
   if (!tfIsWith(tmp)) return tf;
   return tfTUnique(tmp);
*/
return tmp;
3964}

3966TForm tfFollowDefDecl(TForm tf) {
assert(tf != NULL)do { if (!(tf != ((void*)0))) _do_assert(("tf != NULL"),"gencpp.c"
,3967); } while (0);
if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
if (!tfIsDefine(tf)(((tf)->tag) == TF_Define) && !tfIsForward(tf)(((tf)->tag) == TF_Forward)) {
  if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
  return tf;
}
while (tfIsForward(tf)(((tf)->tag) == TF_Forward)) tfFollow(tf)((tf) = tfFollowFn(tf));
if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
if (!tfIsDefine(tf)(((tf)->tag) == TF_Define)) {
  if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
  return tf;
}
tf = tfDeclareType(tfDefineDecl(tf))tfFollowArg(tfFollowArg(tf, 0), 0);
if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
while (tfIsForward(tf)(((tf)->tag) == TF_Forward)) tfFollow(tf)((tf) = tfFollowFn(tf));
if (tfIsSubst(tf)(((tf)->tag) == TF_Subst)) tf = tfMakeSubst(tf);
return tf;
3984}

3986/* -- End TForm -- */


3989/* -- Import/Export -- */

3991String GiveTypeAldorExport(Class *cl, int tab) {
String result,str_tmp;
TForm tmp,tmp2;
int paramNb;
int several = theFALSE;
int cnt, cnt2;
SymeList meths, meths2;
Syme meth;

result = InitStr()strAlloc(500);

/* header */
result = sprintTab(result,tab);
str_tmp = addUnderScore(cl->id.export);
result = STRCAT(result,"ALDOR__givetype__");
result = STRCAT(result,str_tmp);
result = STRCAT(result,"(");
strFree(str_tmp);

/* template params */
if (cl->params) {
62
←
Assuming field 'params' is null→
63
←
Taking false branch→
  int i;
  tmp = cl->params;
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (!tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str));
    result = STRCAT(result,": ");
    str_tmp = TFormToAldor(tmp,!BL_UsePercenttheTRUE);
    if (!str_tmp) result = STRCAT(result,"Pointer");
    else result = STRCAT(result,str_tmp);
  } 
  else 
    for (i=0;i<paramNb;i++) {
tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (!tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,symString(tfDeclareId(tmp2))((tfDeclareId(tmp2))->str));
result = STRCAT(result,": ");
str_tmp = TFormToAldor(tmp2,!BL_UsePercenttheTRUE);
if (!str_tmp) result = STRCAT(result,"Pointer");
else result = STRCAT(result,str_tmp);
if (i < paramNb-1) result = STRCAT(result,",");
    }
}

result = STRCAT(result,"): ");

/* parents */

for (Rewind(cl->extraClasses); !EOList(cl->extraClasses); GotoNext(cl->extraClasses)) {
64
←
Assuming the condition is true→
65
←
Loop condition is true.  Entering loop body→
  /* type of domain is of kind: Cat with ... or Join(Cat1,Cat2) with ... */
  Class *extra = (Class *) GetItem(cl->extraClasses);
 
  /* several parents ? */
  Rewind(extra->parents);
  if (!EOList(extra->parents)) {
66
←
Assuming the condition is false→
67
←
Taking false branch→
    GotoNext(extra->parents);
    if (!EOList(extra->parents)) { /* means several parents ... */
result = STRCAT(result,"Join(");
several = theTRUE;
    }
  }
 
  /* output parents */
  Rewind(extra->parents);
  while (!EOList(extra->parents)) {
68
←
Assuming the condition is false→
69
←
Loop condition is false. Execution continues on line 4066→
    Parent *p = (Parent *)GetItem(extra->parents);
    str_tmp = OutputDomNameAldor(p->id.typeAldor);
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    GotoNext(extra->parents);
    if (!EOList(extra->parents)) result = STRCAT(result,",");
  }
  
  /* end parents - begin body */
  if (several69.1
'several' is 0
) result = STRCAT(result,") with {\n");
70
←
Taking false branch→
  else result = STRCAT(result," with {\n ");
  
  /* methods from extra class */
  cl->methCounter = 0;
  meths = tfThdExports(cl->methods) ? tfThdExports(cl->methods):tfParents(cl->methods)((cl->methods)->parents);
71
←
Assuming the condition is false→
72
←
'?' condition is false→
73
←
Access to field 'parents' results in a dereference of a null pointer (loaded from field 'methods')
  meths2 = meths;
  /* get the number of '%%' to be able to output only the last set of funtions 
     the rest is taken care of by the inheritance */
  for (cnt = 0; meths; meths = meths->rest) {
    meth = meths->first;
    if (!strcmp(symString(symeId(meth))((((meth)->id))->str),"%%")) cnt++;
  }
  /* go to the last '%%' */
  meths = meths2;
  for (cnt2 = 0; cnt2 < cnt; meths = meths->rest) {
    meth = meths->first;
    if (!strcmp(symString(symeId(meth))((((meth)->id))->str),"%%")) cnt2++;
  }
  /* output the remaining functions */
  for (; meths; meths = meths->rest) {
    meth = meths->first;
    str_tmp = GenAldorFnSig(symeType(meth),symString(symeId(meth))((((meth)->id))->str),extra,2,!BL_ExportedtheTRUE,BL_UsePercenttheTRUE,!BL_UseTmplParmstheTRUE);
    if (!str_tmp) continue;
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
  }

  result = sprintTab(result,tab);
  result = STRCAT(result,"}");
}

if (!cl->extraClasses) {
  Rewind(cl->parents);
  if (!EOList(cl->parents)) {
    GotoNext(cl->parents);
    if (!EOList(cl->parents)) { /* means several parents ... */
result = STRCAT(result,"Join(");
several = theTRUE;
    }
  }
  Rewind(cl->parents);
  while (!EOList(cl->parents)) {
    Ident *id = (Ident *)GetItem(cl->parents);
    str_tmp = OutputDomNameAldor(id->typeAldor);
    result = STRCAT(result,str_tmp);
    strFree(str_tmp);
    GotoNext(cl->parents);
    if (!EOList(cl->parents)) result = STRCAT(result,",");
  }
  
  /* end parents - begin body */
  if (several) result = STRCAT(result,")");
  
}

result = STRCAT(result," == ");

/* body == domain */
str_tmp = OutputDomNameAldor(cl->id.typeAldor);  
result = STRCAT(result,str_tmp); result = STRCAT(result,";\n");
strFree(str_tmp);

str_tmp = strCopy(result);
strFree(result);
return str_tmp;
4132}

4134String GiveTypeCppExtern(Class *cl, int tab) {
String result,str_tmp;
TForm tmp,tmp2;
int paramNb;

result = InitStr()strAlloc(500);
result = sprintTab(result,tab);

result = STRCAT(result,"void *ALDOR_givetype_");
result = STRCAT(result,cl->id.export);
result = STRCAT(result,"(");

/* template params */
if (cl->params) {
  int i;
  tmp = cl->params;
  paramNb = tfIsMulti(tmp)(((tmp)->tag) == TF_Multiple) ? tfMultiArgc(tmp) : 1;
  if (paramNb == 1) {
    if (!tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) { strFree(result); return NULL((void*)0); }
    result = STRCAT(result,"void *");
  } 
  else 
    for (i=0;i<paramNb;i++) {
tmp2 = tfMultiArgN(tmp,i)tfFollowArg(tmp, i);
if (!tfIsDeclare(tmp2)(((tmp2)->tag) == TF_Declare)) { strFree(result); return NULL((void*)0); }
result = STRCAT(result,"void *");
if (i < paramNb - 1) result = STRCAT(result,",");
    }
}

result = STRCAT(result,");\n");
str_tmp = strCopy(result);
strFree(result);
return str_tmp;
4168}

4170void GenGiveTypeForExport(Class *cl, FILE *as, FILE *cc) {
String toOutputAS = NULL((void*)0), toOutputCC = NULL((void*)0);

toOutputAS = GiveTypeAldorExport(cl,1);
61
←
Calling 'GiveTypeAldorExport'→
if (toOutputAS) toOutputCC = GiveTypeCppExtern(cl,1);

if (toOutputAS && toOutputCC) { 
  fprintf(as,"%s",toOutputAS); 
  fprintf(cc,"%s",toOutputCC); 
  strFree(toOutputAS);
  strFree(toOutputCC);
} else {
  if (toOutputAS) strFree(toOutputAS);
  if (toOutputCC) strFree(toOutputCC);
}
4185}

4187/* -- End Import/Export -- */

4189/* ---------- END TYPES ---------- */

4191/* Bugs and to do:
 . If SInt is specified without '$Machine' (using 'import from Machine;' for example), then
   the program doesn't translate SInt to FiSInt
 . Multiple return with a % in the list of returned things => just crash I think
 . overloading discrimine sur type de retour
 . function pointers
 . default parameters
 . value parameters for domains (like SI or SF)
 . global variable
 . Overloading resolved only on return type is not handled.
 */

4203/* ---------- UTILS ---------- */

4205/* -- String -- */

4207void printTab(FILE *f, int tab) {
int i;
for (i = 0; i < tab; i++)
  fprintf(f,"\t");
4211}


4214String sprintTab(String s, int tab) {
int i;
for (i = 0; i < tab; i++)
  s = STRCAT(s,"\t");
return s;
4219}


4222String itoa_(int i) {
return strPrintf("%d",i);
4224}


4227String OutputDomNameAldor(String id) {
Length lg = strLength(id);
int i;
String tmp = strCopy(id);

for (i=0; i < lg; i++)
  if (id[i] == '<') tmp[i] = '(';
  else if (id[i] == '>') tmp[i] = ')';

return tmp;
4237}


4240String addUnderScore(String s) {
Length j = strLength(s);
String t = InitStr()strAlloc(500);
int i,k;
String res;

for (i=0,k=0;i<j;i++,k++)
  if (s[i] != '_') t[k]=s[i];
  else {
    t[k]='_';
    k++;
    t[k]='_';
  }
t[k] = '\0';

res = strCopy(t);
strFree(t);
return res;
4258}


4261String transOperatorLike(String s) {
Length j = strLength(s);
String t = InitStr()strAlloc(500);
int i;
String res;

for (i=0 ; i<j ; i++) {
  if ((res = GetStringForSpecialSymbol(s[i],theTRUE)))
    t = STRCAT(t,res);
  else {
    Length m = strLength(t);
    t[m] = s[i];
    t[m+1] = '\0';
  }
}

res = strCopy(t);
strFree(t);
return res;
4280}


4283String AldorifySpeSym(String s) {
/* For each 'special symbol' an _ is placed before */

Length lg = strLength(s);
String t = InitStr()strAlloc(500);
int i,k;
String res;

for (i=0,k=0;i<lg;i++,k++) {
  if (IsSpecialSymbol(s[i],theFALSE)) {
    t[k]='_'; 
    k++;
  }
  t[k]=s[i]; 
}
t[k]='\0';

res = strCopy(t);
strFree(t);
return res;
4303}


4306String RealTypeString(AbSyn ab, int export) {
String str_tmp, str_tmp2;
int isUsrDef;

str_tmp2 = AbSynToCpp(ab);
isUsrDef = AbSynIsUserDef(ab);

if (!isUsrDef) str_tmp = strPrintf("%s *",str_tmp2);
else if (export) str_tmp = strPrintf("void *");
else str_tmp = strPrintf("%s **",str_tmp2);

strFree(str_tmp2);
return str_tmp;
4319}

4321int abIsFuncPtr(AbSyn ab) {
if (!ab) return theFALSE;
if (!abIsApply(ab)((ab)->abHdr.tag == (AB_Apply))) return theFALSE;
return (strEqual(abIdStr(abApplyOp(ab))((((ab)->abApply.op))->abId.sym->str),"->"));
4325}

4327int tfIsFuncPtr(TForm tf) {
if (!tf) return theFALSE;
return (tfIsMap(tf)(((tf)->tag) == TF_Map));
4330}

4332int IsCommonOperator(String s) {
int i;
for (i=0 ; i<CO_size ; i++)
  if (strEqual(commonOperators[i],s)) return theTRUE;
return theFALSE;
4337}

4339int IsInfixOperator(String s) {
int i;
for (i=0 ; i<IO_size ; i++)
  if (strEqual(infixOps[i],s)) return theTRUE;
return theFALSE;
4344}

4346int IsSpecialSymbol(char c, int all) {
/* the option 'all' is to be set when communicating with C (export) */
if (GetStringForSpecialSymbol(c,all) == NULL((void*)0))
  return theFALSE;
else 
  return theTRUE;
4352}

4354String GetStringForSpecialSymbol(char c, int all) {
/* the option 'all' is to be set when communicating with C (export) */
int i;

if (all)
  for (i=0 ; ccSpecCharIdTable[i].ch != 0 ; i++) {
    if (c == ccSpecCharIdTable[i].ch) 
return ccSpecCharIdTable[i].str;
  }
else
  for (i=0 ; ccSpecCharIdTable[i].ch != 0 ; i++) {
    if ((c == ccSpecCharIdTable[i].ch) 
 && (c != BANG'!')
 && (c != QMARK'?'))
return ccSpecCharIdTable[i].str;
  }

return NULL((void*)0);
4372}

4374/* -- End String -- */

4376/* -- Test -- */

4378int PercentsInParms(TForm tf, Class *cl) {
/* 
 * Returns the position of the % in the list of params
 * position is starting from 1
 * returns 0 if no %
 */
if (!tfIsMulti(tf)(((tf)->tag) == TF_Multiple)) {
  if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) {
    if (strEqual(symString(tfDeclareId(tf))((tfDeclareId(tf))->str),"%")) return 1;
    if (strEqual(symString(tfDeclareId(tf))((tfDeclareId(tf))->str),cl->id.basic)) return 1;
  } else if (tfIsGeneral(tf)(((tf)->tag) == TF_General)) {
    AbSyn ab = tfGetExpr(tf)((tf)->__absyn);
    String s = AbSynToAldor(ab,BL_UsePercenttheTRUE);
    if (!s) return 0;
    if (strEqual(s,"%%")) return 1;
    if (strEqual(s,cl->id.basic)) return 1;
    strFree(s);
  }
} else {  /* tfIsMulti(tf) */
  int i,j;
  if ((i=tfMultiArgc(tf))) {
    for (j = 0; j < i; j++) {
TForm tmp = tfMultiArgN(tf,j)tfFollowArg(tf, j);
if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) {
 if (strEqual(symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str),"%")) return j+1;
 if (strEqual(symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str),cl->id.basic)) return j+1;
} 
else if (tfIsGeneral(tmp)(((tmp)->tag) == TF_General)) {
 AbSyn ab = tfGetExpr(tmp)((tmp)->__absyn);
 String s = AbSynToAldor(ab,BL_UsePercenttheTRUE);
 if (s) {
   if (strEqual(s,"%%")) return j+1;
   if (strEqual(s,cl->id.basic)) return j+1;
   strFree(s);
 }
} 
    }
  }
}
return 0;
4418}


4421int StaticOrNot(TForm tf, Class *cl) {
if (!tfIsMulti(tf)(((tf)->tag) == TF_Multiple)) {
  if (tfIsDeclare(tf)(((tf)->tag) == TF_Declare)) {
    if (strEqual(symString(tfDeclareId(tf))((tfDeclareId(tf))->str),"%")) return theFALSE;
    else return !strEqual(symString(tfDeclareId(tf))((tfDeclareId(tf))->str),cl->id.basic);
  } else if (tfIsGeneral(tf)(((tf)->tag) == TF_General)) {
    AbSyn ab = tfGetExpr(tf)((tf)->__absyn);
    if (!ab) return theTRUE;
    if (!abHasTag(ab,AB_Id)((ab)->abHdr.tag == (AB_Id))) return theTRUE;
    if (strEqual(abIdStr(ab)((ab)->abId.sym->str),"%")) return theFALSE;
    return !strEqual(abIdStr(ab)((ab)->abId.sym->str),cl->id.basic);
  } else return theTRUE;
} else {
  if (!tfMultiArgc(tf)) return theTRUE;
  else {
    TForm tmp = tfMultiArgN(tf,(Length) 0)tfFollowArg(tf, (Length) 0);
    if (tfIsDeclare(tmp)(((tmp)->tag) == TF_Declare)) {
if (strEqual(symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str),"%")) return theFALSE;
return !strEqual(symString(tfDeclareId(tmp))((tfDeclareId(tmp))->str),cl->id.basic);
    } 
    else if (tfIsGeneral(tmp)(((tmp)->tag) == TF_General)) {
AbSyn ab = tfGetExpr(tmp)((tmp)->__absyn);
if (!ab) return theTRUE;
if (!abHasTag(ab,AB_Id)((ab)->abHdr.tag == (AB_Id))) return theTRUE;
if (strEqual(abIdStr(ab)((ab)->abId.sym->str),"%")) return theFALSE;
return !strEqual(abIdStr(ab)((ab)->abId.sym->str),cl->id.basic);
    } else return theTRUE;
  }
}
4450}


4453int SpecialCppFunc(String s) {
if (strEqual(s,"char")) return theTRUE;
return theFALSE;
4456}

4458/* -- End Test -- */

4460/* -- ID Handling -- */


4463String operatorForC(String func_id) {
/* Get for the "extern C" a suitable string representing 
   the operator */
/* pre: func_id[0] is a Special Symbol */

String s;
String res;

if (!(IsCommonOperator(func_id)))
  return transOperatorLike(func_id);

s = InitStr()strAlloc(500);
s = STRCAT(s,"Op");
s = STRCAT(s,GetStringForSpecialSymbol(func_id[0],theTRUE));
res = strCopy(s);
strFree(s);
return res;
4480}


4483String createFnIdExternC(String s, Class *cl) {
String str_tmp1,str_tmp2,str_tmp3;
const char ALSTR[]="ALDOR_";
int cnt;
int status;
String func_id = s;
int i;
Length k;

/* Check if operator */
status = REGULAR;

if (IsCommonOperator(func_id)) status = OPERATOR;
else {	/* try to see if SPECIAL_SYM */
  k = strLength(func_id);
  for (i=0 ; i<k ; i++) {
    if (IsSpecialSymbol(func_id[i],theTRUE)) {
status = SPECIAL_SYM;
break;
    }
  }
}

/* Format: ALDORMeth_ClassCnt */  
cnt      = cl ? cl->methCounter : globalFuncCounter;
str_tmp1 = strCopy(cl ? cl->id.export : "Global");
str_tmp2 = (status != REGULAR) ? operatorForC(func_id) : strCopy(func_id);
str_tmp3 = strPrintf("%s%s_%s%d",ALSTR,str_tmp2,str_tmp1,cnt);
strFree(str_tmp2);
strFree(str_tmp1);

return str_tmp3;
4515}


4518String createFnIdExportC(String s, Class *cl) {
String str_tmp  = createFnIdExternC(s,cl);
String str_tmp2 = addUnderScore(str_tmp);
strFree(str_tmp);
return str_tmp2;
4523}


4526String createFnIdForCPP(String func_id, Class *cl) {
String s,res;
OpState status;
int i;
Length k;

/* Check if operator */
status = REGULAR;

if (IsCommonOperator(func_id)) status = OPERATOR;
else {	/* try to see if SPECIAL_SYM */
  k = strLength(func_id);
  for (i=0 ; i<k ; i++) {
    if (IsSpecialSymbol(func_id[i],theTRUE)) {
status = SPECIAL_SYM;
break;
    }
  }
}

/* Output */
s = InitStr()strAlloc(500);
if (status == OPERATOR) { s = STRCAT(s,"operator"); s = STRCAT(s,func_id); }
else if (status == SPECIAL_SYM) {
  String t = operatorForC(func_id);
  s = STRCAT(s,t);
  strFree(t);
} else if (SpecialCppFunc(func_id)) {
  s = STRCAT(s,func_id); s = STRCAT(s,cl->id.basic);
}
else s = STRCAT(s,func_id);

if (scanForBelongsTo(cppKeywords,CK_size,s)) {
  res = InitStr()strAlloc(500);
  res = STRCAT(res,"_");
  res = STRCAT(res,s);
  res = STRCAT(res,"_");
  s = strCopy(res);
  strFree(res);
}

res = strCopy(s);
strFree(s);
return res;
4570}

4572String GenAldorFuncNameReg(String s) {
/* this function will use AldorifySpeSym to ensure any function id
   to be in the right format */

if (IsCommonOperator(s)) return strCopy(s);
if (IsInfixOperator(s)) return strCopy(s); /* to deal with /\ for example */
return AldorifySpeSym(s);  /* *+ -> _*_+, round+ -> round_+ */
4579}


4582String GenAldorFuncName(String s, Class *cl, int isExported) {
/* this function assumes that CurrentClass is set if isExported is theTRUE */
return (isExported ? createFnIdExportC(s,cl) : GenAldorFuncNameReg(s));
4585}


4588String GetIdFromAbSyn(AbSyn ab) {
if (abTag(ab)((ab)->abHdr.tag) == AB_Define) return abIdStr(abDeclareId(abDefineLhs(ab)))((((((ab)->abDefine.lhs))->abDeclare.id))->abId.sym->
str);
else return NULL((void*)0);
4591}

4593/* -- End ID Handling -- */

4595/* ---------- END UTILS ---------- */

4597/* -------------------- INIT FOR ALL STRUCTS ----------------------- */
4598/* InitList is in the "List management" section ... */

4600Function *InitFunc() {
Function *fn = alloc(Function)(Function *) stoAlloc(0,sizeof(Function));
fn->id       = NULL((void*)0);
fn->params   = NULL((void*)0);
fn->ret_typ  = NULL((void*)0);
fn->isStatic = theTRUE;
return fn;
4607}

4609Class *InitClass() {
Class *cl = alloc(Class)(Class *) stoAlloc(0,sizeof(Class));
cl->parents = InitList();
cl->extraClasses = InitList();
cl->methods = NULL((void*)0);
cl->params  = NULL((void*)0);
cl->methCounter = 0;
cl->classCounter = 0;
return cl;
4618}

4620String STRCAT(String s1, String s2) {
String s = strConcat(s1,s2);
strFree(s1);
return s;
4624}

4626/* -------------------- LIST MANAGEMENT -------------------------- */

4628MyList *InitList() {
MyList *lst;

lst = alloc(MyList)(MyList *) stoAlloc(0,sizeof(MyList));
lst->head    = NULL((void*)0);
lst->tail    = NULL((void*)0);
lst->current = NULL((void*)0);

return lst;
4637}

4639void Append(MyList *lst, CellType ct, void *elem) {
Cell *tmp;

if (!lst) { fprintf(stderrstderr, "Append: List not initialized\n"); exit((int) 0); }

/* Creation of the cell to append */
tmp = alloc(Cell)(Cell *) stoAlloc(0,sizeof(Cell));
tmp->Item = elem;
tmp->ct = ct;
tmp->next = NULL((void*)0);

/* Append the cell to the end of the list */
if (!(lst->head)) {
  lst->tail    = tmp;
  lst->current = tmp;
  lst->head    = tmp;
} else {
  lst->tail->next = tmp;
  lst->tail       = tmp;
}
4659}

4661void Rewind(MyList *l) {
if (!l) return;
l->current = l->head;
4664}

4666void *GetItem(MyList *l) {
if (!l) return NULL((void*)0);
if (!l->current) return NULL((void*)0);
return l->current->Item;
4670}

4672void GotoNext(MyList *l) {
if (!l) return;
if (!l->current) return;
l->current = l->current->next;
4676}

4678void HeadToNext(MyList *l) {
if (!l) return;
if (!l->current) return;
l->head = l->current->next;
4682}

4684int Empty(MyList *l) {
return (!l || !l->head);
4686}

4688int NotEmpty(MyList *l) {
return (l && l->head);
4690}

4692int EOList(MyList *l) {
if (!l) return theTRUE;
return !(l->current);
4695}

4697/* -------------------- MEMORY MANAGEMENT -------------------------- */

4699void FreeList(MyList *l) {
if (!l) return;
if (Empty(l)) { stoFree(l); return; }
Rewind(l);
while (!EOList(l)) {
  HeadToNext(l);
  stoFree(l->current);
  Rewind(l);
}
stoFree(l);
4709}

4711void FreeFunction(Function *fn) {
if (!fn) return;
4713}

4715void FreeClass(Class *cl) {
if (!cl) return;

FreeList(cl->extraClasses);
FreeList(cl->parents);
stoFree(cl);  
4721}