The Ecere SDK - sdk/blob - compiler/libec/src/shortcuts.ec

   1 #ifdef ECERE_STATIC
   2 public import static "ecere"
   3 #else
   4 public import "ecere"
   5 #endif
   6
   7 import "ecdefs"
   8
   9 bool parsingType;
  10 public void SetParsingType(bool b) { parsingType = b; }
  11
  12 extern TypeName parsedType;
  13 extern bool echoOn;
  14 extern bool type_yydebug;
  15 extern Location yylloc;
  16
  17 int type_yyparse();
  18 void resetScannerPos(CodePosition pos);
  19
  20 Declarator PlugDeclarator(Declarator decl, Declarator baseDecl)
  21 {
  22    if(decl && decl.type != identifierDeclarator)
  23    {
  24       Declarator base;
  25       decl = CopyDeclarator(decl);
  26
  27       base = decl;
  28       if(base.type != identifierDeclarator)
  29       {
  30          for(; base.declarator && base.declarator.type != identifierDeclarator; base = base.declarator)
  31          {
  32             printf("");
  33          }
  34       }
  35       if(baseDecl)
  36       {
  37          if(base.declarator)
  38             FreeDeclarator(base.declarator);
  39          base.declarator = baseDecl;
  40       }
  41       else if(base.type == identifierDeclarator)
  42       {
  43          FreeDeclarator(decl);
  44          decl = null;
  45       }
  46       return decl;
  47    }
  48    else
  49       return baseDecl;
  50 }
  51
  52
  53 // *** Shortcut Functions ***
  54 Declarator QMkPtrDecl(char * id)
  55 {
  56    Declarator declarator = id ? MkDeclaratorIdentifier(MkIdentifier(id)) : null;
  57    return MkDeclaratorPointer(MkPointer(null,null), declarator);
  58 }
  59
  60 TypeName QMkType(char * spec, Declarator decl)
  61 {
  62    OldList * specs = MkList();
  63    ListAdd(specs, MkSpecifierName(spec));
  64    return MkTypeName(specs, decl);
  65 }
  66
  67 TypeName QMkClass(char * spec, Declarator decl)
  68 {
  69    OldList * specs = MkList();
  70    ListAdd(specs, MkSpecifierName/*MkClassName*/(spec));
  71    return MkTypeName(specs, decl);
  72 }
  73
  74 Expression QBrackets(Expression exp)
  75 {
  76    OldList * expList = MkList();
  77    ListAdd(expList, exp);
  78    return MkExpBrackets(expList);
  79 }
  80
  81 Expression QMkExpId(char * id)
  82 {
  83    return MkExpIdentifier(MkIdentifier(id));
  84 }
  85
  86 Expression QMkExpCond(Expression cond, Expression exp, Expression elseExp)
  87 {
  88    OldList * expList = MkList();
  89    ListAdd(expList, exp);
  90    return MkExpCondition(cond, expList, elseExp);
  91 }
  92
  93 Declaration QMkDeclaration(char * name, InitDeclarator initDecl)
  94 {
  95    OldList * specs = MkList(), * initDecls = null;
  96    ListAdd(specs, MkSpecifierName(name));
  97    if(initDecl)
  98    {
  99       initDecls = MkList();
 100       ListAdd(initDecls, initDecl);
 101    }
 102    return MkDeclaration(specs, initDecls);
 103 }
 104
 105 Declaration QMkDeclarationBase(int base, InitDeclarator initDecl)
 106 {
 107    OldList * specs = MkList(), * initDecls = null;
 108    ListAdd(specs, MkSpecifier(base));
 109    if(initDecl)
 110    {
 111       initDecls = MkList();
 112       ListAdd(initDecls, initDecl);
 113    }
 114    return MkDeclaration(specs, initDecls);
 115 }
 116
 117 char * QMkString(char * source)
 118 {
 119    char * string;
 120    if(source)
 121    {
 122       int len = 0;
 123       int i,j = 0;
 124       char ch;
 125
 126       for(i = 0; (ch = source[i]); i++)
 127       {
 128          len++;
 129          if(ch == '\"' || ch == '\\')
 130             len++;
 131       }
 132
 133       string = new char[len+3];
 134
 135       string[j++] = '\"';
 136       for(i = 0; (ch = source[i]); i++)
 137       {
 138          if(ch == '\"' || ch == '\\')
 139             string[j++] = '\\';
 140          string[j++] = ch;
 141       }
 142       string[j++] = '\"';
 143       string[j] = '\0';
 144    }
 145    else
 146       string = CopyString("0");
 147    return string;
 148 }
 149
 150 public Declarator GetFuncDecl(Declarator decl)
 151 {
 152    Declarator funcDecl = null;
 153    while(decl && decl.type != identifierDeclarator)
 154    {
 155       if(decl.type == functionDeclarator)
 156          funcDecl = decl;
 157       decl = decl.declarator;
 158    }
 159    return funcDecl;
 160 }
 161
 162 bool parseTypeError;
 163
 164 public Declarator SpecDeclFromString(char * string, OldList * specs, Declarator baseDecl)
 165 {
 166    Location oldLocation = yylloc;
 167    Declarator decl = null;
 168    File backFileInput = fileInput;
 169
 170    //char * classOp, * type;
 171    if(!string)
 172       string = "void()";
 173
 174    /*
 175    classOp = strstr(string, "::");
 176    type = classOp ? (classOp + 2) : string;
 177    */
 178
 179    fileInput = TempFile { };
 180    fileInput.Write(string, 1, strlen(string));
 181    fileInput.Seek(0, start);
 182
 183    //type_yydebug = true;
 184    echoOn = false;
 185    parseTypeError = false;
 186    parsedType = null;
 187    declMode = structDeclMode = defaultAccess;
 188    resetScanner();
 189    {
 190       bool oldParsingType = parsingType;
 191       parsingType = true;
 192       type_yyparse();
 193       parsingType = oldParsingType;
 194    }
 195    declMode = structDeclMode = privateAccess;
 196
 197    type_yydebug = false;
 198
 199    delete fileInput;
 200
 201    if(parsedType)
 202    {
 203       if(parsedType.qualifiers)
 204       {
 205          Specifier spec;
 206          for(;(spec = parsedType.qualifiers->first);)
 207          {
 208             parsedType.qualifiers->Remove(spec);
 209             specs->Add(spec);
 210          }
 211       }
 212       if(parsedType.bitCount)
 213       {
 214          parsedType.declarator = MkStructDeclarator(parsedType.declarator, parsedType.bitCount);
 215          parsedType.bitCount = null;
 216       }
 217       decl = PlugDeclarator(parsedType.declarator, baseDecl);
 218       FreeTypeName(parsedType);
 219       parsedType = null;
 220
 221       if(parseTypeError)
 222       {
 223          Compiler_Warning($"parsing type %s\n", string);
 224          // Compiler_Error($"parsing type %s\n", string);
 225       }
 226    }
 227    else
 228    {
 229       Compiler_Warning($"parsing type %s\n", string);
 230       // Compiler_Error($"parsing type %s\n", string);
 231       //eSystem_Logf("parsing type %s\n", string);
 232       //exit(0);
 233       decl = baseDecl;
 234    }
 235
 236    yylloc = oldLocation;
 237
 238    fileInput = backFileInput;
 239    return decl;
 240 }