Package org.openquark.cal.internal.javamodel

Examples of org.openquark.cal.internal.javamodel.JavaExpression$ClassInstanceCreationExpression


                sw.addCase(new SwitchStatement.IntCaseGroup(i, new ReturnStatement(LiteralWrapper.make(fieldName))));
            }

            javaMethod.addStatement(sw);

            JavaExpression exception =
                new JavaExpression.ClassInstanceCreationExpression(JavaTypeName.INDEX_OUT_OF_BOUNDS_EXCEPTION);
            JavaStatement s =
                new JavaStatement.ThrowStatement (exception);
            javaMethod.addStatement(s);
            return javaMethod;
View Full Code Here


            // We want a singleton instance of the data constructor class to use as a
            // supercombinator.
            // private static final (typeConsType) self = new ThisClass();
            int modifiers = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;
            JavaExpression selfInitializer;
            if (LECCMachineConfiguration.passExecContextToDataConstructors()) {
                selfInitializer = new ClassInstanceCreationExpression(className, JavaExpression.LiteralWrapper.NULL, JavaTypeNames.RTEXECUTION_CONTEXT);
            } else {
                selfInitializer = new ClassInstanceCreationExpression(className);
            }
View Full Code Here

                        fieldType = SCJavaDefn.typeExprToTypeName(fieldTypes[i]);
                    }

                    LiteralWrapper fieldVal = JavaDefinitionBuilder.getDefaultValueForType(fieldType);
                    JavaField jf = new JavaField.Instance(null, javaFieldNames[i], fieldType);
                    JavaExpression assign = new JavaExpression.Assignment(jf, fieldVal);
                    javaConstructor.addStatement(new ExpressionStatement(assign));
                }
            }

        }
View Full Code Here

                argTypes[argTypes.length - 1] = JavaTypeNames.RTEXECUTION_CONTEXT;
                argNames[argNames.length - 1] = SCJavaDefn.EXECUTION_CONTEXT_NAME;
            }

            // Build up the arguments to the superclass constructor.
            JavaExpression superClassConstructorArgValues[] = new JavaExpression [commonFields.size()];
            JavaTypeName   superClassConstructorArgTypes[]  = new JavaTypeName [commonFields.size()];
            int j = 0;
            for (final FieldName fn : commonFields) {
                int fieldIndex = dc.getFieldIndex(fn);
                superClassConstructorArgValues[j] = argVars[fieldIndex];
                superClassConstructorArgTypes[j] = argTypes[fieldIndex];
                j++;
            }

            // Add the method to the class.
            JavaConstructor javaConstructor = new JavaConstructor(modifiers, argNames, argTypes, CALToJavaNames.createInnerClassNameFromDC(dc, module), superClassConstructorArgValues, superClassConstructorArgTypes);
            javaClassRep.addConstructor(javaConstructor);

            if (LECCMachineConfiguration.generateDebugCode()) {
                javaConstructor.addStatement(generateDebugCode(argNames, argTypes));
            }

            // Assert the arguments are not null.
            JavaExpression check = new JavaExpression.OperatorExpression.Binary(JavaOperator.NOT_EQUALS_OBJECT, argVars[0], LiteralWrapper.NULL);
            for (int i = 1, n = dc.getArity(); i < n; ++i) {
                JavaExpression nextCheck = new JavaExpression.OperatorExpression.Binary(JavaOperator.NOT_EQUALS_OBJECT, argVars[i], LiteralWrapper.NULL);
                check = new OperatorExpression.Binary(JavaOperator.CONDITIONAL_AND, check, nextCheck);
            }
            javaConstructor.addStatement(new AssertStatement(check, LiteralWrapper.make("Invalid constructor argument for " + dc.getName().getQualifiedName()), JavaTypeName.STRING));

            // Add the body..
View Full Code Here

                argTypes[argTypes.length - 1] = JavaTypeNames.RTEXECUTION_CONTEXT;
                argNames[argNames.length - 1] = SCJavaDefn.EXECUTION_CONTEXT_NAME;
            }

            // Build up the arguments to the superclass constructor.
            JavaExpression superClassConstructorArgValues[] = new JavaExpression [commonFields.size()];
            JavaTypeName   superClassConstructorArgTypes[]  = new JavaTypeName [commonFields.size()];
            int j = 0;
            for (final FieldName fn : commonFields) {
                int fieldIndex = dc.getFieldIndex(fn);
                superClassConstructorArgValues[j] = argVars[fieldIndex];
                superClassConstructorArgTypes[j] = argTypes[fieldIndex];
                j++;
            }

            // Add the method to the class.
            JavaConstructor javaConstructor = new JavaConstructor(modifiers, argNames, argTypes, CALToJavaNames.createInnerClassNameFromDC(dc, module), superClassConstructorArgValues, superClassConstructorArgTypes);
            javaClassRep.addConstructor(javaConstructor);

            if (LECCMachineConfiguration.generateDebugCode()) {
                javaConstructor.addStatement(generateDebugCode(argNames, argTypes));
            }

            // Assert that object arguments are non-null.
            JavaExpression check = null;
            for (int i = 0, n = dc.getArity(); i < n; ++i) {
                // We only check fields of type RTValue.  It is valid to have an unboxed object value of null.
                if (argTypes[i].equals(JavaTypeNames.RTVALUE)) {
                    JavaExpression newCheck = new OperatorExpression.Binary(JavaOperator.NOT_EQUALS_OBJECT, argVars[i], LiteralWrapper.NULL);
                    if (check == null) {
                        check = newCheck;
                    } else {
                        check = new OperatorExpression.Binary(JavaOperator.CONDITIONAL_AND, check, newCheck);
                    }
View Full Code Here

            // Add the throws declaration
            javaMethod.addThrows(JavaTypeName.CAL_EXECUTOR_EXCEPTION);

            if (LECCMachineConfiguration.generateCallCounts()) {
                JavaExpression args[] = new JavaExpression[2];
                JavaTypeName argTypes[] = new JavaTypeName[2];
                args[0] = LiteralWrapper.make(dc.getName().getModuleName().toSourceText());
                args[1] = LiteralWrapper.make(dc.getName().getUnqualifiedName());
                argTypes[0] = argTypes[1] = JavaTypeName.STRING;
                MethodInvocation mi =
                    new MethodInvocation.Instance(SCJavaDefn.EXECUTION_CONTEXT_VAR,
                                         "dcFunctionCalled",
                                         args,
                                         argTypes,
                                         JavaTypeName.VOID,
                                         MethodInvocation.InvocationType.VIRTUAL);
                javaMethod.addStatement(new ExpressionStatement(mi));
            }

            // Add the body..
            final int arity = dc.getArity();
            if (arity > 0) {
                // // Arguments
                javaMethod.addStatement(new LineComment("Arguments"));

                final boolean addEC = LECCMachineConfiguration.passExecContextToDataConstructors();

                final int nConstructorArgs = addEC ? (arity + 1) : arity;

                // Get arg names
                final JavaExpression[] arguments = new JavaExpression[nConstructorArgs];
                for (int i = 0; i < arity; i++) {
                    final String localVarName = "$arg" + i;
                    arguments[i] = new LocalVariable(localVarName, JavaTypeNames.RTVALUE);
                }


                // final RTValue $arg_i = initializer;
                for (int i = arity - 1; i >= 0; i--) {

                    final JavaExpression initializer;

                    if (i == arity - 1) {
                        //$rootNode.getArgValue();
                        initializer = SCJavaDefn.createInvocation(METHODVAR_ROOT_NODE, SCJavaDefn.GETARGVALUE);

                    } else if (i == arity - 2) {

                        if (arity > 2) {
                            //RTValue $currentRootNode;
                            javaMethod.addStatement(new LocalVariableDeclaration(LOCALVAR_CURRENT_ROOT_NODE));
                            //($currentRootNode = $rootNode.prevArg()).getArgValue();
                            initializer =
                                SCJavaDefn.createInvocation(
                                    new Assignment(LOCALVAR_CURRENT_ROOT_NODE, SCJavaDefn.createInvocation(METHODVAR_ROOT_NODE, SCJavaDefn.PREVARG)),
                                    SCJavaDefn.GETARGVALUE);
                        } else {
                            //$rootNode.prevArg().getArgValue();
                            initializer =
                                SCJavaDefn.createInvocation(
                                    SCJavaDefn.createInvocation(METHODVAR_ROOT_NODE, SCJavaDefn.PREVARG),
                                    SCJavaDefn.GETARGVALUE);
                        }

                    } else if (i == 0) {

                        //$currentRootNode.prevArg().getArgValue();
                        initializer =
                            SCJavaDefn.createInvocation(
                                SCJavaDefn.createInvocation(LOCALVAR_CURRENT_ROOT_NODE, SCJavaDefn.PREVARG),
                                SCJavaDefn.GETARGVALUE);

                    } else {

                        //($currentRootNode = $currentRootNode.prevArg()).getArgValue();
                        initializer =
                            SCJavaDefn.createInvocation(
                                new Assignment(LOCALVAR_CURRENT_ROOT_NODE, SCJavaDefn.createInvocation(LOCALVAR_CURRENT_ROOT_NODE, SCJavaDefn.PREVARG)),
                                SCJavaDefn.GETARGVALUE);
                    }

                    final LocalVariableDeclaration argDeclaration =
                        new LocalVariableDeclaration((LocalVariable)arguments[i], initializer, !fieldStrictness[i]);

                    javaMethod.addStatement(argDeclaration);
                }

                // Get arg types - all RTValues.
                final JavaTypeName[] argTypes = new JavaTypeName[nConstructorArgs];
                Arrays.fill(argTypes, JavaTypeNames.RTVALUE);

                if (addEC) {
                    arguments[arguments.length - 1] = SCJavaDefn.EXECUTION_CONTEXT_VAR;
                    argTypes[argTypes.length - 1] = JavaTypeNames.RTEXECUTION_CONTEXT;
                }

                for (int i = 0; i < dc.getArity(); ++i) {
                    if (fieldStrictness[i]) {
                        arguments[i]= new MethodInvocation.Instance (arguments[i],
                                                            "evaluate",
                                                            SCJavaDefn.EXECUTION_CONTEXT_VAR,
                                                            JavaTypeNames.RTEXECUTION_CONTEXT,
                                                            JavaTypeNames.RTVALUE,
                                                            MethodInvocation.InvocationType.VIRTUAL);

                        if (SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                            argTypes[i] = SCJavaDefn.typeExprToTypeName(fieldTypes[i]);
                            arguments[i] = SCJavaDefn.unboxValue(SCJavaDefn.typeExprToTypeName(fieldTypes[i]), arguments[i]);
                        }
                    }
                }

                // return new ThisClass($arg0, $arg1, ...);
                final JavaExpression cice = new ClassInstanceCreationExpression(className, arguments, argTypes);

                javaMethod.addStatement(new ReturnStatement(cice));
            } else {
                // return new ThisClass();
                final JavaExpression cice = new ClassInstanceCreationExpression(className, JavaExpression.LiteralWrapper.NULL, JavaTypeNames.RTEXECUTION_CONTEXT);
                javaMethod.addStatement(new ReturnStatement(cice));
            }
        }
View Full Code Here

            // Add the throws declaration
            javaMethod.addThrows(JavaTypeName.CAL_EXECUTOR_EXCEPTION);

            if (LECCMachineConfiguration.generateCallCounts()) {
                JavaExpression args[] = new JavaExpression[2];
                JavaTypeName ccArgTypes[] = new JavaTypeName[2];
                args[0] = LiteralWrapper.make(dc.getName().getModuleName().toSourceText());
                args[1] = LiteralWrapper.make(dc.getName().getUnqualifiedName());
                ccArgTypes[0] = ccArgTypes[1] = JavaTypeName.STRING;
                MethodInvocation mi =
                    new MethodInvocation.Instance(SCJavaDefn.EXECUTION_CONTEXT_VAR,
                                         "dcFunctionCalled",
                                         args,
                                         ccArgTypes,
                                         JavaTypeName.VOID,
                                         MethodInvocation.InvocationType.VIRTUAL);

                javaMethod.addStatement(new ExpressionStatement(mi));
            }

            boolean addEC = LECCMachineConfiguration.passExecContextToDataConstructors();
            int nConstructorArgs = dc.getArity();
            if (addEC) {
                nConstructorArgs++;
            }

            JavaExpression constructorArgs[] = new JavaExpression [nConstructorArgs];
            JavaTypeName constructorArgTypes[] = new JavaTypeName [nConstructorArgs];
            System.arraycopy(argTypes, 0, constructorArgTypes, 0, constructorArgTypes.length);

            if (addEC) {
                constructorArgs[constructorArgs.length - 1] = SCJavaDefn.EXECUTION_CONTEXT_VAR;
            }

            for (int i = 0; i < dc.getArity(); ++i) {
                constructorArgs[i] = new MethodVariable("member" + i);
                if (fieldStrictness[i]) {
                    constructorArgs[i] = new MethodInvocation.Instance (constructorArgs[i],
                                                    "evaluate",
                                                    SCJavaDefn.EXECUTION_CONTEXT_VAR,
                                                    JavaTypeNames.RTEXECUTION_CONTEXT,
                                                    JavaTypeNames.RTVALUE,
                                                    MethodInvocation.InvocationType.VIRTUAL);

                    if (SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                        constructorArgs[i] = SCJavaDefn.unboxValue(SCJavaDefn.typeExprToTypeName(fieldTypes[i]), constructorArgs[i]);
                        constructorArgTypes[i] = SCJavaDefn.typeExprToTypeName(fieldTypes[i]);
                    }
                }
            }

            JavaExpression cc = new ClassInstanceCreationExpression (className, constructorArgs, constructorArgTypes);

            javaMethod.addStatement(new ReturnStatement(cc));
        }
View Full Code Here

            String methodName = "get" + javaFieldNames[i];
            JavaMethod javaMethod = new JavaMethod(modifiers, returnType, methodName);
            javaClassRep.addMethod(javaMethod);

            // return a boxed version of the field.
            JavaExpression jf;
            if (fieldStrictness[i] && SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                jf = new JavaField.Instance (null, javaFieldNames[i], SCJavaDefn.typeExprToTypeName(fieldTypes[i]));
                jf = SCJavaDefn.boxExpression(fieldTypes[i], jf);
                javaMethod.addStatement(new ReturnStatement(jf));
            } else {
View Full Code Here

                            continue;
                        }
                    }
                }

                JavaExpression jf;
                if (fieldStrictness[i] && SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                    jf = new JavaField.Instance (null, javaFieldNames[i], SCJavaDefn.typeExprToTypeName(fieldTypes[i]));
                    if (forType == null) {
                        jf = SCJavaDefn.boxExpression(fieldTypes[i], jf);
                    }
View Full Code Here

            //}

            JavaMethod javaMethod = new JavaMethod (Modifier.PUBLIC | Modifier.FINAL, JavaTypeName.BOOLEAN, "isFunctionSingleton");
            javaClassRep.addMethod (javaMethod);

            JavaExpression conditionExpr =
                new OperatorExpression.Binary(
                    JavaOperator.EQUALS_OBJECT,
                    new JavaExpression.JavaField.This(className),
                    new JavaExpression.JavaField.Static(className, "$instance", className));
View Full Code Here

TOP

Related Classes of org.openquark.cal.internal.javamodel.JavaExpression$ClassInstanceCreationExpression

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.