FirstPass

java.lang.Object
- org.vishia.java2C.FirstPass

```
public class FirstPass
extends java.lang.Object
```
This class processes the first pass of translating Java to C of a detect class in a java file. Parsing the content of the java file is done before, see GenerateFile. In the first pass all declared elements of a class are captured and store in the ClassData.

Field Summary

Fields
Modifier and Type	Field and Description
`protected org.vishia.java2C.ClassData`	`classData` The data of this class for first and second path.
`protected LocalIdents`	`fileLevelIdents` A TreeMap of all classData sorted by classname to find all other classData.
`protected org.vishia.mainCmd.Report`	`log`
`protected GenerateFile`	`parentGenerateFile`
`protected java.lang.String`	`sMethodNameCurrent` The C-name of the current translated method, used for _Stacktrace and alloc_s_BlockHeapJc.
`static java.lang.String`	`sVersion` Version, history and license.
`protected org.vishia.java2C.iWriteContent`	`writeContent` A writer to file.

Method Summary

Methods
Modifier and Type	Method and Description
`FieldData`	`createFieldInfo(ZbnfParseResultItem zbnfVariable, ZbnfParseResultItem zbnfType, ZbnfParseResultItem zbnfDescription, ZbnfParseResultItem zbnfAnnotation, ZbnfParseResultItem zbnfNewObject, LocalIdents localIdentsP, StatementBlock blockEnvironment, org.vishia.java2C.ClassData declaringClass, char intension, char definitionCondition)` Prepare the type properties from a given ZBNF `type::=` or adequate info.
`org.vishia.java2C.ClassData`	`gen_AnonymousClass(ZbnfParseResultItem zbnfNewObject, ZbnfParseResultItem zbnfDescription, ZbnfParseResultItem zbnfStatement, LocalIdents localIdents, StatementBlock blockEnvironment, java.lang.String sNameField, char intension, GenerateFile fileContainsClass)` Generate an anonymous class, in Java: `new Type(..){...}`.
`protected CCodeData`	`gen_variableDefinition(ZbnfParseResultItem zbnfStatement, ZbnfParseResultItem zbnfDescription, LocalIdents localIdents, StatementBlock blockEnvironment, java.util.List<org.vishia.java2C.ClassData.InitInfoVariable> listVariablesToInit, char intension)` 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.
`protected CCodeData`	`genConstantValue(ZbnfParseResultItem item)` generates constants values from parse result of the syntaxterm simpleValue.
`static java.lang.String`	`genIndent(boolean isDefine, int indent)` generates a String with the correct indentation.
`int`	`getDimensionsArray(ZbnfParseResultItem zbnfType)` Gets the info whether the type is an array type written like `ident[][]`.
`protected org.vishia.java2C.ClassData`	`getType(ZbnfParseResultItem zbnfType, LocalIdents localIdentsP)` Provides the `ClassData` for the given type.
`protected void`	`setStop()`
`protected void`	`stop()` It's a debug helper.
`protected void`	`stopCond()`
`protected void`	`write_Description(ZbnfParseResultItem item, java.lang.StringBuilder uHeader)` writes the parsed description in the H-File.
`void`	`write_methodDeclaration(ZbnfParseResultItem zbnfMethod, java.lang.String sClassName, LocalIdents localIdents, java.lang.StringBuilder uHeader)` writes a method-forward-declaration in Headerfile and registers the method to generate definition.
`void`	`write_methodInline(ZbnfParseResultItem zbnfMethod, java.lang.String sClassName, LocalIdents localIdents, java.lang.StringBuilder uHeader)` writes a method-forward-declaration in Headerfile and registers the method to generate definition.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sVersion
```
public static final java.lang.String sVersion
```
    Version, history and license.
    - 2014-08-16 Hartmut new: call ClassData.completeOverriddenMethods() as last action of write_HeaderContent(StringBuilder, GenerateFile, ZbnfParseResultItem, boolean, String, ClassData, ClassData[]).
    - 2014-08-16 Hartmut new: gatherAllDefinitions() before running runFirstPass2(StringBuilder) because for generation methods as C-MACROs (#define) all definitions of variables should be known.
    - 2014-08-16 Hartmut new: @Java4C.exclude for varariable definitions.
    - 2014-01-12 Hartmut new: The 'Java4C.inline' annotation is realized. It generates a define for C. TODO: While generating the statements of a inline method other methods are not known yet in the ClassData because there are not registered yet calling gen_methodHeadAndRegisterMethod(ZbnfParseResultItem, int, ClassData, ClassData, String, FieldData, FieldData[], boolean, boolean). First all methods should be registered. After them the header file should be generated. Yet called methods should be declared before calling methods in the Java source.
    - 2014-01-10 Hartmut chg: second parameter 'classMethodBody' in gen_methodHeadAndRegisterMethod(...) is identical with 'classContainsMethod' usually, but not if it is a ctor of an inner non static class. The bug, class variable are not known in a inner ctor, are resolved therewith.
    - 2008 Hartmut created:
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    Constant Field Values
  - log
```
protected final org.vishia.mainCmd.Report log
```
  - writeContent
```
protected org.vishia.java2C.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 org.vishia.java2C.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).
- Method Detail
  - write_methodDeclaration
```
public void write_methodDeclaration(ZbnfParseResultItem zbnfMethod,
                           java.lang.String sClassName,
                           LocalIdents localIdents,
                           java.lang.StringBuilder uHeader)
                             throws java.io.IOException,
                                    java.text.ParseException,
                                    java.lang.IllegalArgumentException,
                                    java.lang.IllegalAccessException,
                                    java.lang.InstantiationException
```
    writes a method-forward-declaration in Headerfile and registers the method to generate definition. It calls
    
    Parameters:
    zbnfMethod - with syntax methodDefinition::=.
    
    Throws:
    
    java.io.IOException
    
    java.text.ParseException
    
    java.lang.InstantiationException
    
    java.lang.IllegalAccessException
    
    java.lang.IllegalArgumentException
  - write_methodInline
```
public void write_methodInline(ZbnfParseResultItem zbnfMethod,
                      java.lang.String sClassName,
                      LocalIdents localIdents,
                      java.lang.StringBuilder uHeader)
                        throws java.io.IOException,
                               java.text.ParseException,
                               java.lang.IllegalArgumentException,
                               java.lang.IllegalAccessException,
                               java.lang.InstantiationException
```
    writes a method-forward-declaration in Headerfile and registers the method to generate definition. It calls
    
    Parameters:
    zbnfMethod - with syntax methodDefinition::=.
    
    Throws:
    
    java.io.IOException
    
    java.text.ParseException
    
    java.lang.InstantiationException
    
    java.lang.IllegalAccessException
    
    java.lang.IllegalArgumentException
  - 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 zbnfStatement,
                               ZbnfParseResultItem zbnfDescription,
                               LocalIdents localIdents,
                               StatementBlock blockEnvironment,
                               java.util.List<org.vishia.java2C.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(). NOTE 2014-01-12: it is wrong that All enhanced references are defined together in 1 headerfile. This fact was changed. TODO description
    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 org.vishia.java2C.ClassData gen_AnonymousClass(ZbnfParseResultItem zbnfNewObject,
                                             ZbnfParseResultItem zbnfDescription,
                                             ZbnfParseResultItem zbnfStatement,
                                             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
  - 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(boolean isDefine,
                         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 org.vishia.java2C.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 zbnfAnnotation,
                        ZbnfParseResultItem zbnfNewObject,
                        LocalIdents localIdentsP,
                        StatementBlock blockEnvironment,
                        org.vishia.java2C.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.
    zbnfAnnotation - The ZBNF result which presents the whole statement. if it is a variable definition this arg is equal zbnfVariable. If it is a method definition this is the method definition statement. This result item is used to check Java4C-annotations which are regarded to the type of the variable or the return type of the method.
    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
  - 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()
```

Class FirstPass

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sVersion

log

writeContent

fileLevelIdents

parentGenerateFile

classData

sMethodNameCurrent

Method Detail

write_methodDeclaration

write_methodInline

write_Description

gen_variableDefinition

gen_AnonymousClass

genConstantValue

genIndent

getType

getDimensionsArray

createFieldInfo

stop

setStop

stopCond