void initSymTab(void) { Object* obj; Object* param; symtab = (SymTab*) malloc(sizeof(SymTab)); symtab->globalObjectList = NULL; obj = createFunctionObject("READC"); obj->funcAttrs->returnType = makeCharType(); addObject(&(symtab->globalObjectList), obj); obj = createFunctionObject("READI"); obj->funcAttrs->returnType = makeIntType(); addObject(&(symtab->globalObjectList), obj); obj = createProcedureObject("WRITEI"); param = createParameterObject("i", PARAM_VALUE, obj); param->paramAttrs->type = makeIntType(); addObject(&(obj->procAttrs->paramList),param); addObject(&(symtab->globalObjectList), obj); obj = createProcedureObject("WRITEC"); param = createParameterObject("ch", PARAM_VALUE, obj); param->paramAttrs->type = makeCharType(); addObject(&(obj->procAttrs->paramList),param); addObject(&(symtab->globalObjectList), obj); obj = createProcedureObject("WRITELN"); addObject(&(symtab->globalObjectList), obj); intType = makeIntType(); charType = makeCharType(); }
Type* compileBasicType(void) { Type* type; switch (lookAhead->tokenType) { case KW_INTEGER: eat(KW_INTEGER); type = makeIntType(); break; case KW_CHAR: eat(KW_CHAR); type = makeCharType(); break; case KW_FLOAT: eat(KW_FLOAT); type = makeFloatType(); break; case KW_STRING: eat(KW_STRING); type = makeStringType(); break; default: error(ERR_INVALID_BASICTYPE, lookAhead->lineNo, lookAhead->colNo); break; } return type; }
Type* compileFactor(void) { // parse a factor and return the factor's type Object* obj = NULL; Type* type = NULL; switch (lookAhead->tokenType) { case TK_NUMBER: eat(TK_NUMBER); type = makeIntType(); break; case TK_CHAR: eat(TK_CHAR); type = makeCharType(); break; case TK_IDENT: eat(TK_IDENT); // check if the identifier is declared obj = checkDeclaredIdent(currentToken->string); switch (obj->kind) { case OBJ_CONSTANT: // use as an empty type type = makeIntType(); // assign the type of the constant type->typeClass = obj->constAttrs->value->type; break; case OBJ_VARIABLE: if (obj->varAttrs->type->typeClass != TP_ARRAY) type = obj->varAttrs->type; else type = compileIndexes(obj->varAttrs->type); break; case OBJ_PARAMETER: type = obj->paramAttrs->type; break; case OBJ_FUNCTION: type = obj->funcAttrs->returnType; compileArguments(obj->funcAttrs->paramList); break; default: error(ERR_INVALID_FACTOR,currentToken->lineNo, currentToken->colNo); break; } break; default: error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo); } return type; }
void initSymTab(void) { Object* param; symtab = (SymTab*) malloc(sizeof(SymTab)); symtab->globalObjectList = NULL; symtab->program = NULL; symtab->currentScope = NULL; readcFunction = createFunctionObject("READC"); declareObject(readcFunction); readcFunction->funcAttrs->returnType = makeCharType(); readiFunction = createFunctionObject("READI"); declareObject(readiFunction); readiFunction->funcAttrs->returnType = makeIntType(); writeiProcedure = createProcedureObject("WRITEI"); declareObject(writeiProcedure); enterBlock(writeiProcedure->procAttrs->scope); param = createParameterObject("i", PARAM_VALUE); param->paramAttrs->type = makeIntType(); declareObject(param); exitBlock(); writecProcedure = createProcedureObject("WRITEC"); declareObject(writecProcedure); enterBlock(writecProcedure->procAttrs->scope); param = createParameterObject("ch", PARAM_VALUE); param->paramAttrs->type = makeCharType(); declareObject(param); exitBlock(); writelnProcedure = createProcedureObject("WRITELN"); declareObject(writelnProcedure); intType = makeIntType(); charType = makeCharType(); }
Type* compileType(void) { Type* type; Type* elementType; int arraySize; Object* obj; switch (lookAhead->tokenType) { case KW_INTEGER: eat(KW_INTEGER); type = makeIntType(); break; case KW_CHAR: eat(KW_CHAR); type = makeCharType(); break; case KW_STRING: eat(KW_STRING); type=makeStringType(); break; case KW_FLOAT: eat(KW_FLOAT); type=makeFloatType(); break; case KW_ARRAY: eat(KW_ARRAY); eat(SB_LSEL); eat(TK_NUMBER); arraySize = currentToken->value; eat(SB_RSEL); eat(KW_OF); elementType = compileType(); type = makeArrayType(arraySize, elementType); break; case TK_IDENT: eat(TK_IDENT); obj = checkDeclaredType(currentToken->string); type = duplicateType(obj->typeAttrs->actualType); break; default: error(ERR_INVALID_TYPE, lookAhead->lineNo, lookAhead->colNo); break; } return type; }
Type* compileBasicType(void) { // TODO: create and return a basic type Type* type; switch (lookAhead->tokenType) { case KW_INTEGER: eat(KW_INTEGER); type = makeIntType(); break; case KW_CHAR: eat(KW_CHAR); type = makeCharType(); break; default: error(ERR_INVALID_BASICTYPE, lookAhead->lineNo, lookAhead->colNo); break; } return type; }
Type* compileType(void) { Type* type; Type* elementType; int arraySize; Object* obj; switch (lookAhead->tokenType) { case KW_INTEGER: eat(KW_INTEGER); type = makeIntType(); break; case KW_CHAR: eat(KW_CHAR); type = makeCharType(); break; case KW_ARRAY: eat(KW_ARRAY); eat(SB_LSEL); eat(TK_NUMBER); arraySize = currentToken->value; eat(SB_RSEL); eat(KW_OF); elementType = compileType(); type = makeArrayType(arraySize, elementType); break; case TK_IDENT: eat(TK_IDENT); // check if the type identifier is declared and get its actual type obj = checkDeclaredType(currentToken->string); if (obj != NULL) type = duplicateType(obj->typeAttrs->actualType); else error(ERR_UNDECLARED_TYPE, currentToken->colNo, currentToken->lineNo); break; default: error(ERR_INVALID_TYPE, lookAhead->lineNo, lookAhead->colNo); break; } return type; }
Type* compileType(void) { Type* type; Type* elementType; int arraySize; Object* obj; switch (lookAhead->tokenType) { case KW_INTEGER: eat(KW_INTEGER); type = makeIntType(); break; case KW_CHAR: eat(KW_CHAR); type = makeCharType(); break; case KW_ARRAY: eat(KW_ARRAY); eat(SB_LSEL); eat(TK_NUMBER); arraySize = currentToken->value; eat(SB_RSEL); eat(KW_OF); elementType = compileType(); type = makeArrayType(arraySize, elementType); break; case TK_IDENT: eat(TK_IDENT); // TODO: check if the type idntifier is declared and get its actual type break; default: error(ERR_INVALID_TYPE, lookAhead->lineNo, lookAhead->colNo); break; } return type; }
int main() { Object* obj; initSymTab(); obj = createProgramObject("PRG"); enterBlock(obj->progAttrs->scope); obj = createConstantObject("c1"); obj->constAttrs->value = makeIntConstant(10); declareObject(obj); obj = createConstantObject("c2"); obj->constAttrs->value = makeCharConstant('a'); declareObject(obj); obj = createTypeObject("t1"); obj->typeAttrs->actualType = makeArrayType(10, makeIntType()); declareObject(obj); obj = createVariableObject("v1"); obj->varAttrs->type = makeIntType(); declareObject(obj); obj = createVariableObject("v2"); obj->varAttrs->type = makeArrayType(10, makeArrayType(10, makeIntType())); declareObject(obj); obj = createFunctionObject("f"); obj->funcAttrs->returnType = makeIntType(); declareObject(obj); enterBlock(obj->funcAttrs->scope); obj = createParameterObject("p1", PARAM_VALUE, symtab->currentScope->owner); obj->paramAttrs->type = makeIntType(); declareObject(obj); obj = createParameterObject("p2", PARAM_REFERENCE, symtab->currentScope->owner); obj->paramAttrs->type = makeCharType(); declareObject(obj); exitBlock(); obj = createProcedureObject("p"); declareObject(obj); enterBlock(obj->procAttrs->scope); obj = createParameterObject("v1", PARAM_VALUE, symtab->currentScope->owner); obj->paramAttrs->type = makeIntType(); declareObject(obj); obj = createConstantObject("c1"); obj->constAttrs->value = makeCharConstant('a'); declareObject(obj); obj = createConstantObject("c3"); obj->constAttrs->value = makeIntConstant(10); declareObject(obj); obj = createTypeObject("t1"); obj->typeAttrs->actualType = makeIntType(); declareObject(obj); obj = createTypeObject("t2"); obj->typeAttrs->actualType = makeArrayType(10, makeIntType()); declareObject(obj); obj = createVariableObject("v2"); obj->varAttrs->type = makeArrayType(10, makeIntType()); declareObject(obj); obj = createVariableObject("v3"); obj->varAttrs->type = makeCharType(); declareObject(obj); exitBlock(); exitBlock(); printObject(symtab->program, 0); cleanSymTab(); return 0; }
IHqlExpression * HqlCppCaseInfo::buildIndexedMap(BuildCtx & ctx, const CHqlBoundExpr & test) { ITypeInfo * compareType = test.queryType()->queryPromotedType(); type_t compareTypeCode = compareType->getTypeCode(); HqlExprArray values; IHqlExpression * dft = queryActiveTableSelector(); // value doesn't matter as long as it will not occur __int64 lower = getIntValue(lowerTableBound, 0); unsigned num = (getIntValue(upperTableBound, 0)-lower)+1; CHqlBoundExpr indexExpr; switch (compareTypeCode) { case type_int: indexExpr.set(test); break; case type_string: indexExpr.expr.setown(createValue(no_index, makeCharType(), LINK(test.expr), getZero())); indexExpr.expr.setown(createValue(no_cast, makeIntType(1, false), LINK(indexExpr.expr))); break; default: throwUnexpectedType(compareType); } if (useRangeIndex && (num != 1)) translator.ensureSimpleExpr(ctx, indexExpr); OwnedHqlExpr mapped; ITypeInfo * retType = resultType; //if num == pairs.ordinality() and all results are identical, avoid the table lookup. if (allResultsMatch && (num == pairs.ordinality())) { mapped.set(pairs.item(0).queryChild(1)); } else { values.ensure(num); unsigned idx; for (idx = 0; idx < num; idx++) values.append(*LINK(dft)); ForEachItemIn(idx2, pairs) { IHqlExpression & cur = pairs.item(idx2); IValue * value = cur.queryChild(0)->queryValue(); unsigned replaceIndex; switch (compareTypeCode) { case type_int: replaceIndex = (unsigned)(value->getIntValue()-lower); break; case type_string: { StringBuffer temp; value->getStringValue(temp); replaceIndex = (unsigned)((unsigned char)temp.charAt(0)-lower); break; } default: throwUnexpectedType(compareType); } IHqlExpression * mapTo = cur.queryChild(1); if (mapTo->getOperator() != no_constant) throwUnexpected(); if (replaceIndex >= num) translator.reportWarning(CategoryIgnored, HQLWRN_CaseCanNeverMatch, "CASE entry %d can never match the test condition", replaceIndex); else values.replace(*LINK(mapTo),replaceIndex); } //Now replace the placeholders with the default values. for (idx = 0; idx < num; idx++) { if (&values.item(idx) == dft) values.replace(*defaultValue.getLink(),idx); } // use a var string type to get better C++ generated... ITypeInfo * storeType = getArrayElementType(resultType); ITypeInfo * listType = makeArrayType(storeType, values.ordinality()); OwnedHqlExpr lvalues = createValue(no_list, listType, values); CHqlBoundExpr boundTable; translator.buildExpr(ctx, lvalues, boundTable); LinkedHqlExpr tableIndex = indexExpr.expr; if (getIntValue(lowerTableBound, 0)) tableIndex.setown(createValue(no_sub, tableIndex->getType(), LINK(tableIndex), LINK(lowerTableBound))); IHqlExpression * ret = createValue(no_index, LINK(retType), LINK(boundTable.expr), LINK(tableIndex)); mapped.setown(createTranslatedOwned(ret)); }