Documentation
¶
Overview ¶
Package program contains high-level orchestration and state of the input and output program during transpilation.
Index ¶
- Constants
- func AddFunctionDefinition(f FunctionDefinition)
- type Comment
- type FunctionDefinition
- type Program
- func (p *Program) AddImport(importPath string)
- func (p *Program) AddImports(importPaths ...string)
- func (p *Program) AddMessage(message string) bool
- func (p *Program) AppendStartupExpr(e goast.Expr)
- func (p *Program) AppendStartupStatement(stmt goast.Stmt)
- func (p *Program) DefineType(typeName string)
- func (p *Program) GenerateErrorMessage(e error, n ast.Node) string
- func (p *Program) GenerateWarningMessage(e error, n ast.Node) string
- func (p *Program) GenerateWarningOrErrorMessage(e error, n ast.Node, isError bool) string
- func (p *Program) GetComments(n ast.Position) (out []*goast.Comment)
- func (p *Program) GetMessageComments() (_ *goast.CommentGroup)
- func (p *Program) GetNextIdentifier(prefix string) string
- func (p *Program) GetStruct(name string) *Struct
- func (p *Program) ImportType(name string) string
- func (p *Program) Imports() []string
- func (p *Program) IsTypeAlreadyDefined(typeName string) bool
- func (p *Program) StartupStatements() []goast.Stmt
- func (p *Program) String() string
- type Struct
- type StructRegistry
Constants ¶
const Version = "v0.21.4 Zinc 2018-01-30"
Version can be requested through the command line with:
c2go -v
See https://github.com/elliotchance/c2go/wiki/Release-Process
Variables ¶
This section is empty.
Functions ¶
func AddFunctionDefinition ¶ added in v0.9.2
func AddFunctionDefinition(f FunctionDefinition)
AddFunctionDefinition registers a function definition. If the definition already exists it will be replaced.
Types ¶
type FunctionDefinition ¶ added in v0.9.2
type FunctionDefinition struct {
// The name of the function, like "printf".
Name string
// The C return type, like "int".
ReturnType string
// The C argument types, like ["bool", "int"]. There is currently no way
// to represent a varargs.
ArgumentTypes []string
// If this is not empty then this function name should be used instead
// of the Name. Many low level functions have an exact match with a Go
// function. For example, "sin()".
Substitution string
// Can be overridden with the substitution to rearrange the return variables
// and parameters. When either of these are nil the behavior is to keep the
// single return value and parameters the same.
ReturnParameters []int
Parameters []int
}
FunctionDefinition contains the prototype definition for a function.
func GetFunctionDefinition ¶ added in v0.9.2
func GetFunctionDefinition(functionName string) *FunctionDefinition
GetFunctionDefinition will return nil if the function does not exist (is not registered).
type Program ¶
type Program struct {
// These are for the output Go AST.
FileSet *token.FileSet
File *goast.File
// Contains the current function name during the transpilation.
Function *ast.FunctionDecl
// The definitions for defined structs.
// TODO: This field should be protected through proper getters and setters.
Structs StructRegistry
Unions StructRegistry
// If verbose is on progress messages will be printed immediately as code
// comments (so that they do not interfere with the program output).
Verbose bool
// A map of all the global variables (variables that exist outside of a
// function) and their types.
GlobalVariables map[string]string
// This option is not available through the command line. It is to allow the
// internal integration testing to generate the output in the form of a
// Go-test rather than a standalone Go file.
OutputAsTest bool
// EnumConstantToEnum - a map with key="EnumConstant" and value="enum type"
// clang don`t show enum constant with enum type,
// so we have to use hack for repair the type
EnumConstantToEnum map[string]string
// EnumTypedefName - a map with key="Name of typedef enum" and
// value="exist ot not"
EnumTypedefName map[string]bool
// TypedefType - map for type alias, for example:
// C : typedef int INT;
// Map: key = INT, value = int
// Important: key and value are C types
TypedefType map[string]string
// Comments
Comments []Comment
// contains filtered or unexported fields
}
Program contains all of the input, output and transpition state of a C program to a Go program.
func (*Program) AddImport ¶
AddImport will append an absolute import if it is unique to the list of imports for this program.
func (*Program) AddImports ¶ added in v0.11.0
AddImports is a convienience method for adding multiple imports.
func (*Program) AddMessage ¶ added in v0.12.3
AddMessage adds a message (such as a warning or error) comment to the output file. Usually the message is generated from one of the Generate functions in the ast package.
It is expected that the message already have the comment ("//") prefix.
The message will not be appended if it is blank. This is because the Generate functions return a blank string conditionally when there is no error.
The return value will be true if a message was added, otherwise false.
func (*Program) AppendStartupExpr ¶ added in v0.11.0
AppendStartupExpr is a convienience method for adding a new startup statement that is in the form of an expression.
func (*Program) AppendStartupStatement ¶ added in v0.11.0
AppendStartupStatement adds a new statement that must be executed when the program starts up before any other code. These are required to setup state for global variables like STDIN that might be referenced by the program.
func (*Program) DefineType ¶ added in v0.13.7
DefineType will record a type as having already been defined. The purpose for this is to not generate Go for a type more than once. C allows variables and other entities (such as function prototypes) to be defined more than once in some cases. An example of this would be static variables or functions.
func (*Program) GenerateErrorMessage ¶ added in v0.15.0
GenerateErrorMessage - generate error message
func (*Program) GenerateWarningMessage ¶ added in v0.15.0
GenerateWarningMessage - generate warning message
func (*Program) GenerateWarningOrErrorMessage ¶ added in v0.15.0
GenerateWarningOrErrorMessage - generate error if it happen
func (*Program) GetComments ¶ added in v0.21.0
GetComments - return comments
func (*Program) GetMessageComments ¶ added in v0.18.4
func (p *Program) GetMessageComments() (_ *goast.CommentGroup)
GetMessageComments - get messages "Warnings", "Error" like a comment Location of comments only NEAR of error or warning and don't show directly location
func (*Program) GetNextIdentifier ¶ added in v0.11.0
GetNextIdentifier generates a new globally unique identifier name. This can be used for variables and functions in generated code.
The value of prefix is only useful for readability in the code. If the prefix is an empty string then the prefix "__temp" will be used.
func (*Program) GetStruct ¶ added in v0.13.3
GetStruct returns a struct object (representing struct type or union type) or nil if doesn't exist. This method can get struct or union in the same way and distinguish only by the IsUnion field. `name` argument is the C like `struct a_struct`, it allow pointer type like `union a_union *`. Pointer types used in a DeclRefExpr in the case a deferenced structure by using `->` operator to access to a field like this: a_struct->member .
This method is used in collaboration with the field "c2go/program".*Struct.IsUnion to simplify the code like in function "c2go/transpiler".transpileMemberExpr() where the same *Struct value returned by this method is used in the 2 cases, in the case where the value has a struct type and in the case where the value has an union type.
func (*Program) ImportType ¶
ImportType imports a package for a fully qualified type and returns the local type name. For example:
t := p.ImportType("github.com/elliotchance/c2go/darwin.CtRuneT")
Will import "github.com/elliotchance/c2go/darwin" and return (value of t) "darwin.CtRuneT".
func (*Program) IsTypeAlreadyDefined ¶ added in v0.13.7
IsTypeAlreadyDefined will return true if the typeName has already been defined.
A type could be defined:
1. Initially. That is, before the transpilation starts (hard-coded). 2. By calling DefineType throughout the transpilation.
func (*Program) StartupStatements ¶ added in v0.11.0
StartupStatements returns the statements that will be executed before the program starts. These are required to setup state for global variables like STDIN that might be referenced by the program.
type Struct ¶ added in v0.11.1
type Struct struct {
// The name of the struct.
Name string
// True if the struct kind is an union.
// This field is used to avoid to dupplicate code for union case the type is the same.
// Plus, this field is used in collaboration with the method "c2go/program".*Program.GetStruct()
IsUnion bool
// Each of the fields and their C type. The field may be a string or an
// instance of Struct for nested structures.
Fields map[string]interface{}
}
Struct represents the definition for a C struct.
func NewStruct ¶ added in v0.11.1
func NewStruct(n *ast.RecordDecl) *Struct
NewStruct creates a new Struct definition from an ast.RecordDecl.
type StructRegistry ¶ added in v0.13.3
StructRegistry is a map of Struct for struct types and union type
func (StructRegistry) HasType ¶ added in v0.13.3
func (sr StructRegistry) HasType(typename string) bool
HasType method check if type exists
Source Files