Package org.openquark.cal.internal.javamodel

Examples of org.openquark.cal.internal.javamodel.JavaConstructor


            // Import the constructors for each inner class (i.e. each data constructor)
            // Pull in the constructor for the Java class.
            for (int i = 0, n = javaClass.getNInnerClasses(); i < n; ++i) {
                JavaClassRep innerClass = javaClass.getInnerClass(i);
                assert (innerClass.getNConstructors() == 1);
                JavaConstructor constructor = innerClass.getConstructor(0);
                topLevelDefnsList.add(importJavaConstructor(constructor, true));
            }
           
            // Create accessors for fields in the top level class.
            for (FieldName fn : typeConstructorInfo.commonFieldNames) {
View Full Code Here


            String javaConstructorName = fixupClassName(dc.getName().getUnqualifiedName());
            String calConstructorName = "j" + javaConstructorName + "_new";
           
            TypeExpr[] dcFieldTypeExprs = getFieldTypesForDC(dc);

            JavaConstructor javaConstructor = null;
            if (isInnerClass) {
                for (int i = 0, n = javaClass.getNInnerClasses(); i < n; ++i) {
                    JavaClassRep innerClass = javaClass.getInnerClass(i);
                    if (innerClass.getClassName().getUnqualifiedJavaSourceName().endsWith("." + javaConstructorName)) {
                        javaConstructor = innerClass.getConstructor(0);
                        break;
                    }
                }
            } else {
                javaConstructor = javaClass.getConstructor(0);
            }
           
            if (javaConstructor == null) {
                throw new NullPointerException ("Unable to find Java constructor for data constructor " + dc.getName());
            }
           
            int nArgs = javaConstructor.getNParams();
           
            if (nArgs == 0) {
                return SourceModel.Expr.Var.makeUnqualified(calConstructorName);
            }
           
            TypeExprDefn argTypes[] = new TypeExprDefn[nArgs];
            for (int i = 0; i < nArgs; ++i) {
                argTypes[i] = getTypeExprDefn(new JavaTypeName[]{javaConstructor.getParamType(i)});
            }

            SourceModel.Expr applicationExpressions[] = new SourceModel.Expr[nArgs+ 1];
            SourceModel.Expr.Var output = Expr.Var.make(CAL_Prelude.Functions.output);
View Full Code Here

                int index = constructorName.lastIndexOf('.');
                if (index > -1) {
                    constructorName = constructorName.substring(index + 1);
                }
               
                JavaConstructor constructor;
                if (!typeConstructorInfo.isEnumerationType) {
                    constructor = new JavaConstructor (Modifier.PRIVATE, argNames, argTypes, constructorName);
                } else {
                    constructor = new JavaConstructor (Modifier.PUBLIC, argNames, argTypes, constructorName);
                }
               
                constructor.addStatement(constructorBody);
               
                return constructor;
            }
View Full Code Here

             */
            private final JavaConstructor createConstructor_default (
                    JavaTypeName className,
                    boolean isEnumeration) {
               
                JavaConstructor constructor;
                if (isEnumeration) {
                    // We want a private constructor that initializes the name$ and ordinal$ fields.
                    constructor =
                        new JavaConstructor (
                                Modifier.PRIVATE,
                                new String[]{"ordinal", "name"},
                                new JavaTypeName[]{JavaTypeName.INT, JavaTypeName.STRING},
                                className.getUnqualifiedJavaSourceName());
                   
                    JavaExpression assignOrdinal =
                        new JavaExpression.Assignment (
                                new JavaField.Instance(null, ORDINAL_FIELD_NAME, JavaTypeName.INT),
                                new MethodVariable("ordinal"));
                    constructor.addStatement(new ExpressionStatement(assignOrdinal));
                   
                    JavaExpression assignName =
                        new JavaExpression.Assignment (
                                new JavaField.Instance(null, DC_NAME_FIELD_NAME, JavaTypeName.STRING),
                                new MethodVariable("name"));
                    constructor.addStatement(new ExpressionStatement(assignName));
                   
                } else {
                    constructor = new JavaConstructor (Modifier.PUBLIC, className.getUnqualifiedJavaSourceName());
                }
               
                return constructor;
            }       
View Full Code Here

                int index = constructorName.lastIndexOf('.');
                if (index > -1) {
                    constructorName = constructorName.substring(index + 1);
                }
               
                JavaConstructor constructor;
                if (typeConstructorInfo.commonFieldNames.size() > 0) {
                    JavaExpression superArgValues[] = new JavaExpression[typeConstructorInfo.commonFieldNames.size()];
                    JavaTypeName superArgTypes[] = new JavaTypeName[superArgValues.length];
                    int i = 0;
                    for (FieldName superFieldName : typeConstructorInfo.commonFieldNames) {
                        JavaTypeName fieldType = (JavaTypeName)dci.fieldTypeNames.get(superFieldName);
                        String fieldName = (String)typeConstructorInfo.fieldJavaNames.get(superFieldName);
                        String argName = fieldName+"$";
                        JavaExpression superArgValue = new MethodVariable(argName);
                        superArgValues[i] = superArgValue;
                        superArgTypes[i] = fieldType;
                        ++i;
                    }
                   
                    constructor = new JavaConstructor (Modifier.PUBLIC, argNames, argTypes, constructorName, superArgValues, superArgTypes);
                } else {
                    constructor = new JavaConstructor (Modifier.PUBLIC, argNames, argTypes, constructorName);
                   
                }
               
                constructor.addStatement(constructorBody);
               
                return constructor;

            }
View Full Code Here

            MethodVariable $fieldOrdinalVariable = new MethodVariable(argNames[2]);
            MethodVariable $errorInfoVariable = new MethodVariable(argNames[3]);

            // Create the constructor.
            // In this case we simply pass the parameters to the superclass constructor.
            JavaConstructor constructor =
                new JavaConstructor (Modifier.PUBLIC,
                                     argNames,
                                     argTypes,
                                     "FieldSelection",
                                     new JavaExpression[]{
                                         $dataConsExprVariable,
View Full Code Here

         */
        private void createConstructor_noArgs() throws CodeGenerationException {
            int modifiers = 0;

            boolean addEC = LECCMachineConfiguration.passExecContextToDataConstructors();
            JavaConstructor javaConstructor;
            if (addEC) {
                modifiers |= Modifier.PUBLIC;
                javaConstructor = new JavaConstructor(modifiers,  new String[]{SCJavaDefn.EXECUTION_CONTEXT_NAME}, new JavaTypeName[]{JavaTypeNames.RTEXECUTION_CONTEXT}, CALToJavaNames.createInnerClassNameFromDC(dc, module));
            } else {
                modifiers |= Modifier.PRIVATE;
                javaConstructor = new JavaConstructor(modifiers, CALToJavaNames.createInnerClassNameFromDC(dc, module));
            }
            // Add the method to the class.
            javaClassRep.addConstructor(javaConstructor);

            // Initialize any final fields.
            for (int i = 0; i < dc.getArity(); ++i) {
                if (!commonFields.contains(dc.getNthFieldName(i)) && fieldStrictness[i]) {
                    JavaTypeName fieldType = JavaTypeNames.RTVALUE;
                    if (SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                        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

                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..
            // We want to assign any fields in this class.
            for (int i = 0; i < dc.getArity(); i++) {
                if (commonFields.contains(dc.getNthFieldName(i))) {
                    // This field is in the containing class so we don't
                    // assign here.
                    continue;
                }

                JavaField field = new JavaField.Instance(null, javaFieldNames[i], JavaTypeNames.RTVALUE);

                Assignment memberAssignment = new Assignment(field, argVars[i]);
                javaConstructor.addStatement(new ExpressionStatement(memberAssignment));
            }

            // Add the statistics block.
            addStatsBlock(javaConstructor);
        }
View Full Code Here

                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);
                    }
                }
            }
            if (check != null) {
                javaConstructor.addStatement(new AssertStatement(check, LiteralWrapper.make("Invalid constructor argument for " + dc.getName().getQualifiedName()), JavaTypeName.STRING));
            }

            // Add the body..
            // We want to assign any of the fields in this class.
            for (int i = 0, n = dc.getArity(); i < n; i++) {
                if (commonFields.contains(dc.getNthFieldName(i))) {
                    // This field is in the containing class so we don't
                    // assign here.
                    continue;
                }
                JavaTypeName fieldType = JavaTypeNames.RTVALUE;
                if (fieldStrictness[i] && SCJavaDefn.canTypeBeUnboxed(fieldTypes[i])) {
                    fieldType = SCJavaDefn.typeExprToTypeName(fieldTypes[i]);
                }

                JavaField field = new JavaField.Instance(null, javaFieldNames[i], fieldType);

                Assignment memberAssignment = new Assignment(field, argVars[i]);
                javaConstructor.addStatement(new ExpressionStatement(memberAssignment));
            }

            // Add the statistics block.
            addStatsBlock(javaConstructor);
        }
View Full Code Here

         * @param fieldNameToType
         * @param fieldNameToStrictness
         * @return the constructor.
         */
        private JavaConstructor createDefaultConstructor (Set<FieldName> fieldNames, Map<FieldName, JavaTypeName> fieldNameToType, Map<FieldName, Boolean> fieldNameToStrictness) {
            JavaConstructor constructor = new JavaConstructor (Modifier.PROTECTED, className.getUnqualifiedJavaSourceName());

            // The final fields need to be initialized to a default value.
            for (final FieldName fn : fieldNames) {
                boolean strict = fieldNameToStrictness.get(fn).booleanValue();
                if (!strict) {
                    continue;
                }
                JavaTypeName type = fieldNameToType.get(fn);
                String fieldName = SCJavaDefn.getJavaFieldNameFromFieldName(fn);

                JavaExpression assign = new JavaExpression.Assignment(new JavaField.Instance(null, fieldName, type), getDefaultValueForType(type));
                constructor.addStatement(new ExpressionStatement(assign));
            }

            return constructor;
        }
View Full Code Here

TOP

Related Classes of org.openquark.cal.internal.javamodel.JavaConstructor

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.