Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wa-lang
wa
提交
69671b1d
wa
项目概览
wa-lang
/
wa
12 个月 前同步成功
通知
68
Star
655
Fork
45
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
wa
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
69671b1d
编写于
7月 24, 2022
作者:
3
3dgen
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
添加ctypes包
上级
046f84f0
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
588 addition
and
0 deletion
+588
-0
internal/backends/compiler_c/cir/ctypes/ctypes.go
internal/backends/compiler_c/cir/ctypes/ctypes.go
+415
-0
internal/backends/compiler_c/cir/ctypes/rich_type.go
internal/backends/compiler_c/cir/ctypes/rich_type.go
+173
-0
未找到文件。
internal/backends/compiler_c/cir/ctypes/ctypes.go
0 → 100644
浏览文件 @
69671b1d
//ctypes包定义C-IR的类型
package
ctypes
import
(
"fmt"
"strings"
"github.com/wa-lang/wa/internal/logger"
)
/**************************************
Type: C-IR类型接口
以下类型实现了 Type 接口:
*types.VoidType
*types.FuncType
*types.IntType
*types.FloatType
**************************************/
type
Type
interface
{
fmt
.
Stringer
// CIRString 返回该类型的CIR表达
CIRString
()
string
// Name 返回该类型的名字,例如字符串类型的Name()=="string",而其CIRString()=="std::string"
Name
()
string
// Equal 判断u是否与当前类型相同
Equal
(
u
Type
)
bool
}
var
(
Void
=
&
VoidType
{}
Bool
=
&
BoolType
{}
Int8
=
&
IntType
{
Kind
:
IntKindI8
}
Uint8
=
&
IntType
{
Kind
:
IntKindU8
}
Int16
=
&
IntType
{
Kind
:
IntKindI16
}
Uint16
=
&
IntType
{
Kind
:
IntKindU16
}
Int32
=
&
IntType
{
Kind
:
IntKindI32
}
Uint32
=
&
IntType
{
Kind
:
IntKindU32
}
Int64
=
&
IntType
{
Kind
:
IntKindI64
}
Uint64
=
&
IntType
{
Kind
:
IntKindU64
}
Float
=
&
FloatType
{
Kind
:
FloatKindFloat
}
Double
=
&
FloatType
{
Kind
:
FloatKindDouble
}
)
/**************************************
VoidType:
**************************************/
type
VoidType
struct
{
}
// String 返回该类型的字符串表达
func
(
t
*
VoidType
)
String
()
string
{
return
t
.
Name
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
VoidType
)
CIRString
()
string
{
return
"void"
}
func
(
t
*
VoidType
)
Name
()
string
{
return
"void"
}
// Equal 判断u是否与当前类型相同
func
(
t
*
VoidType
)
Equal
(
u
Type
)
bool
{
if
_
,
ok
:=
u
.
(
*
VoidType
);
ok
{
return
true
}
return
false
}
/**************************************
BoolType:
**************************************/
type
BoolType
struct
{
}
// String 返回该类型的字符串表达
func
(
t
*
BoolType
)
String
()
string
{
return
t
.
Name
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
BoolType
)
CIRString
()
string
{
return
"bool"
}
func
(
t
*
BoolType
)
Name
()
string
{
return
"bool"
}
// Equal 判断u是否与当前类型相同
func
(
t
*
BoolType
)
Equal
(
u
Type
)
bool
{
if
_
,
ok
:=
u
.
(
*
BoolType
);
ok
{
return
true
}
return
false
}
/**************************************
FuncType:
**************************************/
type
FuncType
struct
{
// 返回值类型
Ret
Type
// 参数
Params
[]
Type
}
// NewFunc 根据指定的返回值和参数类型创建函数类型
func
NewFuncType
(
ret
Type
,
params
[]
Type
)
*
FuncType
{
return
&
FuncType
{
Ret
:
ret
,
Params
:
params
,
}
}
// String 返回该类型的字符串表达
func
(
t
*
FuncType
)
String
()
string
{
return
t
.
CIRString
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
FuncType
)
CIRString
()
string
{
buf
:=
&
strings
.
Builder
{}
fmt
.
Fprintf
(
buf
,
"%s ("
,
t
.
Ret
.
CIRString
())
for
i
,
param
:=
range
t
.
Params
{
if
i
!=
0
{
buf
.
WriteString
(
", "
)
}
buf
.
WriteString
(
param
.
String
())
}
buf
.
WriteString
(
")"
)
return
buf
.
String
()
}
func
(
t
*
FuncType
)
Name
()
string
{
logger
.
Fatal
(
"Todo: FuncType.Name()"
)
return
""
}
// Equal 判断u是否与当前类型相同
func
(
t
*
FuncType
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
FuncType
);
ok
{
if
!
t
.
Ret
.
Equal
(
u
.
Ret
)
{
return
false
}
if
len
(
t
.
Params
)
!=
len
(
u
.
Params
)
{
return
false
}
for
i
:=
range
t
.
Params
{
if
!
t
.
Params
[
i
]
.
Equal
(
u
.
Params
[
i
])
{
return
false
}
}
return
true
}
return
false
}
/**************************************
IntType:
**************************************/
type
IntType
struct
{
// 整数类型
Kind
IntKind
}
// IntKind: 整数类型
type
IntKind
uint8
const
(
// 8位有符号整数
IntKindI8
IntKind
=
iota
// 8位无符号整数
IntKindU8
// 16位有符号整数
IntKindI16
// 16位无符号整数
IntKindU16
// 32位有符号整数
IntKindI32
// 32位无符号整数
IntKindU32
// 64位有符号整数
IntKindI64
// 64位无符号整数
IntKindU64
)
var
intKindName
=
[
...
][
2
]
string
{
IntKindI8
:
{
"int8_t"
,
"int8"
},
IntKindU8
:
{
"uint8_t"
,
"uint8"
},
IntKindI16
:
{
"int16_t"
,
"int16"
},
IntKindU16
:
{
"uint16_t"
,
"uint16"
},
IntKindI32
:
{
"int32_t"
,
"int32"
},
IntKindU32
:
{
"uint32_t"
,
"uint32"
},
IntKindI64
:
{
"int64_t"
,
"int64"
},
IntKindU64
:
{
"uint64_t"
,
"uint64"
},
}
func
(
i
IntKind
)
cirString
()
string
{
if
int
(
i
)
>=
len
(
intKindName
)
{
panic
(
"Invalid IntKind."
)
}
return
intKindName
[
i
][
0
]
}
func
(
i
IntKind
)
name
()
string
{
if
int
(
i
)
>=
len
(
intKindName
)
{
panic
(
"Invalid IntKind."
)
}
return
intKindName
[
i
][
1
]
}
// GetBitSize() 返回整数的位宽
func
(
i
IntKind
)
GetBitSize
()
int
{
_IntKindSize
:=
[
...
]
int
{
IntKindI8
:
8
,
IntKindU8
:
8
,
IntKindI16
:
16
,
IntKindU16
:
16
,
IntKindI32
:
32
,
IntKindU32
:
32
,
IntKindI64
:
64
,
IntKindU64
:
64
,
}
if
int
(
i
)
>=
len
(
_IntKindSize
)
{
panic
(
"Invalid IntKind."
)
}
return
_IntKindSize
[
i
]
}
// NewInt 根据给定参数创建整数类型
func
NewInt
(
kind
IntKind
)
*
IntType
{
return
&
IntType
{
Kind
:
kind
,
}
}
// String 返回该类型的字符串表达
func
(
t
*
IntType
)
String
()
string
{
return
t
.
Name
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
IntType
)
CIRString
()
string
{
return
t
.
Kind
.
cirString
()
}
func
(
t
*
IntType
)
Name
()
string
{
return
t
.
Kind
.
name
()
}
// Equal 判断u是否与当前类型相同
func
(
t
*
IntType
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
IntType
);
ok
{
return
u
.
Kind
==
t
.
Kind
}
return
false
}
/*-----------------------------------*/
// FloatType: C-IR的浮点数类型
type
FloatType
struct
{
// 浮点数类型
Kind
FloatKind
}
// FloatKind: 浮点数类型
type
FloatKind
uint8
const
(
// 32位浮点数,IEEE 754 单精度
FloatKindFloat
FloatKind
=
iota
// 64位浮点数,IEEE 754 双精度
FloatKindDouble
)
func
(
i
FloatKind
)
String
()
string
{
_FloatKindName
:=
[
...
]
string
{
FloatKindFloat
:
"float"
,
FloatKindDouble
:
"double"
,
}
if
i
>=
FloatKind
(
len
(
_FloatKindName
))
{
panic
(
"Invalid FloatKind."
)
}
return
_FloatKindName
[
i
]
}
// NewFloat 根据给定参数创建浮点数类型
func
NewFloat
(
kind
FloatKind
)
*
FloatType
{
return
&
FloatType
{
Kind
:
kind
,
}
}
// String 返回该类型的字符串表达
func
(
t
*
FloatType
)
String
()
string
{
return
t
.
Name
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
FloatType
)
CIRString
()
string
{
return
t
.
Kind
.
String
()
}
func
(
t
*
FloatType
)
Name
()
string
{
return
t
.
Kind
.
String
()
}
// Equal 判断u是否与当前类型相同
func
(
t
*
FloatType
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
FloatType
);
ok
{
return
u
.
Kind
==
t
.
Kind
}
return
false
}
/**************************************
PointerType:
**************************************/
type
PointerType
struct
{
Base
Type
}
func
NewPointerType
(
base
Type
)
*
PointerType
{
return
&
PointerType
{
Base
:
base
}
}
// String 返回该类型的字符串表达
func
(
t
*
PointerType
)
String
()
string
{
return
t
.
CIRString
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
PointerType
)
CIRString
()
string
{
return
t
.
Base
.
CIRString
()
+
"*"
}
func
(
t
*
PointerType
)
Name
()
string
{
logger
.
Fatal
(
"Todo: PointerType.Name()"
)
return
""
}
// Equal 判断u是否与当前类型相同
func
(
t
*
PointerType
)
Equal
(
u
Type
)
bool
{
if
ut
,
ok
:=
u
.
(
*
PointerType
);
ok
{
return
t
.
Base
.
Equal
(
ut
.
Base
)
}
return
false
}
/**************************************
RefType:
**************************************/
type
RefType
struct
{
Base
Type
}
func
NewRefType
(
base
Type
)
*
RefType
{
return
&
RefType
{
Base
:
base
}
}
// String 返回该类型的字符串表达
func
(
t
*
RefType
)
String
()
string
{
return
t
.
CIRString
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
RefType
)
CIRString
()
string
{
return
"$wartc::Ref<"
+
t
.
Base
.
CIRString
()
+
">"
}
func
(
t
*
RefType
)
Name
()
string
{
logger
.
Fatal
(
"Todo: RefType.Name()"
)
return
""
}
// Equal 判断u是否与当前类型相同
func
(
t
*
RefType
)
Equal
(
u
Type
)
bool
{
if
ut
,
ok
:=
u
.
(
*
RefType
);
ok
{
return
t
.
Base
.
Equal
(
ut
.
Base
)
}
return
false
}
/**************************************
StringType:
**************************************/
type
StringType
struct
{
}
// String 返回该类型的字符串表达
func
(
t
*
StringType
)
String
()
string
{
return
t
.
CIRString
()
}
// CIRString 返回该类型的CIR语法表达
func
(
t
*
StringType
)
CIRString
()
string
{
return
"std::string"
}
func
(
t
*
StringType
)
Name
()
string
{
return
"string"
}
// Equal 判断u是否与当前类型相同
func
(
t
*
StringType
)
Equal
(
u
Type
)
bool
{
if
_
,
ok
:=
u
.
(
*
StringType
);
ok
{
return
true
}
return
false
}
internal/backends/compiler_c/cir/ctypes/rich_type.go
0 → 100644
浏览文件 @
69671b1d
package
ctypes
import
(
"strconv"
"github.com/wa-lang/wa/internal/logger"
)
/**************************************
Tuple:
**************************************/
type
Tuple
struct
{
Vars
[]
Type
}
func
NewTuple
(
v
[]
Type
)
*
Tuple
{
return
&
Tuple
{
Vars
:
v
}
}
func
(
t
*
Tuple
)
String
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Tuple
)
CIRString
()
string
{
s
:=
"$TupleStart_"
for
_
,
n
:=
range
t
.
Vars
{
s
+=
n
.
Name
()
s
+=
"_"
}
s
+=
"$TupleEnd"
return
s
}
func
(
t
*
Tuple
)
Name
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Tuple
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
Tuple
);
ok
{
return
t
.
CIRString
()
==
u
.
CIRString
()
}
return
false
}
func
(
t
*
Tuple
)
GenStruct
()
Struct
{
var
m
[]
Field
for
i
,
v
:=
range
t
.
Vars
{
m
=
append
(
m
,
*
NewField
(
"$m"
+
strconv
.
Itoa
(
i
),
v
))
}
return
*
NewStruct
(
t
.
CIRString
(),
m
)
}
/**************************************
Struct:
**************************************/
type
Field
struct
{
name
string
typ
Type
}
func
(
i
*
Field
)
CIRString
()
string
{
return
i
.
name
}
func
NewField
(
n
string
,
t
Type
)
*
Field
{
return
&
Field
{
name
:
n
,
typ
:
t
}
}
func
(
i
*
Field
)
Type
()
Type
{
return
i
.
typ
}
type
Struct
struct
{
name
string
Members
[]
Field
}
func
NewStruct
(
name
string
,
m
[]
Field
)
*
Struct
{
return
&
Struct
{
name
:
name
,
Members
:
m
}
}
func
(
t
*
Struct
)
String
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Struct
)
CIRString
()
string
{
return
t
.
name
}
func
(
t
*
Struct
)
Name
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Struct
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
Struct
);
ok
{
return
t
.
CIRString
()
==
u
.
CIRString
()
}
return
false
}
/**************************************
Array:
**************************************/
type
Array
struct
{
len
int64
elem
Type
}
func
NewArray
(
len
int64
,
elem
Type
)
*
Array
{
return
&
Array
{
len
:
len
,
elem
:
elem
}
}
func
(
t
*
Array
)
GetElem
()
Type
{
return
t
.
elem
}
func
(
t
*
Array
)
GetLen
()
int64
{
return
t
.
len
}
func
(
t
*
Array
)
String
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Array
)
CIRString
()
string
{
return
"std::array<"
+
t
.
elem
.
CIRString
()
+
", "
+
strconv
.
Itoa
(
int
(
t
.
len
))
+
">"
}
func
(
t
*
Array
)
Name
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Array
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
Array
);
ok
{
return
t
.
CIRString
()
==
u
.
CIRString
()
}
return
false
}
/**************************************
Slice:
**************************************/
type
Slice
struct
{
elem
Type
}
func
NewSlice
(
elem
Type
)
*
Slice
{
return
&
Slice
{
elem
:
elem
}
}
func
(
t
*
Slice
)
GetElem
()
Type
{
return
t
.
elem
}
func
(
t
*
Slice
)
String
()
string
{
return
t
.
CIRString
()
}
func
(
t
*
Slice
)
CIRString
()
string
{
return
"$wartc::Slice<"
+
t
.
elem
.
CIRString
()
+
">"
}
func
(
t
*
Slice
)
Name
()
string
{
logger
.
Fatal
(
"Todo: Slice.Name()"
)
return
""
}
func
(
t
*
Slice
)
Equal
(
u
Type
)
bool
{
if
u
,
ok
:=
u
.
(
*
Slice
);
ok
{
return
t
.
elem
.
Equal
(
u
.
elem
)
}
return
false
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录