org.vishia.java2C
Class GenerateClass

java.lang.Object
  org.vishia.java2C.GenerateClass

Direct Known Subclasses:

FirstPass, SecondPass

 class GenerateClass
extends java.lang.Object

This is the superclass for FirstPass and SecondPass. It contains commonly methods used in both passes and commonly data for both passes. This class isn't store as instance between both passes, elsewhere the ClassData to store are stored in the instance of ClassData, all the ClassData are contained in a list inside AllClassData. The attributes of this class are copied from the Java2C_Main in construction and there are forgotten after running the pass.

log

protected final Report log

sNewLine

private static final java.lang.String sNewLine

String to generate newline and indent.

See Also:

Constant Field Values

writeContent

protected iWriteContent writeContent

A writer to file.

fileLevelIdents

protected final LocalIdents fileLevelIdents

A TreeMap of all classData sorted by classname to find all other classData. This list is complete if the second path runs.

parentGenerateFile

protected final GenerateFile parentGenerateFile

classData

protected ClassData classData

The data of this class for first and second path. A nested class will be recognized as a normal class.

sMethodNameCurrent

protected java.lang.String sMethodNameCurrent

The C-name of the current translated method, used for _Stacktrace and alloc_s_BlockHeapJc. This value is set and used inside SecondPass#write_methodDefinition(ZbnfParseResultItem, String, LocalIdents).

runRequiredFirstPass

final RunRequiredFirstPass_ifc runRequiredFirstPass

The interface to call a firstpass run of a needed type.

stopCond

private boolean stopCond

GenerateClass

protected GenerateClass(iWriteContent writeContent,
                        GenerateFile parentGenerateFile,
                        LocalIdents fileLevelIdents,
                        RunRequiredFirstPass_ifc runRequiredFirstPass,
                        Report log)

constructs the class. This constructor is called from the superclass.

Parameters:

writeContent - The writer to the C- and H-File.

fileLevelIdents - List of all known Classes while translation Java2C

runRequiredFirstPass - Reference to run the first pass of a required class. If in the first or second pass any ClassData from another class are necessary but there was not found in pkgIdents, the first pass of this required class will called recursively while processing the pass of this class.

write_Description

protected void write_Description(ZbnfParseResultItem item,
                                 java.lang.StringBuilder uHeader)
                          throws java.io.IOException

writes the parsed description in the H-File.

Parameters:

item - description::= test_description::=

Throws:

java.io.IOException

gen_variableDefinition

protected CCodeData gen_variableDefinition(ZbnfParseResultItem zbnfVariableDefinition,
                                           ZbnfParseResultItem zbnfDescription,
                                           LocalIdents localIdents,
                                           StatementBlock blockEnvironment,
                                           java.util.List<ClassData.InitInfoVariable> listVariablesToInit,
                                           char intension)
                                    throws java.text.ParseException,
                                           java.io.FileNotFoundException,
                                           java.lang.IllegalArgumentException,
                                           java.io.IOException,
                                           java.lang.IllegalAccessException,
                                           java.lang.InstantiationException

Generates a variable definition with syntax of < variableDefinition>, register the variable in the LocalIdents of the class or block and registers in the list of variables to init or static variables.
The variableDefinition is used both in first and second pass of translation, in the first pass there are the class variables, in the second pass there are variables in block statement. But also arguments for method and constructor calls with the syntax of a in a argumentList::=... are translated with this method. It is the same syntax.

• The LocalIdents are given per reference, it is either the instance of this classData or the instance of the block-statement.
• If the variable is a static variable, it is registered unconditionally in the classData.ClassData.staticVariables. Static variables are only able at class level. Static variables may have an initialization or not.
• If the variable is non-static and it has an initial < value> or < newValue> or < newArray> or < constArray> as ZBNF-child, than the variable is registered in the localIdents of the block or class.
• The initialization is not execute at position of definition of the variable, but
  • for class variables in the constructor.
  • for block variables after the last variable definition (C language necessity).
  • for static variables in the C-file, where the extern declaration is written with this routine also in the Headerfile. Static variables are initialized only with const values yet, the calculation of values from other values is not supported yet. If it is necessary, an extra static initializator-routine is necessary per object-file and should be organized per executable.
  • The variant of const initialization of block variables at position of variable definition isn't used, the same result is gotten by assignment of the value after all variable definitions (is there an optimization effect at C/machine-code-level?)

The FieldData#gen_VariableDefinition() is called inside. The properties of the variable are stored in its FieldData, which are created here from the ZBNF parse results. So the C-code-String of variable definition is able to prepare only with knowledge of the FieldData.
There are some special cases all considered here:

• If it is a final static variable with a immediate simple assignment like final static int name = 5;, a #define name_Classname 5 is produced.
• If it is a final Type ... = new Type(...), an embedded struct is defined in C. That's correct, because a final reference can't be changed and the reference type is equal the instanciated type. Embedded struct constructs are opportune in C to optimize access and memory layout of the data.
• A reference is generated either as normal forward declaration like struct Type_t* ... or with using an enhanced reference like Type_REF .... All enhanced references are defined together in 1 headerfile In form

     typedef struct NAMEREF_t { ObjectRefValuesJc refbase; struct NAME_t* ref; } NAMEREF;
     

  , see referenceNeeded() and Java2C_Main.writeFileRef().

Parameters:

zbnfVariableDefinition - from parsers result.

zbnfDescription - The description to the variable. If the variable is a method argument, than this description is gotten as a part of the method description after tag param. The description may contain java2c-tags. The following tags are respected:

• zeroTermString
• zeroTermStringTODO
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString
• zeroTermString

localIdents - The environment identifiers. Register the variable there, get types from them.

listVariablesToInit - The initialization of variables is stored in this list. The initializations should be done in C not by the variables declaration but in another part of code. For class variables that is the constructor(s). Therefore this parameter should be the ClassData.variablesToInit of this. But if this routine is called inside a statement block, an extra List instance for the block should given locally.

intension - intension of calling

• A = argument list of declaration of a method or constructor.
• a = argument list of definition of a method or constructor.
• b = inside statement block
• c = class level
• s = static class level

Returns:

Code snipped and informations of the variables declaration.

Throws:

java.text.ParseException

java.lang.InstantiationException

java.lang.IllegalAccessException

java.io.IOException

java.lang.IllegalArgumentException

java.io.FileNotFoundException

gen_AnonymousClass

public ClassData gen_AnonymousClass(ZbnfParseResultItem zbnfNewObject,
                                    ZbnfParseResultItem zbnfDescription,
                                    LocalIdents localIdents,
                                    StatementBlock blockEnvironment,
                                    java.lang.String sNameField,
                                    char intension,
                                    GenerateFile fileContainsClass)
                             throws java.io.FileNotFoundException,
                                    java.lang.IllegalArgumentException,
                                    java.io.IOException,
                                    java.lang.IllegalAccessException,
                                    java.lang.InstantiationException,
                                    java.text.ParseException

Generate an anonymous class, in Java: new Type(..){...}.

• Gets the Type of new as baseClass for the anonymous class
• Runs the FirstPass#runFirstPassClass(StringBuilder, GenerateFile, String, String, String, String, ZbnfParseResultItem, boolean, String, ClassData, List, boolean, ClassData).
• Generates a constructor based on the found ctor of the baseClassData, from there the formal argument list and the return type is taken. see also FirstPass#writeCtor(...)
• For anonymous classes, which are found in the second pass, see param intension = 'b', an extra SecondPass.runSecondPassClass(ZbnfParseResultItem, String) is called. The content of this second-pass is written using TODO before the running second-pass.
• For anonymous classes, which are found in the first pass to initialize variables, the normal second pass will regarded it as inner classes.

Parameters:

zbnfNewObject - The parse result from newObject::=...

zbnfNewObject -

zbnfDescription -

localIdents - The idents of the context, either classLevelIdents if intensio TODO always classLevelIdents.

blockEnvironment -

sNameField - The name of the field which is initialized with new Type(..){...} to build the name of the inner class, TODO name of routine.

intension - 'b' if called in an statement block, otherwise: at class level.

fileContainsClass -

Returns:

Throws:

java.io.FileNotFoundException

java.lang.IllegalArgumentException

java.io.IOException

java.lang.IllegalAccessException

java.lang.InstantiationException

java.text.ParseException

get_shortDescription

java.lang.String get_shortDescription(ZbnfParseResultItem zbnfDescription)

Prepares the description from the < description>parse result item. The description is shorted to one line, but only to ". ", the first sentence.

Parameters:

parent - The item

Returns:

Description guaranteed without newline.

genConstantValue

protected CCodeData genConstantValue(ZbnfParseResultItem item)

generates constants values from parse result of the syntaxterm simpleValue. It is called if a < simpleValue> is expected, but the simpleValue should or may be a constant. At example generation a #define NAME VALUE expression in C where a final static int NAME = VALUE; is given in Java.

Parameters:

item - The part of a simpleValue what is

 [ <""?simpleStringLiteral>
 | <''?simpleCharLiteral>
 | 0x<#x?hexNumber>
 | - 0x<#x?hexNumberNegative>
 | <#-?intNumber>[?\.]
 | <#f?floatNumber>F
 | <#f?doubleNumber>
 ]

Returns:

null if it is not any of the named part, than it may be a non constant value, see syntax description in Java.zbnf, return the constant expression in C if it is a constant one.

genIndent

public static java.lang.String genIndent(int indent)

generates a String with the correct indentation.

Parameters:

indent - nr of indentation, as counter for nesting

Returns:

"\n" and the appropriate number of spaces.

getType

protected ClassData getType(ZbnfParseResultItem zbnfType,
                            LocalIdents localIdentsP)
                     throws java.io.FileNotFoundException,
                            java.lang.IllegalArgumentException,
                            java.io.IOException,
                            java.lang.IllegalAccessException,
                            java.lang.InstantiationException,
                            java.text.ParseException

Provides the ClassData for the given type. The type is given in form of a parse result item with semantic

 type::=
 [ [List|LinkedList|ArrayList|Iterator|Class][ \<  \>] 
 | [Map|TreeMap|ArrayList|Iterator|Class][ \<  \>\<  \>] 
 | 
 ] 
 [{ \[ \]}].
 

. Especially because the possibility of <envIdent?typeIdent> the requested type may be a type inside another class (an inner class, Outerclass.Innerclass), so this class should be provided before, and the type should be searched there.

• If the type is known, it means the ClassData with the given key are found, starting in the LocalIdents of the current context, further searching in the Java2C_Main#userTypes and the Java2C_Main.standardClassData, if necessary searched as inner type. It are one or some simple accesses to the appropriate LocalIdents.
• If the type isn't found, or the environment type (<envIdent?typeIdent>) isn't found, it is possible that this type isn't translated yet, but it is a part of the users type.java sources to translate. In this case a type.java-file should be part of input files, given with cmd line arguments -i:FILE or inside the -if:INPFILE. Therefore RunRequiredFirstPass_ifc#runRequestedFirstPass(String type) is called. This routine either processes the parsing and first pass of translation for that file, or it parses the appropriate type.stc File and provides therewith the ClassData. The parsing is a deep recursively process, because other types are need too. This routine is called than recursively.
• If a file with the requested type isn't found, it may be either an not provided standard type (this is a deficiency of this translator, it may be any yet not considered Java standard class is used), or it may be an external type which is provided in the C-handwritten environment, where a only emulating type.java-File in the Java sources exists. In both cases a new ClassData with attribute "external" is created.

In all cases a useable ClassData-instance is returned.

Parameters:

zbnfType - The zbnf-component with syntax type::=....

localIdents - The idents of this level.

Returns:

The ClassData of the type.

Throws:

java.lang.InstantiationException

java.lang.IllegalAccessException

java.io.IOException

java.lang.IllegalArgumentException

java.io.FileNotFoundException

java.text.ParseException

getDimensionsArray

public int getDimensionsArray(ZbnfParseResultItem zbnfType)

Gets the info whether the type is an array type written like ident[][].

Parameters:

zbnfType - The ZBNF parse result for a type.

Returns:

0 if [] isn't found (parse result typeArray isn't present, >0 if it is a array type.

createFieldInfo

public FieldData createFieldInfo(ZbnfParseResultItem zbnfVariable,
                                 ZbnfParseResultItem zbnfType,
                                 ZbnfParseResultItem zbnfDescription,
                                 ZbnfParseResultItem zbnfNewObject,
                                 LocalIdents localIdentsP,
                                 StatementBlock blockEnvironment,
                                 ClassData declaringClass,
                                 char intension,
                                 char definitionCondition)
                          throws java.lang.IllegalAccessException,
                                 java.lang.InstantiationException,
                                 java.io.FileNotFoundException,
                                 java.lang.IllegalArgumentException,
                                 java.io.IOException,
                                 java.text.ParseException

Prepare the type properties from a given ZBNF type::= or adequate info. The type properties are stored in a new FieldData, but without field name. The type properties includes array designation and some Java2CTag.

Parameters:

zbnfVariable - It may be null, if only the type informations should be kept. The ZBNF result which presents a variable definition. Some informations about the type of variable are contained in that level of parse result, like new Array[length], final, a static initialization etc.

zbnfType - The ZBNF result which presents type::= or nonArrayType::= or typeIdent::=

zbnfDescription - The ZBNF result which presents the description part to the type. If it is a variable definition, it is the description to the them. But if it is a argument or return type of a method, it is that part of the description of the method, which describes the param or return. It may contain a <$?Java2CTag> to the type element. This param may be null, if no description of them is available.

zbnfNewObject - maybe given, to create a stack or embedded instance.

localIdentsP - The local visible identifiers.

intension -

Returns:

A new instance of FieldData containing all type informations, but without name of field and without any instance informations like fix size of array etc.

Throws:

java.io.IOException

java.lang.IllegalAccessException

java.lang.InstantiationException

java.io.IOException

java.lang.IllegalArgumentException

java.io.FileNotFoundException - from called getType(ZbnfParseResultItem, LocalIdents).

java.text.ParseException

Since:

2009-06-27

getTypeInfoSimple

FieldData getTypeInfoSimple(ZbnfParseResultItem zbnfVariable,
                            ZbnfParseResultItem zbnfType,
                            ZbnfParseResultItem zbnfDescription,
                            LocalIdents localIdentsP,
                            java.lang.String sNameField,
                            ClassData declaringClass,
                            char intension,
                            char accessMode,
                            ClassData typeClass,
                            ClassData instanceClass,
                            char staticMode,
                            ZbnfParseResultItem itemNewObject)
                      throws java.io.FileNotFoundException,
                             java.lang.IllegalArgumentException,
                             java.io.IOException,
                             java.lang.IllegalAccessException,
                             java.lang.InstantiationException,
                             java.text.ParseException

Throws:

java.io.FileNotFoundException

java.lang.IllegalArgumentException

java.io.IOException

java.lang.IllegalAccessException

java.lang.InstantiationException

java.text.ParseException

createFieldDataNewObject

FieldData createFieldDataNewObject(ZbnfParseResultItem zbnfNewObject,
                                   ZbnfParseResultItem zbnfDescription,
                                   LocalIdents typeIdentsForNew,
                                   LocalIdents localIdentsP,
                                   StatementBlock blockEnvironment,
                                   java.lang.String sNameField,
                                   ClassData declaringClass,
                                   char intension,
                                   char accessModeP,
                                   char staticMode,
                                   boolean isFinal)
                             throws java.io.FileNotFoundException,
                                    java.lang.IllegalArgumentException,
                                    java.io.IOException,
                                    java.lang.IllegalAccessException,
                                    java.lang.InstantiationException,
                                    java.text.ParseException

Creates FieldData for a new Type(...)-construction. If a variable is initialized with the new-construction, it may be an embedded instance, or a instance from a given implementation class or others. This things are detected by evaluating the java2c=annotation in the zbnfDescription, or in zbnfNewObject. Then this method returns the complete FieldData for the variable.

If a new-construction is used in an expression, the param sNameField in null. But the other informations in FieldData may be a point of interesting, so the adequate form is able to use.

• If the variable is final and the new Type is equal the type of variable (or always, TODO), then an embedded instance should created.
• If the variable is final and it is a StringBuffer or new StringBuilder(size), then a embedded fix buffer with direct string should created.

Parameters:

zbnfNewObject - The parse result from expression newObject::=.

zbnfDescription - The description to the variable

typeIdentsForNew -

localIdentsP - The environment for parameters. -not for the new Object.

sNameField - name of variable

declaringClass - The class where the FieldData should be associated to. May be null for statementblock-fields or new in Expression.

intension -

accessModeP -

staticMode -

isFinal -

Returns:

Throws:

java.io.FileNotFoundException

java.lang.IllegalArgumentException

java.io.IOException

java.lang.IllegalAccessException

java.lang.InstantiationException

java.text.ParseException

getTypeInfoArray

FieldData getTypeInfoArray(ZbnfParseResultItem zbnfVariable,
                           ZbnfParseResultItem zbnfType,
                           ZbnfParseResultItem zbnfDescription,
                           LocalIdents localIdentsP,
                           java.lang.String sNameField,
                           ClassData declaringClass,
                           char intension,
                           char accessMode,
                           ClassData typeClass,
                           char staticMode,
                           int dimensionArray)
                     throws java.io.FileNotFoundException,
                            java.lang.IllegalArgumentException,
                            java.io.IOException,
                            java.lang.IllegalAccessException,
                            java.lang.InstantiationException,
                            java.text.ParseException

Throws:

java.io.FileNotFoundException

java.lang.IllegalArgumentException

java.io.IOException

java.lang.IllegalAccessException

java.lang.InstantiationException

java.text.ParseException

stop

protected void stop()

It's a debug helper. The method is empty, but it is a mark to set a breakpoint.

setStop

protected void setStop()

stopCond

protected void stopCond()