From 74edb7b2681c9d1701d30c0d576a5bd5d3f0a1ae Mon Sep 17 00:00:00 2001 From: e5l Date: Thu, 11 Aug 2016 19:20:17 +0300 Subject: [PATCH] translator: correct protobuf, worked translator --- proto/runtime/src/main/kotlin/WireFormat.kt | 12 +++++-- .../kotlinnative/translator/BlockCodegen.kt | 35 ++++++++++++------- 2 files changed, 31 insertions(+), 16 deletions(-) diff --git a/proto/runtime/src/main/kotlin/WireFormat.kt b/proto/runtime/src/main/kotlin/WireFormat.kt index 628328e124c..6ede9ccf92e 100644 --- a/proto/runtime/src/main/kotlin/WireFormat.kt +++ b/proto/runtime/src/main/kotlin/WireFormat.kt @@ -120,19 +120,25 @@ object WireFormat { return getTagSize(fieldNumber, WireType.FIX_32) + FIXED_32_BYTE_SIZE } - fun getFixed32SizeNoTag(value: Int): Int = FIXED_32_BYTE_SIZE + fun getFixed32SizeNoTag(value: Int): Int { + return FIXED_32_BYTE_SIZE + } fun getFixed64Size(fieldNumber: Int, value: Long): Int { return getTagSize(fieldNumber, WireType.FIX_64) + FIXED_64_BYTE_SIZE } - fun getFixed64SizeNoTag(value: Long): Int = FIXED_64_BYTE_SIZE + fun getFixed64SizeNoTag(value: Long): Int { + return FIXED_64_BYTE_SIZE + } fun getDoubleSize(fieldNumber: Int, value: Double): Int { return getTagSize(fieldNumber, WireType.FIX_64) + FIXED_64_BYTE_SIZE } - fun getDoubleSizeNoTag(value: Double): Int = FIXED_64_BYTE_SIZE + fun getDoubleSizeNoTag(value: Double): Int { + return FIXED_64_BYTE_SIZE + } fun getFloatSize(fieldNumber: Int, value: Float): Int { return getTagSize(fieldNumber, WireType.FIX_32) + FIXED_32_BYTE_SIZE diff --git a/translator/src/main/kotlin/org/kotlinnative/translator/BlockCodegen.kt b/translator/src/main/kotlin/org/kotlinnative/translator/BlockCodegen.kt index 2fc0903543a..976816f6765 100644 --- a/translator/src/main/kotlin/org/kotlinnative/translator/BlockCodegen.kt +++ b/translator/src/main/kotlin/org/kotlinnative/translator/BlockCodegen.kt @@ -35,7 +35,7 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va if (isBlock) { expressionWalker(expr, scopeDepth) } else { - var result = evaluateExpression(expr, scopeDepth)!! + var result = evaluateExpression(expr, scopeDepth) ?: throw UnexpectedException(expr!!.text) when (result) { is LLVMVariable -> { if (result.pointer == 1 && result.type !is LLVMReferenceType) { @@ -176,8 +176,18 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va val receiverName = receiverExpr.text var receiver = when (receiverExpr) { is KtCallExpression, - is KtBinaryExpression, - is KtDotQualifiedExpression -> evaluateExpression(receiverExpr, scopeDepth) as LLVMVariable + is KtBinaryExpression -> evaluateExpression(receiverExpr, scopeDepth) as LLVMVariable + is KtDotQualifiedExpression -> { + val location = receiverName.split(".") + var codegen: StructCodegen? = state.classes[location[0]] + var i = 1 + while (i < location.size && codegen != null) { + codegen = codegen.nestedClasses[location[i]] + i++ + } + + if (codegen != null) null else evaluateExpression(receiverExpr, scopeDepth) as LLVMVariable + } is KtNameReferenceExpression -> { val referenceContext = state.bindingContext.get(BindingContext.REFERENCE_TARGET, receiverExpr) when (referenceContext) { @@ -331,13 +341,13 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va private fun evaluateReferenceExpression(expr: KtReferenceExpression, scopeDepth: Int, classScope: StructCodegen? = null): LLVMSingleValue? = when { expr is KtArrayAccessExpression -> evaluateArrayAccessExpression(expr, scopeDepth + 1) isEnumClassField(expr, classScope) -> resolveEnumClassField(expr, classScope) - resolveContainingClass(expr) != null -> { - val clazz = resolveContainingClass(expr) - val receiver = if (clazz != null) variableManager[clazz.fullName] ?: variableManager["this"] else variableManager["this"] + variableManager[expr.firstChild.text] != null -> variableManager[expr.firstChild.text] + (expr is KtNameReferenceExpression) && (classScope != null) -> evaluateNameReferenceExpression(expr, classScope.parentCodegen!!) + else -> { + val clazz = resolveCodegen(expr) + val receiver = if (clazz != null) variableManager[clazz.fullName] ?: variableManager["this"] else variableManager["this"] evaluateMemberMethodOrField(receiver!!, expr.firstChild.text, topLevel) } - (expr is KtNameReferenceExpression) && (classScope != null) -> evaluateNameReferenceExpression(expr, classScope.parentCodegen!!) - else -> variableManager[expr.firstChild.text] } private fun evaluateNameReferenceExpression(expr: KtNameReferenceExpression, classScope: StructCodegen): LLVMSingleValue? { @@ -345,6 +355,9 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va val companionObject = (classScope as ClassCodegen).companionObjectCodegen ?: throw UnexpectedException(expr.text) val field = companionObject.fieldsIndex[fieldName] val receiver = variableManager[companionObject.fullName]!! + if (field == null) { + throw UnexpectedException("") + } val result = codeBuilder.getNewVariable(field!!.type, pointer = 1) codeBuilder.loadClassField(result, receiver, field.offset) @@ -405,11 +418,9 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va if (classScope.methods.containsKey(methodShortName)) { val descriptor = classScope.methods[methodShortName]!! val parentDescriptor = descriptor.parentCodegen!! - val receiver = variableManager[parentDescriptor.fullName]!! + val receiver = variableManager[parentDescriptor.fullName] ?: throw UnexpectedException(parentDescriptor.fullName) val methodFullName = descriptor.name - val returnType = descriptor.returnType!!.type - val loadedArgs = loadArgsIfRequired(names, descriptor.args) val callArgs = mutableListOf(receiver) callArgs.addAll(loadedArgs) @@ -567,8 +578,6 @@ abstract class BlockCodegen(val state: TranslationState, val variableManager: Va } left ?: throw UnsupportedOperationException("Wrong binary exception: ${expr.text}") - - val right = evaluateExpression(expr.right, scopeDepth) ?: throw UnsupportedOperationException("Wrong binary exception: ${expr.text}") return executeBinaryExpression(operator, expr.operationReference, left, right) }