Lines Matching refs:pType
205 pType = NULL;
208 Type* pType;
389 virtual void loadFloat(int address, Type* pType) = 0;
391 /* Add the struct offset in bytes to R0, change the type to pType */
392 virtual void addStructOffsetR0(int offset, Type* pType) = 0;
469 void convertR0(Type* pType) {
470 convertR0Imp(pType, false);
473 void castR0(Type* pType) {
474 convertR0Imp(pType, true);
477 virtual void convertR0Imp(Type* pType, bool isCast) = 0;
557 return mExpressionStack.back().pType;
621 void setR0Type(Type* pType) {
622 assert(pType != NULL);
623 mExpressionStack.back().pType = pType;
627 void setR0Type(Type* pType, ExpressionType et) {
628 assert(pType != NULL);
629 mExpressionStack.back().pType = pType;
634 return mExpressionStack[mExpressionStack.size()-2].pType;
684 static bool isFloatType(Type* pType) {
685 return isFloatTag(pType->tag);
692 static bool isPointerType(Type* pType) {
693 return isPointerTag(pType->tag);
1065 virtual void loadFloat(int address, Type* pType) {
1066 setR0Type(pType);
1073 switch (pType->tag) {
1095 virtual void addStructOffsetR0(int offset, Type* pType) {
1104 setR0Type(pType, ET_LVALUE);
1786 virtual void convertR0Imp(Type* pType, bool isCast){
1788 if (isPointerType(pType) && isPointerType(pR0Type)) {
1790 Type* pB = pType;
1801 } else if (bitsSame(pType, pR0Type)) {
1805 TypeTag destTag = collapseType(pType->tag);
1858 incompatibleTypes(pR0Type, pType);
1862 incompatibleTypes(pR0Type, pType);
1866 setR0Type(pType);
2066 virtual size_t alignmentOf(Type* pType){
2067 switch(pType->tag) {
2075 return alignmentOf(pType->pHead);
2077 return pType->pHead->alignment & 0x7fffffff;
2089 virtual size_t sizeOf(Type* pType){
2090 switch(pType->tag) {
2104 return pType->length * sizeOf(pType->pHead);
2106 return pType->pHead->length;
2108 error("Unsupported type %d", pType->tag);
2284 void incompatibleTypes(Type* pR0Type, Type* pType) {
2285 error("Incompatible types old: %d new: %d", pR0Type->tag, pType->tag);
2490 virtual void loadFloat(int address, Type* pType) {
2491 setR0Type(pType);
2492 switch (pType->tag) {
2505 pType) {
2509 setR0Type(pType, ET_LVALUE);
2912 virtual void convertR0Imp(Type* pType, bool isCast){
2916 setR0Type(pType);
2919 if (isPointerType(pType) && isPointerType(pR0Type)) {
2921 Type* pB = pType;
2932 } else if (bitsSame(pType, pR0Type)) {
2934 } else if (isFloatType(pType
2938 TypeTag destTag = collapseType(pType->tag);
2961 pR0Type->tag, pType->tag);
2964 setR0Type(pType);
3058 virtual size_t alignmentOf(Type* pType){
3059 switch (pType->tag) {
3065 return alignmentOf(pType->pHead);
3067 return pType->pHead->alignment & 0x7fffffff;
3079 virtual size_t sizeOf(Type* pType){
3080 switch(pType->tag) {
3094 return pType->length * sizeOf(pType->pHead);
3096 return pType->pHead->length;
3098 error("Unsupported type %d", pType->tag);
3226 virtual void loadFloat(int address, Type* pType) {
3227 fprintf(stderr, "loadFloat(%d, type=%d)\n", address, pType->tag);
3228 mpBase->loadFloat(address, pType);
3231 virtual void addStructOffsetR0(int offset, Type* pType) {
3232 fprintf(stderr, "addStructOffsetR0(%d, type=%d)\n", offset, pType->tag);
3233 mpBase->addStructOffsetR0(offset, pType);
3306 virtual void convertR0Imp(Type* pType, bool isCast){
3307 fprintf(stderr, "convertR0(pType tag=%d, %d)\n", pType->tag, isCast);
3308 mpBase->convertR0Imp(pType, isCast);
3341 fprintf(stderr, "adjustStackAfterCall(pType, %d, %d)\n", l, isIndirect);
3368 virtual size_t alignmentOf(Type* pType){
3369 return mpBase->alignmentOf(pType);
3375 virtual size_t sizeOf(Type* pType){
3376 return mpBase->sizeOf(pType);
3812 Type* pType;
3893 VariableInfo* add(Type* pType) {
3894 VariableInfo* pVI = add(pType->id);
3895 pVI->pType = pType;
4642 if (pVI->pType == NULL) {
4644 pVI->pType = mkpIntFn;
4646 pVI->pType = mkpInt;
4773 if (pVI->pType->tag == TY_ARRAY) {
4774 pVal = pVI->pType;
4777 pVal = createPtrType(pVI->pType);
5140 Type* pType = (Type*) mpCurrentArena->alloc(sizeof(Type));
5141 memset(pType, 0, sizeof(*pType));
5142 pType->storageClass = SC_DEFAULT;
5143 pType->tag = tag;
5144 pType->pHead = pHead;
5145 pType->pTail = pTail;
5146 return pType;
5149 Type* createPtrType(Type* pType) {
5150 return createType(TY_POINTER, pType, NULL);
5156 void decodeType(String& buffer, Type* pType) {
5158 if (pType == NULL) {
5162 decodeTypeImp(buffer, pType);
5165 void decodeTypeImp(String& buffer, Type* pType) {
5166 decodeTypeImpPrefix(buffer, pType);
5167 decodeId(buffer, pType->id);
5168 decodeTypeImpPostfix(buffer, pType);
5179 void decodeTypeImpPrefix(String& buffer, Type* pType) {
5180 TypeTag tag = pType->tag;
5204 bool isStruct = (pType->pHead->alignment & 0x80000000) != 0;
5206 if (pType->pHead && pType->pHead->structTag) {
5208 decodeId(buffer, pType->pHead->structTag);
5232 decodeTypeImpPrefix(buffer, pType->pHead);
5233 if(pType->pHead && pType->pHead->tag == TY_FUNC) {
5239 decodeTypeImpPrefix(buffer, pType->pHead);
5244 decodeTypeImp(buffer, pType->pHead);
5247 decodeTypeImp(buffer, pType->pHead);
5251 temp.printf("Unknown tag %d", pType->tag);
5257 void decodeTypeImpPostfix(String& buffer, Type* pType) {
5258 TypeTag tag = pType->tag;
5262 if(pType->pHead && pType->pHead->tag == TY_FUNC) {
5265 decodeTypeImpPostfix(buffer, pType->pHead);
5270 temp.printf("[%d]", pType->length);
5275 if (pType->pHead->length >= 0) {
5277 for(Type* pArg = pType->pTail; pArg; pArg = pArg->pTail) {
5286 for(Type* pArg = pType->pTail; pArg; pArg = pArg->pTail) {
5299 void printType(Type* pType) {
5301 decodeType(buffer, pType);
5329 Type* pType = NULL;
5333 insertStorageClass(&pType, SC_AUTO);
5336 insertStorageClass(&pType, SC_REGISTER);
5339 insertStorageClass(&pType, SC_STATIC);
5342 insertStorageClass(&pType, SC_EXTERN);
5345 insertStorageClass(&pType, SC_TYPEDEF);
5348 insertTypeSpecifier(&pType, TY_INT);
5351 insertTypeSpecifier(&pType, TY_SHORT);
5354 insertTypeSpecifier(&pType, TY_CHAR);
5357 insertTypeSpecifier(&pType, TY_VOID);
5360 insertTypeSpecifier(&pType, TY_FLOAT);
5363 insertTypeSpecifier(&pType, TY_DOUBLE);
5368 insertTypeSpecifier(&pType, TY_STRUCT);
5371 pType = acceptStruct(pType, isStruct);
5379 if (pV && pV->pType->storageClass == SC_TYPEDEF) {
5380 if (! pType) {
5381 pType = createType(TY_UNKNOWN, NULL, NULL);
5383 StorageClass storageClass = pType->storageClass;
5384 *pType = *pV->pType;
5385 pType->storageClass = storageClass;
5397 if (pType) {
5398 if (pType->tag == TY_UNKNOWN) {
5399 pType->tag = TY_INT;
5402 switch(pType->storageClass) {
5410 if (pType->storageClass != SC_DEFAULT) {
5415 return pType;
5430 if (pStructInfo->pType->pHead->length == -1) {
5443 pStructType->pHead = pStructInfo->pType;
5460 pToken->mpStructInfo->pType = pStructType;
5533 Type* acceptDeclaration(Type* pType, bool nameAllowed, bool nameRequired) {
5536 StorageClass storageClass = pType->storageClass;
5537 pType = acceptDecl2(pType, declName, nameAllowed,
5541 Type* pOldType = pType;
5542 pType = createType(pType->tag, pType->pHead, pType->pTail);
5543 *pType = *pOldType;
5544 pType->id = declName;
5545 pType->storageClass = storageClass;
5551 printType(pType);
5556 return pType;
5561 Type* pType = acceptDeclaration(pBaseType, true, nameRequired);
5562 if (! pType) {
5565 return pType;
5570 Type* pType = acceptPrimitiveType(false);
5571 if (pType) {
5572 pType = acceptDeclaration(pType, false, false);
5574 return pType;
5578 Type* pType = acceptCastTypeDeclaration();
5579 if (! pType) {
5582 return pType;
5585 Type* acceptDecl2(Type* pType, tokenid_t& declName,
5589 pType = createType(TY_POINTER, pType, NULL);
5591 pType = acceptDecl3(pType, declName, nameAllowed, nameRequired,
5593 return pType;
5596 Type* acceptDecl3(Type* pType, tokenid_t& declName,
5624 pType = createType(TY_FUNC, pType, pTail);
5631 Type* pDecayType = createPtrType(pType);
5632 pType = createType(TY_ARRAY, pType, pDecayType);
5633 pType->length = tokc;
5648 pA->pHead = pType;
5649 pType = pNewHead;
5651 return pType;
5680 Type* pType = acceptPrimitiveType(allowStorageClass);
5681 if (!pType) {
5686 return pType;
5869 pGen->alignmentOf(name->pType),
5870 pGen->sizeOf(name->pType));
5944 Type* passingType(Type* pType) {
5945 switch (pType->tag) {
5950 return pType;
