【VxWorks5(1)，2024年最新腾讯T2手把手教你

2401_84265519

已于 2024-04-15 18:41:28 修改

阅读量905

点赞数 8

分类专栏： 2024年程序员学习文章标签： windows 网络服务器

于 2024-04-15 18:41:26 首次发布

本文链接：https://blog.csdn.net/2401_84265519/article/details/137791240

版权

2024年程序员学习专栏收录该内容

45 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

01l,21dec86,dnw changed to not get include files from default directories.
01k,01jul86,jlf documentation.
01j,21may86,llk added lstFree and lstNStep.
01i,09apr86,rdc added lstFind.
01h,20jul85,jlf documentation.
01g,19sep84,jlf fixed spacing in comments by adding .ne’s.
01f,08sep84,jlf added comments and copyright notice.
01e,29jun84,dnw added lstConcat and lstExtract.
01d,03jun84,dnw added lstFirst, lstLast.
changed list.{head,tail} to list.node.{next,previous}.
cleaned up comments, etc.
01c,07may84,ecs added lstNext, lstPrevious, and lstCount.
01b,09jun83,ecs modified the documentation
01a,06aug82,dnw created from old singly-linked-list lib which is now “slllb”.
*/

/*
DESCRIPTION
This subroutine library supports the creation and maintenance of a
doubly linked list. The user supplies a list descriptor (type LIST)
that will contain pointers to the first and last nodes in the list,
and a count of the number of nodes in the list. The nodes in the
list can be any user-defined structure, but they must reserve space
for two pointers as their first elements. Both the forward and
backward chains are terminated with a NULL pointer.

The linked-list library simply manipulates the linked-list data structures;
no kernel functions are invoked. In particular, linked lists by themselves
provide no task synchronization or mutual exclusion. If multiple tasks will
access a single linked list, that list must be guarded with some
mutual-exclusion mechanism (e.g., a mutual-exclusion semaphore).

NON-EMPTY LIST:
.CS

| head--------------->| next----------->| next---------
| | | | | | |
| | ------- prev |<---------- prev | |
| | | | | | | |
| tail------ | | … | ----->| … | |
| | | v | v
|count=2| | ----- | -----
--------- | — | —
| - | -


.CE

EMPTY LIST:
.CS

| head------------------
| | |
| tail---------- |
| | | v
| count=0 | ----- -----

.CE

INCLUDE FILES: lstLib.h
*/

/* LINTLIBRARY */

#include “vxWorks.h”
#include “lstLib.h”
#include “stdlib.h”

#define HEAD node.next /* first node in list /
#define TAIL node.previous / last node in list */

/*********************************************************************
*

lstLibInit - initializes lstLib module
This routine pulls lstLib into the vxWorks image.
RETURNS: N/A
*/
void lstLibInit (void)
{
return;
}

/*********************************************************************
*

lstInit - initialize a list descriptor
This routine initializes a specified list to an empty list.
RETURNS: N/A
*/

void lstInit
(
FAST LIST pList / ptr to list descriptor to be initialized /
)
{
pList->HEAD = NULL;
pList->TAIL = NULL;
pList->count = 0;
}
/************************************************************************
*

lstAdd - add a node to the end of a list
This routine adds a specified node to the end of a specified list.
RETURNS: N/A
*/

void lstAdd
(
LIST pList, / pointer to list descriptor /
NODE pNode / pointer to node to be added /
)
{
lstInsert (pList, pList->TAIL, pNode);
}
/************************************************************************
*

lstConcat - concatenate two lists
This routine concatenates the second list to the end of the first list.
The second list is left empty. Either list (or both) can be
empty at the beginning of the operation.
RETURNS: N/A
*/

void lstConcat
(
FAST LIST pDstList, / destination list */
FAST LIST pAddList / list to be added to dstList /
)
{
if (pAddList->count == 0) / nothing to do if AddList is empty */
return;

if (pDstList->count == 0)
*pDstList = pAddList;
else
{
/ both lists non-empty; update DstList pointers */

pDstList->TAIL->next = pAddList->HEAD;
pAddList->HEAD->previous = pDstList->TAIL;
pDstList->TAIL = pAddList->TAIL;

pDstList->count += pAddList->count;
}

/* make AddList empty */

lstInit (pAddList);
}
/**************************************************************************
*

lstCount - report the number of nodes in a list
This routine returns the number of nodes in a specified list.
RETURNS:
The number of nodes in the list.
*/

int lstCount
(
LIST pList / pointer to list descriptor /
)
{
return (pList->count);
}
/*************************************************************************
*

lstDelete - delete a specified node from a list
This routine deletes a specified node from a specified list.
RETURNS: N/A
*/

void lstDelete
(
FAST LIST pList, / pointer to list descriptor */
FAST NODE pNode / pointer to node to be deleted */
)
{
if (pNode->previous == NULL)
pList->HEAD = pNode->next;
else
pNode->previous->next = pNode->next;

if (pNode->next == NULL)
pList->TAIL = pNode->previous;
else
pNode->next->previous = pNode->previous;

/* update node count */

pList->count–;
}
/************************************************************************
*

lstExtract - extract a sublist from a list
This routine extracts the sublist that starts with and ends
with from a source list. It places the extracted list in
.
RETURNS: N/A
*/

void lstExtract
(
FAST LIST pSrcList, / pointer to source list */
FAST NODE pStartNode, / first node in sublist to be extracted */
FAST NODE pEndNode, / last node in sublist to be extracted */
FAST LIST pDstList / ptr to list where to put extracted list */
)
{
FAST int i;
FAST NODE *pNode;

/* fix pointers in original list */

if (pStartNode->previous == NULL)
pSrcList->HEAD = pEndNode->next;
else
pStartNode->previous->next = pEndNode->next;

if (pEndNode->next == NULL)
pSrcList->TAIL = pStartNode->previous;
else
pEndNode->next->previous = pStartNode->previous;

/* fix pointers in extracted list */

pDstList->HEAD = pStartNode;
pDstList->TAIL = pEndNode;

pStartNode->previous = NULL;
pEndNode->next = NULL;

/* count number of nodes in extracted list and update counts in lists */

i = 0;

for (pNode = pStartNode; pNode != NULL; pNode = pNode->next)
i++;

pSrcList->count -= i;
pDstList->count = i;
}
/************************************************************************
*

lstFirst - find first node in list
This routine finds the first node in a linked list.
RETURNS
A pointer to the first node in a list, or
NULL if the list is empty.
*/

NODE lstFirst
(
LIST pList / pointer to list descriptor /
)
{
return (pList->HEAD);
}
/**********************************************************************
*

lstGet - delete and return the first node from a list
This routine gets the first node from a specified list, deletes the node
from the list, and returns a pointer to the node gotten.
RETURNS
A pointer to the node gotten, or
NULL if the list is empty.
*/

NODE *lstGet
(
FAST LIST pList / ptr to list from which to get node */
)
{
FAST NODE *pNode = pList->HEAD;

if (pNode != NULL) /* is list empty? /
{
pList->HEAD = pNode->next; / make next node be 1st */

if (pNode->next == NULL) /* is there any next node? /
pList->TAIL = NULL; / no - list is empty /
else
pNode->next->previous = NULL; / yes - make it 1st node */

pList->count–; /* update node count */
}

return (pNode);
}
/************************************************************************
*

lstInsert - insert a node in a list after a specified node
This routine inserts a specified node in a specified list.
The new node is placed following the list node .
If is NULL, the node is inserted at the head of the list.
RETURNS: N/A
*/

void lstInsert
(
FAST LIST pList, / pointer to list descriptor */
FAST NODE pPrev, / pointer to node after which to insert */
FAST NODE pNode / pointer to node to be inserted */
)
{
FAST NODE *pNext;

if (pPrev == NULL)
{ /* new node is to be first in list /
pNext = pList->HEAD;
pList->HEAD = pNode;
}
else
{ / make prev node point fwd to new */
pNext = pPrev->next;
pPrev->next = pNode;
}

if (pNext == NULL)
pList->TAIL = pNode; /* new node is to be last in list /
else
pNext->previous = pNode; / make next node point back to new */

/* set pointers in new node, and update node count */

pNode->next = pNext;
pNode->previous = pPrev;

pList->count++;
}
/************************************************************************
*

lstLast - find the last node in a list
This routine finds the last node in a list.
RETURNS
A pointer to the last node in the list, or
NULL if the list is empty.
*/

NODE lstLast
(
LIST pList / pointer to list descriptor /
)
{
return (pList->TAIL);
}
/**********************************************************************
*

lstNext - find the next node in a list
This routine locates the node immediately following a specified node.
RETURNS:
A pointer to the next node in the list, or
NULL if there is no next node.
*/

NODE lstNext
(
NODE pNode / ptr to node whose successor is to be found /
)
{
return (pNode->next);
}
/**********************************************************************
*