c语言结构体数组存入文件_Golang解析C语言结构体语法

最新推荐文章于 2023-01-30 18:27:19 发布
最新推荐文章于 2023-01-30 18:27:19 发布
阅读量355 收藏
点赞数
文章标签： c语言结构体数组存入文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39541227/article/details/112451168
版权
物联网设备的数据常常是一些结构体数据，即将结构体对象转byte数组，我们实现了元数据动态解析这些结构体。然后遇到了一个问题，每个结构体的字段信息很多，填写元数据成了一个很痛苦的事情。针对这个问题，我尝试使用解析C语言头文件，获取结构体的信息，减少人工的操作。

下面涉及一部分编译原理的内容，但是不需要学习过编译原理的知识。

以下代码放到GitHub上

geange/cstruct-go​github.com
98fe662591f27588446e01f4a920f9a9.png

词法分析(lexical analysis)

将头文件的数据转化成Token。 
typedef struct
{
    s32 Longitude;
    s32 Latitude;
    s16 Height;
    u8  Speed;
    u8  Type;
    u8  HeadType;
    u8  HeightType;
    u16 Reserved2;
    u8  Param0;
    u8  Param1;
    u8  Param2;
    u8  Param3;
    u32 Reserved3;
} MSG_Waypoint_t;

上面是一个C语言结构体，token可以看作'typedef'，'struct'，'s32'，';'，'}'等等。（其实这部分是有一些区别的，学过编译原理的应该明白，但是没学过可以先不理会，个人觉得影响不大）。

如果将这一个结构体拆分成一个个Token，要怎么做，没错，就是遍历。。因为头文件的语法超级简单，简单遍历即可（我目前没有对注释信息做处理，所以默认是没有注释的）。

定义一个Scanner接口

type Scanner interface {
	// 格式化，清除注释（我暂时没有写）
	Format() error
	// 获取当前位置的字符
	Fetch() (byte, error)
	// 获取当前位置的字符，并且游标指向下一个字符
	Next() (byte, error)
	// 扫描数值类型
	ScanDigit() (Token, error)
	// 扫描字符类型
	ScanLetter() (Token, error)
	// 扫描全部
	Scan() ([]Token, error)
}

func NewScanner(text []byte) Scanner {
	return &scanner{
		bs:    text,
		index: 0,
	}
}

func NewScannerString(text string) Scanner {
	return &scanner{
		bs:    []byte(text),
		index: 0,
	}
}

type scanner struct {
	bs    []byte
	index int
}

func (s *scanner) Format() error {
	panic("implement me")
}

func (s *scanner) Fetch() (byte, error) {
	if s.index >= len(s.bs) {
		return 0, io.EOF
	}
	return s.bs[s.index], nil
}

func (s *scanner) Next() (byte, error) {
	if s.index >= len(s.bs) {
		return 0, io.EOF
	}

	r := s.bs[s.index]
	s.index++
	return r, nil
}

func (s *scanner) ScanDigit() (Token, error) {
	buf := make([]byte, 0, 10)

	numFlag := false
	pointFlag := false

	for {
		word, err := s.Fetch()
		if err != nil {
			return nil, err
		}
		if isDigit(word) {
			if !numFlag {
				numFlag = true
			}
			buf = append(buf, word)
			s.Next()
			continue
		}

		if word == '.' {
			if !pointFlag {
				pointFlag = true
				buf = append(buf, word)
				s.Next()
				continue
			} else {
				return nil, errors.New("float number has not only one point")
			}
		}

		// end of digit
		break
	}

	if pointFlag {
		num, err := strconv.ParseFloat(string(buf), 64)
		if err != nil {
			return nil, err
		}
		return &DigitToken{
			ttype:      TFloatingPoint,
			floatValue: num,
		}, nil
	}

	num, err := strconv.Atoi(string(buf))
	if err != nil {
		return nil, err
	}
	return &DigitToken{
		ttype:    TInteger,
		intValue: num,
	}, nil
}

func (s *scanner) ScanLetter() (Token, error) {
	buf := make([]byte, 0, 5)

	letterFlag := false

	for {
		b, err := s.Fetch()
		if err != nil {
			return nil, err
		}

		if isLetter(b) {
			letterFlag = true
			buf = append(buf, b)
			s.Next()
			continue
		}

		if isDigit(b) {
			if !letterFlag {
				return nil, errors.New("number not allow to be use as the first of the word")
			}
			buf = append(buf, b)
			s.Next()
			continue
		}
		// end of digit
		break
	}

	word := string(buf)
	if IN(word, ReserveWords...) {
		switch word {
		case "s64":
			return &ReservedWordToken{ttype: TInt64}, nil
		case "s32":
			return &ReservedWordToken{ttype: TInt32}, nil
		case "s16":
			return &ReservedWordToken{ttype: TInt16}, nil
		case "s8":
			return &ReservedWordToken{ttype: TInt8}, nil
		case "u64":
			return &ReservedWordToken{ttype: TUint64}, nil
		case "u32":
			return &ReservedWordToken{ttype: TUint32}, nil
		case "u16":
			return &ReservedWordToken{ttype: TUint16}, nil
		case "u8":
			return &ReservedWordToken{ttype: TUint8}, nil
		case "float":
			return &ReservedWordToken{ttype: TFloat32}, nil
		case "double":
			return &ReservedWordToken{ttype: TFloat64}, nil
		case "type":
			return &ReservedWordToken{ttype: TType}, nil
		case "typedef":
			return &ReservedWordToken{ttype: TTypedef}, nil
		case "struct":
			return &ReservedWordToken{ttype: TStruct}, nil
		case "byte":
			return &ReservedWordToken{ttype: TByte}, nil
		}
	}
	return &LetterToken{ttype: TString, value: word}, nil
}

func (s *scanner) Scan() ([]Token, error) {
	tokens := make([]Token, 0, 10)
	for {
		b, err := s.Fetch()
		if err != nil {
			if err == io.EOF {
				break
			}
		}

		switch {
		case isLetter(b):
			token, err := s.ScanLetter()
			if err != nil {
				return nil, err
			}
			tokens = append(tokens, token)
		case isDigit(b):
			token, err := s.ScanDigit()
			if err != nil {
				return nil, err
			}
			tokens = append(tokens, token)
		case b == ' ' || b == 'n' || b == 't':
			s.Next()
			continue
		case b == ';':
			s.Next()
			token := &DelimiterToken{ttype: TLineEnd}
			tokens = append(tokens, token)
		case b == '[':
			s.Next()
			token := &DelimiterToken{ttype: TLeftBracket}
			tokens = append(tokens, token)
		case b == ']':
			s.Next()
			token := &DelimiterToken{ttype: TRightBracket}
			tokens = append(tokens, token)
		case b == '{':
			s.Next()
			token := &DelimiterToken{ttype: TLeftBrace}
			tokens = append(tokens, token)
		case b == '}':
			s.Next()
			token := &DelimiterToken{ttype: TRightBrace}
			tokens = append(tokens, token)
		}
	}
	return tokens, nil
}

自此获取了全部的Token，下面可以解析结构体了。

这部分理解很简单，当获取一个Token是'i32'时，获取下一个token是该字段的名字，这个时候就需要分2钟情况处理。继续获取Token，如果是分号，说明这不是数组类型，如果获取是中括号就是数组类型了。内嵌结构体的话需要在全局Map中记录结构体的信息，当遇到一个类型非系统预留字（不是i32/i16/long/int这种），那检查是否已经有结构体解析结果，没有解析结果就报错。 
type Lexer interface {
	// 获取当前token
	Fetch() (Token, error)
	// 获取当前Token，游标指向下一个Token
	Next() (Token, error)
	Index(n int) (Token, error)
	CurrentIndex() int
	// 解析声明
	Statement() ([]Field, error)
	// 解析单个结构体
	Structure() (*CStruct, error)
	// 解析整个头文件信息
	AllStructure() ([]*CStruct, error)
	// 是否存在结构体
	ExistStructure(name string) (*CStruct, bool)
}

type lexer struct {
	tokens     []Token
	index      int
	structures map[string]CStruct
}

func (l *lexer) Fetch() (Token, error) {
	if l.index >= len(l.tokens) {
		return nil, io.EOF
	}

	token := l.tokens[l.index]
	return token, nil
}

func (l *lexer) Next() (Token, error) {
	if l.index >= len(l.tokens) {
		return nil, io.EOF
	}
	token := l.tokens[l.index]
	l.index++
	return token, nil
}

func (l *lexer) Index(n int) (Token, error) {
	if n >= len(l.tokens) {
		return nil, io.EOF
	}

	token := l.tokens[n]
	return token, nil
}

func (l *lexer) CurrentIndex() int {
	return l.index
}

func (l *lexer) Statement() ([]Field, error) {
	result := make([]Field, 0)

	dataTypeToken, err := l.Next()
	if err != nil {
		return nil, err
	}

	nameToken, err := l.Next()
	if err != nil {
		return nil, err
	}

	tToken, err := l.Fetch()
	if err != nil {
		return nil, err
	}

	var dType FieldType
	switch dataTypeToken.Type() {
	case TInt64:
		dType = Int64
	case TInt32:
		dType = Int32
	case TInt16:
		dType = Int16
	case TInt8:
		dType = Int8
	case TUint64:
		dType = UInt64
	case TUint32:
		dType = UInt32
	case TUint16:
		dType = UInt16
	case TUint8:
		dType = UInt8
	case TFloat32:
		dType = Float32
	case TFloat64:
		dType = Float64
	case TByte:
		dType = Hex
	}

	// 基础类型
	if tToken.Type() == TLineEnd {
		name := nameToken.Value().(string)
		switch dataTypeToken.Type() {
		case TString:
			// 内嵌子集
			structName := dataTypeToken.Value().(string)
			cStruct, ok := l.ExistStructure(structName)
			if !ok {
				return nil, errors.New(fmt.Sprintf("%s struct not defined", structName))
			}
			fs, err := cStruct.ToStatement()
			if err != nil {
				return nil, errors.Wrap(err, "get statement from sub struct")
			}
			for i := range fs {
				fs[i].Name = fmt.Sprintf("%s_%s", name, fs[i].Name)
			}
			result = append(result, fs...)
		default:
			field := Field{
				Name: name,
				Type: dType,
				Size: getFieldTypeSize(dType),
			}
			result = append(result, field)
		}
		_, _ = l.Next()
		return result, nil
	}

	switch dataTypeToken.Type() {
	case TFloat64, TInt64, TInt32, TInt16, TInt8, TUint64, TUint32, TUint16, TUint8, TByte:
		if tToken.Type() == TLeftBracket {
			fs, err := l.arrayStatement(dataTypeToken, nameToken, nil, false)
			if err != nil {
				return nil, err
			}
			result = append(result, fs...)
		}
	case TString:
		structName := dataTypeToken.Value().(string)
		if tToken.Type() == TLeftBracket {
			if cStruct, ok := l.ExistStructure(structName); ok {
				fs, err := l.arrayStatement(dataTypeToken, nameToken, cStruct, true)
				if err != nil {
					return nil, err
				}
				result = append(result, fs...)
			}
		}
		return nil, errors.New(fmt.Sprintf("%s struct not defined", structName))
	}
	return result, nil
}

func (l *lexer) Structure() (*CStruct, error) {
	token, err := l.Next()
	if err != nil {
		return nil, err
	}

	switch token.Type() {
	case TTypedef:
		stToken, err := l.Next()
		if err != nil {
			return nil, err
		}

		if stToken.Type() != TStruct {
			return nil, errors.New("'struct' not found after typedef")
		}

		bToken, err := l.Fetch()
		if err != nil {
			return nil, err
		}

		if bToken.Type() != TLeftBrace {
			return nil, errors.New("'{' not found after typedef struct")
		}

		fs, err := l.structureInBrace()
		if err != nil {
			return nil, err
		}

		nameToken, err := l.Next()
		if err != nil {
			return nil, err
		}

		if nameToken.Type() != TString {
			return nil, errors.New("structure type not found")
		}

		name := nameToken.Value().(string)
		cStruct := CStruct{
			Name:     name,
			FieldSet: FieldSet(fs),
		}

		endToken, err := l.Next()
		if err != nil {
			return nil, errors.Wrap(err, "';' bot found after struct defined")
		}
		if endToken.Type() != TLineEnd {
			return nil, errors.Wrap(err, "';' bot found after struct defined")
		}

		return &cStruct, nil
	case TStruct:
		nameToken, err := l.Next()
		if err != nil {
			return nil, err
		}

		if nameToken.Type() != TString {
			return nil, errors.New("structure type not found")
		}

		fs, err := l.structureInBrace()
		if err != nil {
			return nil, err
		}
		name := nameToken.Value().(string)
		cStruct := CStruct{
			Name:     name,
			FieldSet: FieldSet(fs),
		}

		endToken, err := l.Next()
		if err != nil {
			return nil, errors.Wrap(err, "';' bot found after struct defined")
		}
		if endToken.Type() != TLineEnd {
			return nil, errors.Wrap(err, "';' bot found after struct defined")
		}

		return &cStruct, nil
	}
	return nil, errors.New("struct format error")
}

func (l *lexer) AllStructure() ([]*CStruct, error) {
	result := make([]*CStruct, 0)
	for {
		cStruct, err := l.Structure()
		if err != nil {
			return nil, err
		}
		result = append(result, cStruct)
		l.structures[cStruct.Name] = *cStruct

		_, err = l.Fetch()
		if err == io.EOF {
			break
		}
	}
	return result, nil
}

func (l *lexer) ExistStructure(name string) (*CStruct, bool) {
	c, ok := l.structures[name]
	return &c, ok
}

func (l *lexer) structureInBrace() ([]Field, error) {
	token, err := l.Next()
	if err != nil {
		return nil, err
	}
	if token.Type() != TLeftBrace {
		return nil, errors.New("'{' not found")
	}

	result := make([]Field, 0)

	for {
		fs, err := l.Statement()
		if err != nil {
			return nil, err
		}
		result = append(result, fs...)

		token, err := l.Fetch()
		if err != nil {
			return nil, err
		}
		if token.Type() == TRightBrace {
			_, _ = l.Next()
			break
		}
	}

	return result, nil
}

虽然也不指望各位能看完。。。

weixin_39541227
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 以数组的形式存储数据（c语言 干货满满）
xiexiexiexieqing的博客
06-10 1916
今天又遇到两个有意思的题 我家来看看吧 以数组的形式存储数据（小明，21）（小花，17）（张三，20）（小红，16）（王二，18） 插入 （li's）
cstruct2go:一个将C结构转换为等效Golang结构的简单工具
05-25
cstruct2go 一个简单的工具将C结构转换为等效的Golang结构 安装 该工具可以通过简单的go build进行编译。 你也可以把它添加到您的GOBIN与go install 用法 ./cstruct2go -i=test_structs.h -o=test_structs.go -p=test_structs CLI选项： -i：输入文件-o：输出文件-p：程序包名称，默认为“ main” -f：格式标志，如果为true，则在输出文件上运行go fmt，默认为true -h：打印帮助 兼容类型 兼容的类型可以在test_structs.h文件中找到
java_celluar.zip_golang_golang 界面_java_celluar
09-21
使用golang语言开发的生命游戏小程序，只完成了很少一部分功能。项目用了gxui界面库，可供大家学习探讨使用。
Golang包学习.zip_DEMO_HTSP_golang_golang 联合_police37w
07-13
golang中文手册,时里包含使用DEMO
大家一起学Golang——结构体、方法
01-07
大家一起学Golang——结构体、方法 结构体类型 空结构体 结构体标签 匿名字段 方法 重写 结构体类型 结构体类型通过一系列的且唯一的字段来声明。在go中数组切片只能存储同一类型的数据，但结构体用户可以自定义将不同数据类型进行组合。 type Student struct{ name string age int } 初始化： st := Student{ name: “Jeff”, age: 18, } 初始化时要换行，每一行要用逗号隔开。 st := Student{“Beniff”,19} 要注意每个字段初始化的顺序 空结构体 st := struct{}{} 占用空间0字节，返回
C语言中结构体的数据结构以及字符数组的存放
cobbQiao的博客
09-26 886
C语言学习笔记---结构体中的字符数组和字符指针
HXYDJ的博客
11-08 2158
  在结构体中可以使用字符数组来存储字符串，也可以使用字符指针来存储字符串。比如： struct str { char s1[5]; char s2[5]; }; struct str str1= {"123","abc"}; 或者 struct str { char *s1; char *s2; }; struct str str1= {"123","abc"};   通过这两种方式定义的结构体都可以正常运行，输出结果也都是一样的。   那么这两种方式在内存中存储是
C#结构体和字节数组的转换
jiangxinyu的专栏
05-23 8284
http://www.haogongju.net/art/624248 在写C#TCP通信程序时，发送数据时，只能发送byte数组，处理起来比较麻烦不说，如果是和VC6.0等写的程序通信的话，很多的都是传送结构体，在VC6.0中可以很方便的把一个char[]数组转换为一个结构体，而在C#却不能直接把byte数组转换为结构体，要在C#中发送结构体，可以按以下方法实现： （1）定义结构体：
c++ 结构体转字节数组_Redis数据结构(上)
weixin_29128423的博客
12-20 327
上一篇我们已经介绍完了Redis的内存模型，本篇我们一起来看一下Redis数据结构。Redis常用的数据结构有以下几种：简单动态字符串链表字典跳表整数集合压缩列表对象Redis 没有直接使用 C 字符串(即以空字符’\0’结尾的字符数组)作为默认的字符串表示，而是使用了SDS。SDS 是简单动态字符串(Simple Dynamic String)的缩写。它是自己构建了一种名为 简单动态字...
eclipse关于"/struts-tags" not found错误的最新解决方法
luckytjm的专栏
04-16 6232
我也是刚开始学习struct2，因为网上说用eclipse比用myeclipse好，然后我就用了eclipse，但是到使用struct标签时老是显示"/struts-tags" not found错误，连个最简单的HelloWorld都搞不定，于是把代码给同学用myeclipse调试，却一点错误都没有，然后我也去网上找过无数的方法来解决，可是依然没有什么起色，不是404错误（工程都找不到），就是5
示例：go语言将结构体的数据保存为JSON格式的文本数据
qq_41358574的博客
01-30 843
JSON格式是一种用途广泛的对象文本格式。在Go语言中，结构体可以通过系统提供的json.Marshal()函数进行序列化。为了演示怎样通过反射获取结构体成员及各种值的过程，下面使用反射将结构体序列化为文本数据。内容摘录自《go语言从入门到进阶实战》（2）准备要序列化的结构体数据。（1）准备数据结构体。（3）调用序列化函数。
实现的go语言的结构体排序
10-22
用go语言实现的结构体排序，使用go的反射包（reflect），实现结构体按指定字段排序，字段类型目前支持int，int64，string，方便扩展任意基本类型，使用直接导入包，然后调用sortStruct(structArr, 'sorft_name', true)
Go 结构体、数组、字典和 json 字符串的相互转换方法
09-18
今天小编就为大家分享一篇Go 结构体、数组、字典和 json 字符串的相互转换方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
client_golang:适用于Go应用程序的Prometheus工具库
04-28
但是，仍将prometheus / client_golang / api /…中的API客户端视为实验性的。 API客户端的重大更改不会触发新的主要版本。 对于在CHANGELOG.md中显式标记为EXPERIMENTAL的所选其他新功能，也是如此。 在，对需要对...
在spark-shell中解决error: not found: value StructType/StructField/StringType问题
someby的博客
11-06 3031
问题描述： 在Spark-shell中运行官方文档提供的例子时，出现error: not found: value StructType/StructField/StringType的错误 解决方法： stackoverflow上 给出的解决方法是导入相应的类型  import org.apache.spark.sql.types._ 导入后问题就解决了...
结构体中数组的使用
chpdirector84的专栏
11-21 3098
 一：对于FIXED数组，如下示例    class Program    {        unsafe struct EPC1G2_TagID        {            public short tagDataLen;            public fixed byte aucTagData[32];        };       
C#学习之byte数组与结构体之间的转换
雍王爷的博客
04-21 7880
原文： http://www.cnblogs.com/sunrack/articles/1244043.html //**注意在我的实际项目中直接调用字节转换，并没有定义结构体 在写C#TCP通信程序时，发送数据时，只能发送byte数组，处理起来比较麻烦不说，如果是和VC6.0等写的程序通信的话，很多的都是传送结构体，在VC6.0中可以很方便的把一个char[]数组转换为一个结构体，而
golang 结构体数组 反转
最新发布
03-23
在Go语言中，可以使用结构体数组来存储一具有相同结构的数据。要反转一个结构体数组，可以使用双指针的方法进行操作。具体步骤如下： 1. 定义一个结构体类型，例如： ```go type Person struct { Name string Age...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值