CDeclTyping

abstract def addStructDeclarationToEnv(e: StructDeclaration, featureExpr: FeatureExpr, env: Env): Env

abstract def checkEnumInitializer(initializer: Expr, fexpr: FeatureExpr, env: Env): Unit

abstract def getExprType(expr: Expr, featureExpr: FeatureExpr, env: Env): Conditional[CType]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object EmptyEnv extends Env

def addAnonStructUse(id: Id, fields: ConditionalTypeMap): Unit

def addDecl(current: Any, featureExpr: FeatureExpr, env: Env, isDefinition: Boolean = true): Unit

def addDefinition(definition: AST, env: Env, feature: FeatureExpr = FeatureExprFactory.True, isFunctionDeclarator: Boolean = false): Unit

def addEnumUse(entry: AST, env: Env, feature: FeatureExpr): Unit

def addEnv(ast: AST, env: Env): Unit

invoked before every external decl, statement and expression with the environment of that node

def addJumpStatements(compoundStatement: CompoundStatement): Unit

def addOldStyleParameters(oldStyleParameters: List[Opt[OldParameterDeclaration]], declarator: Declarator, expr: FeatureExpr, env: Env): Unit

def addStructDeclUse(entry: Id, env: Env, isUnion: Boolean, feature: FeatureExpr): Unit

def addStructDefinition(definition: AST, env: Env, feature: FeatureExpr): Unit

def addStructRedeclaration(env: Env, declaration: Id, feature: FeatureExpr, isUnion: Boolean): Unit

def addStructUse(entry: AST, featureExpr: FeatureExpr, env: Env, structName: String, isUnion: Boolean): Unit

def addTypeUse(entry: AST, env: Env, feature: FeatureExpr): Unit

def addUse(entry: AST, feature: FeatureExpr, env: Env): Unit

def arrayType(t: CType): Boolean

final def asInstanceOf[T0]: T0

def assertTypeSystemConstraint(condition: Boolean, featureExpr: FeatureExpr, msg: String, where: AST): Boolean

def checkStructCompleteness(ctype: CType, expr: FeatureExpr, env: Env, where: AST, checkedStructs: List[String] = Nil): Unit

ensure that the type is complete in the given environment

def checkStructCompletenessC(ctype: Conditional[CType], expr: FeatureExpr, env: Env, where: AST, checkedStructs: List[String] = Nil): Unit

def checkingExternal(externalDef: ExternalDef): Unit

invoked before checking an external declaration (for example used for progress reports)

def clearDeclUseMap(): Unit

def clone(): AnyRef

def coerce(expectedType: CType, foundType: CType): Boolean

determines whether types are compatible in assignements etc

def constructType(specifiers: List[Opt[Specifier]], featureExpr: FeatureExpr, env: Env, locationForErrorMsg: AST): Conditional[CType]

def converse(a: CType, b: CType): CType

ansi c conversion rules of two arithmetic types (if called on other types, it just returns the first type; hence the pattern if cocerce(x,y) return converse(x,y) should yield the default behavior )

def declType(specs: List[Opt[Specifier]], decl: Declarator, attributes: List[Opt[AttributeSpecifier]], featureExpr: FeatureExpr, env: Env, oldStyleParameterTypes: ConditionalTypeMap = null): Conditional[CType]

def enumDeclarations(specs: List[Opt[Specifier]], featureExpr: FeatureExpr, d: AST, env: Env): List[(String, FeatureExpr, AST, Conditional[CType], DeclarationKind, Conditional[Linkage])]

define all fields from enum type specifiers as int values

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterDeadSpecifiers[T](l: List[Opt[T]], ctx: FeatureExpr): List[Opt[T]]

filtering is a workaround for a parsing problem (see open test) that can produce False AST-subtrees in some combinations.

def finalize(): Unit

final def getClass(): Class[_]

def getDeclarationType(specifiers: List[Opt[Specifier]], decl: Declarator, featureExpr: FeatureExpr, env: Env): Conditional[CType]

def getDeclaratorType(decl: Declarator, returnType: Conditional[CType], featureExpr: FeatureExpr, env: Env, oldStyleParameterTypes: ConditionalTypeMap = null): Conditional[CType]

def getDeclaredVariables(decl: Declaration, featureExpr: FeatureExpr, env: Env, checkInitializer: (Expr, Conditional[CType], FeatureExpr, Env) ⇒ Unit = noInitCheck): (Env, List[(String, FeatureExpr, AST, Conditional[CType], DeclarationKind, Conditional[Linkage])])

get a list of all declared variables from a declaration.

def getExternCondition(specifiers: List[Opt[Specifier]]): FeatureExpr

def getFunctionType(specifiers: List[Opt[Specifier]], declarator: Declarator, oldStyleParameters: ConditionalTypeMap, featureExpr: FeatureExpr, env: Env): Conditional[CType]

def getIsExtern(list: List[Opt[Specifier]]): FeatureExpr

under which condition is modifier extern defined?

def getLinkage(symbol: String, isFunctionDef: Boolean, specifiers: List[Opt[Specifier]], fexpr: FeatureExpr, env: Env, where: AST): Conditional[Linkage]

linkage depends on previous identifiers in scope, on the scope (file level or not) and the specifiers

def getOldStyleParameters(oldStyleParameters: List[Opt[OldParameterDeclaration]], featureExpr: FeatureExpr, env: Env): ConditionalTypeMap

def getSpecifierCondition(specifiers: List[Opt[Specifier]], specifier: Specifier): FeatureExpr

def getStaticCondition(specifiers: List[Opt[Specifier]]): FeatureExpr

def getTypenameType(typename: TypeName, featureExpr: FeatureExpr, env: Env): Conditional[CType]

def hashCode(): Int

def init(): Unit

def isArithmetic(t: CType): Boolean

def isArray(t: CType): Boolean

def isCharSignCoercion(a: AType, b: AType): Boolean

are both types char but with different signage?

def isCompound(t: CType): Boolean

def isForcedCoercion(expectedType: AType, foundType: AType): Boolean

we can report as a warning if both types are number, but they are not the same width or signed

def isFunction(t: CType): Boolean

final def isInstanceOf[T0]: Boolean

def isIntegral(t: CType): Boolean

def isPointer(t: CType): Boolean

def isScalar(t: CType): Boolean

def isStruct(t: CType): Boolean

def isTypedef(specs: List[Opt[Specifier]]): Boolean

def isZero(t: CType): Boolean

def issueTypeError(severity: Severity, condition: FeatureExpr, msg: String, where: AST, severityExtra: String = ""): Unit

error reporting for type errors

final def ne(arg0: AnyRef): Boolean

def normalize(t: AType): AType

def normalize(t: CType): CType

normalize types for internal comparison in coerce (do not return this to the outside)

final def notify(): Unit

final def notifyAll(): Unit

def opts: ICTypeSysOptions

def parseStructMembers(members: List[Opt[StructDeclaration]], featureExpr: FeatureExpr, initialEnv: Env): ConditionalTypeMap

def promote(x: CType): CType

promotion is what happens internally during conversion

def recognizeTypedefs(decl: Declaration, featureExpr: FeatureExpr, env: Env): Seq[(String, FeatureExpr, (AST, Conditional[CType]))]

final def reportTypeError(featureExpr: FeatureExpr, txt: String, where: AST, severity: Severity = Severity.OtherError, severityExtra: String = ""): CUnknown

final def synchronized[T0](arg0: ⇒ T0): T0

implicit def toCType(x: CLong): AType

implicit def toCType(x: CShort): AType

implicit def toCType(x: CChar): AType

implicit def toCType(x: CInt): AType

def toString(): String

def typedExpr(expr: Expr, ctype: Conditional[CType], featureExpr: FeatureExpr, env: Env): Unit

invoked after typing an expression

def typedFunction(fun: FunctionDef, ctype: Conditional[CType], featureExpr: FeatureExpr): Unit

invoked after typing a function definition (top level declaration, not nested function)

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit