2024-06-23 编译原理实验4——中间代码生成

news2024/12/28 20:50:10

文章目录

    • 一、实验要求
    • 二、实验设计
    • 三、实验结果
    • 四、附完整代码

补录与分享本科实验，以示纪念。

一、实验要求

在词法分析、语法分析和语义分析程序的基础上，将C−−源代码翻译为中间代码。
要求将中间代码输出成线性结构（三地址代码），使用虚拟机小程序（附录B）来测试中间代码的运行结果。
由于在后面的实验中还会用到本次实验已经写好的代码，因此保持一个良好的代码风格、系统地设计代码结构和各模块之间的接口对于整个实验来讲相当重要！

  • 基本要求
    1. 对于正确的测试样例，输出可以在虚拟机上运行的中间代码文件。
    2. 在程序可以生成正确的中间代码（“正确”是指该中间代码在虚拟机小程序上运行结果正确）的前提下，效率也是最终评分的关键因素。
  • 附加要求
  1. 修改前面对C−−源代码的假设2和3，使源代码中：
    a) 可以出现结构体类型的变量（但不会有结构体变量之间直接赋值）。
    b) 结构体类型的变量可以作为函数的参数（但函数不会返回结构体类型的值）。
  2. 修改前面对C−−源代码的假设2和3，使源代码中：
    c) 一维数组类型的变量可以作为函数参数（但函数不会返回一维数组类型的值）。
    d) 可以出现高维数组类型的变量（但高维数组类型的变量不会作为函数的参数或返回类值）。

本实验只实现了abc，没有实现d。

二、实验设计

1、translate
该函数使用switch-case寻找需要处理的节点进行处理，否则继续寻找下层结点：

void translate(Node *h) {
    if (h == NULL) return;
    switch (h->type) {
        case Specifier:
            return;
        case FunDec: {
            translateFunDec(h);
            break;
        }
        case Dec: {
            translateDec(h);
            break;
        }
        case Stmt: {
            translateStmt(h);
            break;
        }
        default: {
            for (int i = 0; i < h->childNum; i++)
                translate(h->child[i]);
            break;
        }
    }
}

语义分析需要对每个匹配的产生式进行分析，因此需要写专门的函数进行操作。每个函数的操作均不一样，但也拥有相同的操作：

bool checkNode(Node *node, Types type) {
   if (node == NULL) {
      addLogNullNode(type);
      return false;
   }
   else if (node->type != type) {
      addLogTypeDismatch(type);
      return false;
   }
   addLogStartDealing(type);
   return true;
}

bool hasBrothers(Node *node, int n, ...) {
   va_list vaList;
   va_start(vaList, n);
   Types next;
   for (int i = 0; i < n; ++i) {
      next = va_arg(vaList, Types);
      if (node == NULL || next != node->type) return false;
      node = node->brother;
   }
   return node == NULL;
}

2、translateExp
我们注意到，一个exp的处理需要分两种情况：刚定义和已定义。即未被处理和已被处理过。于是我们添加了一个参数option：option = 0表示exp未被用过，option = 1表示exp已被用过。
这样做的另一个好处是，可以实现exp值的向上传递。
因此，translateExp函数对每一个匹配的产生式都进行了两种处理：option = 0和option = 1。

void translateExp(Node *h, char *place, int option) {
    if (h->child[0]->type == _LP) {
        return translateExp(h->child[1], place, option);
    } else if (h->childNum == 3 && h->child[1]->type == _ASSIGNOP) {
        char temp[MAX_LENGTH];
        translateExp(h->child[0], temp, 0);
        translateExp(h->child[2], temp, 1);
        if (place != NULL) {
            if (option == 0) {
                strcpy(place, temp);
            } else {
                addIrCode(3, place, ":=", temp);
            }
        }
    } else if (h->childNum == 3 && h->child[1]->type == _LP) {
        if (place == NULL) {
            if (strcmp(h->child[0]->name, "read") == 0)
                return;
            char temp[MAX_LENGTH];
            newTemp(temp);
            addIrCode(4, temp, ":=", "CALL", h->child[0]->name);
        } else {
            if (option == 0)
                newTemp(place);
            if (strcmp(h->child[0]->name, "read") == 0)
                addIrCode(2, "READ", place);
            else
                addIrCode(4, place, ":=", "CALL", h->child[0]->name);
        }
    } else if (h->childNum == 4 && h->child[1]->type == _LP) {
        if (place == NULL) {
            if (strcmp(h->child[0]->name, "write") == 0) {
                char temp[MAX_LENGTH];
                translateExp(h->child[2]->child[0], temp, 0);
                addIrCode(2, "WRITE", temp);
            } else {
                FunDefUnit *f = getFunction(h->child[0]->name);
                translateArgs(h->child[2], f->parameterList, 0);
                char temp[MAX_LENGTH];
                newTemp(temp);
                addIrCode(4, temp, ":=", "CALL", h->child[0]->name);
            }
        } else {
            if (strcmp(h->child[0]->name, "write") == 0) {
                char temp[MAX_LENGTH];
                translateExp(h->child[2]->child[0], temp, 0);
                addIrCode(2, "WRITE", temp);
                if (option == 0) {
                    place[0] = '#';
                    place[1] = '0';
                    place[2] = '\0';
                } else {
                    addIrCode(3, place, ":=", "#0");
                }
            } else {
                FunDefUnit *f = getFunction(h->child[0]->name);
                translateArgs(h->child[2], f->parameterList, 0);
                if (option == 0)
                    newTemp(place);
                addIrCode(4, place, ":=", "CALL", h->child[0]->name);
            }
        }
    }
    if (place == NULL)return;
    if (h->child[0]->type == _INT) {
        if (option == 0) {
            sprintf(place, "#%d", h->child[0]->intValue);
        } else {
            char temp[MAX_LENGTH];
            sprintf(temp, "#%d", h->child[0]->intValue);
            addIrCode(3, place, ":=", temp);
        }
    } else if (h->child[0]->type == _ID && h->childNum == 1) {
        if (option == 0) {
            strcpy(place, h->child[0]->name);
        } else {
            addIrCode(3, place, ":=", h->child[0]->name);
        }
    } else if (h->childNum == 3 &&
               (h->child[1]->type == _PLUS || h->child[1]->type == _MINUS || h->child[1]->type == _STAR ||
                h->child[1]->type == _DIV)) {
        char temp1[MAX_LENGTH], temp2[MAX_LENGTH];
        translateExp(h->child[0], temp1, 0);
        if ((temp1[0] == '#' && temp1[1] == '0') && (h->child[1]->type == _STAR || h->child[1]->type == _DIV)) {
            if (option == 0) {
                place[0] = '#';
                place[1] = '0';
                place[2] = '\0';
            } else {
                addIrCode(3, place, ":=", "#0");
            }
        }
        translateExp(h->child[2], temp2, 0);
        if ((temp2[0] == '#' && temp2[1] == '0') && (h->child[1]->type == _STAR || h->child[1]->type == _DIV)) {
            if (option == 0) {
                place[0] = '#';
                place[1] = '0';
                place[2] = '\0';
            } else {
                addIrCode(3, place, ":=", "#0");
            }
        } else if (temp1[0] == '#' && temp2[0] == '#') {
            int i1 = strtol(&temp1[1], NULL, 10);
            int i2 = strtol(&temp2[1], NULL, 10);
            if (h->child[1]->type == _PLUS) {
                if (option == 0) {
                    sprintf(place, "#%d", i1 + i2);
                } else {
                    char temp[MAX_LENGTH];
                    sprintf(temp, "#%d", i1 + i2);
                    addIrCode(3, place, ":=", temp);
                }
            } else if (h->child[1]->type == _MINUS) {
                if (option == 0) {
                    sprintf(place, "#%d", i1 - i2);
                } else {
                    char temp[MAX_LENGTH];
                    sprintf(temp, "#%d", i1 - i2);
                    addIrCode(3, place, ":=", temp);
                }
            } else if (h->child[1]->type == _STAR) {
                if (option == 0) {
                    sprintf(place, "#%d", i1 * i2);
                } else {
                    char temp[MAX_LENGTH];
                    sprintf(temp, "#%d", i1 * i2);
                    addIrCode(3, place, ":=", temp);
                }
            } else {
                if (option == 0) {
                    sprintf(place, "#%d", i1 / i2);
                } else {
                    char temp[MAX_LENGTH];
                    sprintf(temp, "#%d", i1 / i2);
                    addIrCode(3, place, ":=", temp);
                }
            }
        } else if (temp2[0] == '#' && temp2[1] == '0') {
            if (option == 0)
                strcpy(place, temp1);
            else
                addIrCode(3, place, ":=", temp1);
        } else if (temp1[0] == '#' && temp1[1] == '0' && h->child[1]->type == _PLUS) {
            if (option == 0)
                strcpy(place, temp2);
            else
                addIrCode(3, place, ":=", temp2);
        } else {
            char op[2];
            op[1] = '\0';
            if (h->child[1]->type == _PLUS) op[0] = '+';
            else if (h->child[1]->type == _MINUS) op[0] = '-';
            else if (h->child[1]->type == _STAR) op[0] = '*';
            else op[0] = '/';
            if (option == 0) {
                newTemp(place);
            }
            addIrCode(5, place, ":=", temp1, op, temp2);
        }
    } else if (h->child[0]->type == _MINUS) {
        char temp[MAX_LENGTH];
        translateExp(h->child[1], temp, 0);
        if (temp[0] == '#') {
            int i = strtol(&temp[1], NULL, 10);
            if (option == 0) {
                sprintf(place, "#%d", -i);
            } else {
                char temp1[MAX_LENGTH];
                sprintf(temp1, "#%d", -i);
                addIrCode(3, place, ":=", temp1);
            }
        } else {
            if (option == 0) {
                newTemp(place);
            }
            addIrCode(5, place, ":=", "#0", "-", temp);
        }
    } else if (h->child[0]->type == _NOT || h->child[1]->type == _RELOP || h->child[1]->type == _AND ||
               h->child[1]->type == _OR) {
        char label1[MAX_LENGTH], label2[MAX_LENGTH];
        newLabel(label1);
        newLabel(label2);
        if (option == 0)
            newTemp(place);
        addIrCode(3, place, ":=", "#0");
        translateCond(h, label1, label2);
        addIrCode(3, "LABEL", label1, ":");
        addIrCode(3, place, ":=", "#1");
        addIrCode(3, "LABEL", label2, ":");
    } else if (h->childNum == 4 && h->child[1]->type == _LB) {
        char temp1[MAX_LENGTH], temp2[MAX_LENGTH];
        getLocation(h->child[0], temp1);
        translateExp(h->child[2], temp2, 0);
        if (temp2[0] == '#' && temp2[1] == '0') {
            char temp[MAX_LENGTH];
            if (temp1[0] == '&')
                strcpy(temp, &temp1[1]);
            else
                sprintf(temp, "*%s", temp1);
            if (option == 0) {
                strcpy(place, temp);
            } else {
                addIrCode(3, place, ":=", temp);
            }
        } else if (temp2[0] == '#') {
            int i = strtol(&temp2[1], NULL, 10);
            char temp[MAX_LENGTH], tempi[MAX_LENGTH];
            sprintf(tempi, "#%d", i * currentSize);
            newTemp(temp);
            addIrCode(5, temp, ":=", temp1, "+", tempi);
            char result[MAX_LENGTH];
            sprintf(result, "*%s", temp);
            if (option == 0)
                strcpy(place, result);
            else
                addIrCode(3, place, ":=", result);
        } else {
            char temp[MAX_LENGTH], tempi[MAX_LENGTH], result[MAX_LENGTH], num[MAX_LENGTH];
            sprintf(num, "#%d", currentSize);
            newTemp(temp);
            newTemp(tempi);
            addIrCode(5, tempi, ":=", temp2, "*", num);
            addIrCode(5, temp, ":=", temp1, "+", tempi);
            sprintf(result, "*%s", temp);
            if (option == 0)
                strcpy(place, result);
            else
                addIrCode(3, place, ":=", result);
        }
    } else if (h->childNum == 3 && h->child[1]->type == _DOT) {
        char left[MAX_LENGTH], temp[MAX_LENGTH], result[MAX_LENGTH];
        getLocation(h->child[0], left);
        int offseti = structGetOffset(currentStruct, h->child[2]->name);
        char offset[MAX_LENGTH];
        sprintf(offset, "#%d", offseti);
        newTemp(temp);
        addIrCode(5, temp, ":=", left, "+", offset);
        sprintf(result, "*%s", temp);
        if (option == 0)
            strcpy(place, result);
        else
            addIrCode(3, place, ":=", result);
    }
}

3、translateStmt
和translate函数类似，匹配每一个产生式做出相应的操作，其中可以用到translateExp处理exp结点：

void translateStmt(Node *h) {
    switch (h->child[0]->type) {
        case Exp: {
            translateExp(h->child[0], NULL, 0);
            break;
        }
        case CompSt: {
            translate(h->child[0]);
            break;
        }
        case _RETURN: {
            char temp[MAX_LENGTH];
            translateExp(h->child[1], temp, 0);
            addIrCode(2, "RETURN", temp);
            break;
        }
        case _IF: {
            char label1[MAX_LENGTH], label2[MAX_LENGTH], label3[MAX_LENGTH];
            newLabel(label1);
            newLabel(label2);
            if (h->childNum == 7) {
                newLabel(label3);
            }
            translateCond(h->child[2], label1, label2);
            addIrCode(3, "LABEL", label1, ":");
            translate(h->child[4]);
            if (h->childNum == 7)
                addIrCode(2, "GOTO", label3);
            addIrCode(3, "LABEL", label2, ":");
            if (h->childNum == 7) {
                translate(h->child[6]);
                addIrCode(3, "LABEL", label3, ":");
            }
            break;
        }
        case _WHILE: {
            char label1[MAX_LENGTH], label2[MAX_LENGTH], label3[MAX_LENGTH];
            newLabel(label1);
            newLabel(label2);
            newLabel(label3);
            addIrCode(3, "LABEL", label1, ":");
            translateCond(h->child[2], label2, label3);
            addIrCode(3, "LABEL", label2, ":");
            translate(h->child[4]);
            addIrCode(2, "GOTO", label1);
            addIrCode(3, "LABEL", label3, ":");
            break;
        }
    }
}

4、translateArgs
（1）如果Args→Exp COMMA Args，则继续处理Args，即函数的第一个if语句。
（2）分情况考虑，如果exp不为数组或结构，则翻译exp，即函数的第二个if语句。
（3）否则，exp为数组或结构。首先使用getlocation函数获取其地址，然后将其加入irCode。

void translateArgs(Node *h, VarDefUnit **args, int count) {
    if (h->childNum == 3)
        translateArgs(h->child[2], args, count + 1);
    if (args[count]->varType != _ARR_STRUCT_) {
        char temp[MAX_LENGTH];
        translateExp(h->child[0], temp, 0);
        addIrCode(2, "ARG", temp);
    }else {
        char temp[MAX_LENGTH];
        getLocation(h->child[0], temp);
        addIrCode(2, "ARG", temp);
    }
}

三、实验结果

  1. t1.cmm
int main()
{
    int n;
    n = read();
    if (n > 0) write(1); 
    else if (n < 0) write (-1);
    else write(0);
    return 0;
}

执行中间代码生成：

中间代码：

FUNCTION main :
READ n
IF n > #0 GOTO label0
GOTO label1
LABEL label0 :
WRITE #1
GOTO label2
LABEL label1 :
IF n < #0 GOTO label3
GOTO label4
LABEL label3 :
WRITE #-1
GOTO label5
LABEL label4 :
WRITE #0
LABEL label5 :
LABEL label2 :
RETURN #0

中间代码执行结果（输入 2）：

  1. t2.cmm
int fact(int n)
{
    if (n == 1)
        return n;
    else
        return (n * fact(n - 1));
}

int main()
{
    int m, result;
    m = read();
    if (m > 1)
        result = fact(m);
    else
        result = 1;
    write(result);
    return 0;
}

执行中间代码生成：

中间代码：

FUNCTION fact :
PARAM n
IF n == #1 GOTO label0
GOTO label1
LABEL label0 :
RETURN n
GOTO label2
LABEL label1 :
_t0 := n - #1
ARG _t0
_t1 := CALL fact
_t2 := n * _t1
RETURN _t2
LABEL label2 :
FUNCTION main :
READ m
IF m > #1 GOTO label3
GOTO label4
LABEL label3 :
ARG m
result := CALL fact
GOTO label5
LABEL label4 :
result := #1
LABEL label5 :
WRITE result
RETURN #0

中间代码执行结果（输入 5）：

  1. t3.cmm
struct Operands
{
    int o1;
    int o2;
};

int add(struct Operands temp)
{
	return (temp.o1 + temp.o2);
}

int main()
{
    int n;
    struct Operands op;
    op.o1 = 1;
    op.o2 = 2;
    n = add(op);
    write(n);
    return 0;
}

执行中间代码生成：

中间代码：

FUNCTION add :
PARAM temp
_t0 := temp + #0
_t1 := temp + #4
_t2 := *_t0 + *_t1
RETURN _t2
FUNCTION main :
DEC op 8
_t3 := &op + #0
*_t3 := #1
_t4 := &op + #4
*_t4 := #2
ARG &op
n := CALL add
WRITE n
RETURN #0

中间代码执行结果：

  1. t4.cmm
int add(int temp[2])
{
   return (temp[0] + temp[1]);
}

int main()
{
    int op[2];
    int r[1][2];
    int i = 0, j = 0;
    while (i < 2) {
  	    while (j < 2) {
            op[j] = i + j;
            j = j + 1;
        }
        r[0][i] = add(op);
        write(r[0][i]);
        i = i + 1;
        j = 0;
    }
    return 0;
}

执行中间代码生成：

中间代码：

FUNCTION add :
PARAM temp
_t0 := temp + #4
_t1 := *temp + *_t0
RETURN _t1
FUNCTION main :
DEC op 8
DEC r 8
i := #0
j := #0
LABEL label0 :
IF i < #2 GOTO label1
GOTO label2
LABEL label1 :
LABEL label3 :
IF j < #2 GOTO label4
GOTO label5
LABEL label4 :
_t3 := j * #4
_t2 := &op + _t3
_t8 := i + j
*_t2 := _t8
j := j + #1
GOTO label3
LABEL label5 :
_t5 := i * #8
_t4 := &r + _t5
ARG &op
_t9 := CALL add
*_t4 := _t9
_t7 := i * #8
_t6 := &r + _t7
WRITE *_t6
i := i + #1
j := #0
GOTO label0
LABEL label2 :
RETURN #0

中间代码执行结果：

四、附完整代码

github 链接：https://github.com/zheliku/byyl---Intermediate-Code-Generation。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1853001.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

STM32F103ZET6基于HAL库实现CAN回环测试和中断接收

STM32F103ZET6基于HAL库实现CAN回环测试和中断接收

简介 在野火STM32F103ZET6开发板上基于HAL库实现了CAN回环测试&#xff0c;并通过PCAN客户端工具和串口打印的方式&#xff0c;分别验证了CAN数据发送成功和CAN数据中断接收成功。 STM32F1开发板测试 STM32测试程序 发送函数 /** 函数名&#xff1a;CAN_SetMsg* 描述 &am…
阅读更多...
Windows安全中心打开白屏的解决方法

Windows安全中心打开白屏的解决方法

Windows安全中心打开白屏的解决方法&#xff1a; 1. 复制以下内容&#xff0c;打开记事本粘贴并保存&#xff0c;同时将记事本文件的【txt后缀名改为reg】: Windows Registry Editor Version 5.00 &#xff3b;HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows Defende…
阅读更多...
RTA_OS基础功能讲解 2.10-调度表

RTA_OS基础功能讲解 2.10-调度表

RTA_OS基础功能讲解 2.10-调度表 文章目录 RTA_OS基础功能讲解 2.10-调度表一、调度表简介二、调度表配置2.1 同步三、到期点配置四、启动调度表4.1 绝对启动4.2 相对启动4.3 同步启动五、到期点处理六、停止调度表6.1 重新启动被停止的调度表七、切换调度表八、选择同步策略8.…
阅读更多...
NSIS 入门教程 (三)

NSIS 入门教程 (三)

引言 在教程的第二部分中&#xff0c;我们为安装程序增加了一个卸载程序&#xff0c;并查看了一些其他的向导页面以及安装部分的选择。第三部分的目标是使安装程序的外观更加现代化。 更现代的外观 为了给安装程序一个更现代的外观&#xff0c;我们要启用现代用户界面。要提…
阅读更多...
UnityShader——基础篇之UnityShader基础

UnityShader——基础篇之UnityShader基础

UnityShader基础 UnityShader概述 材质和UnityShader 总的来说&#xff0c;在Unity中需要配合使用材质(Material)和 Unity Shader 才能达到需要的效果&#xff0c;常见流程为&#xff1a; 创建一个材质创建一个 Unity Shader&#xff0c;并把它赋给上一步中创建的材质把材质…
阅读更多...
AcWing算法基础课笔记——求组合数4

AcWing算法基础课笔记——求组合数4

求组合数Ⅳ 用来解决求 C a b C_a^b Cab​的问题&#xff08;没有模运算&#xff09; 解决办法&#xff1a;分解质因数&#xff0c;实现高精度乘法。 C a b a ! b ! ( a − b ) ! C_a^b \frac{a!}{b!(a - b)!} Cab​b!(a−b)!a!​ 其中 a ! a! a!可以用 p p p的倍数来表示…
阅读更多...
自动驾驶仿真：Carsim转向传动比设置

自动驾驶仿真：Carsim转向传动比设置

文章目录 一、转向传动比概念二、设置转向传动比1、C factor概念2、Steer Kinematics概念3、传动比计算公式 三、转向传动比验证 一、转向传动比概念 转向传动比&#xff08;Steering Ratio&#xff09;表示方向盘转动角度与车轮转动角度之间的关系。公式如下&#xff1a; 转向…
阅读更多...
计算机网络 动态路由OSPF

计算机网络 动态路由OSPF

一、理论知识 1.OSPF基本概念 ①OSPF是一种链路状态路由协议&#xff0c;使用Dijkstra算法计算最短路径。 ②OSPF使用区域&#xff08;Area&#xff09;来组织网络&#xff0c;区域0&#xff08;Area 0&#xff09;是主干区域。 ③路由器通过通告直连网络加入OSPF域。 ④反…
阅读更多...
QT中制作带有界面的静态库

QT中制作带有界面的静态库

1、可参考以下文章 QT中制作带有界面的动态库 2、相比动态库&#xff0c;静态库就更简单了&#xff0c;&#xff0c;&#xff0c; 1&#xff09;创建静态库项目 2&#xff09;直接右键创建同名窗口类进行覆盖 3&#xff09;编译生成静态库 4&#xff09;使用
阅读更多...
人工智能导论笔记

人工智能导论笔记

目录 ​编辑 绪论篇 有关知识表示和推理的零碎知识点 机器学习篇 K-近邻算法&#xff08;KNN&#xff09; 人工神经网络与深度学习篇 人工神经元模型 人工神经网络 BP神经网络 卷积神经网络 搜索策略 状态空间表示法 盲目搜索 启发式图搜索策略 绪论篇 3个学派&a…
阅读更多...
实战篇：GY-906红外测温模块 + 万年历（定时器计数中断版本） -STM32篇

实战篇：GY-906红外测温模块 + 万年历（定时器计数中断版本） -STM32篇

本文章基于兆易创新GD32 MCU所提供的2.2.4版本库函数开发 向上代码兼容GD32F450ZGT6中使用 后续项目主要在下面该专栏中发布&#xff1a; https://blog.csdn.net/qq_62316532/category_12608431.html?spm1001.2014.3001.5482 感兴趣的点个关注收藏一下吧! 电机驱动开发可以跳转…
阅读更多...
视频批量剪辑新境界：一键转码MP4至MP3并自动删除原文件，轻松优化存储空间与播放体验

视频批量剪辑新境界：一键转码MP4至MP3并自动删除原文件，轻松优化存储空间与播放体验

随着数字媒体的飞速发展&#xff0c;视频文件已成为我们生活中不可或缺的一部分。然而&#xff0c;大量视频文件的累积不仅占据了宝贵的存储空间&#xff0c;而且在某些情况下&#xff0c;我们更希望提取视频中的音频内容。为了满足这一需求&#xff0c;我们推出了全新的视频批…
阅读更多...
LLVM——安装多版本LLVM和Clang并切换使用（Ubuntu）

LLVM——安装多版本LLVM和Clang并切换使用（Ubuntu）

1、描述 本机&#xff08;Ubuntu22&#xff09;已经安装了LLVM-14&#xff0c;但是需要使用LLVM-12。安装LLVM-12和Clang-12并切换使用。 2、过程 安装LLVM-12和Clang-12。 sudo apt-get install llvm-12 sudo apt-get install clang-12 【注】运行 sudo apt-get install ll…
阅读更多...
django学习入门系列之第三点《CSS基础样式介绍2》

django学习入门系列之第三点《CSS基础样式介绍2》

文章目录 文字对齐方式外边距内边距往期回顾 文字对齐方式 水平对齐方式 text-align: center;垂直对齐方式 /* 注意&#xff0c;这个只能是一行来居中 */ line-height:/*长度*/ ;样例 <!DOCTYPE html> <html lang"en"> <head><meta charset…
阅读更多...
【Oracle】实验一 安装和使用Oracle数据库

【Oracle】实验一 安装和使用Oracle数据库

【实验目的】 掌握Oracle软件安装过程&#xff0c;选择安装组件掌握建立Oracle数据库&#xff0c;配置网络连接使用SQL*Plus&#xff0c;登录到实例和数据库掌握命令方式的关闭和启动实例及数据库 【实验内容】 安装Oracle19c&#xff0c;记录安装过程。切记&#xff1a;创建…
阅读更多...
Jenkins定时构建自动化(二)：Jenkins的定时构建

Jenkins定时构建自动化(二)：Jenkins的定时构建

目录 ​编辑 一、 jenkins定时构建语法&#xff1a; 1. 语法规则&#xff1a; 2. 常见用法举例 3. 再次举例 接上一篇&#xff1a;Jenkins定时构建自动化(一)&#xff1a;Jenkins下载安装配置&#xff1a;Jenkins定时构建自动化(一)&#xff1a;Jenkins下载安装配置-CSDN博客 …
阅读更多...
HTML静态网页成品作业(HTML+CSS)——故宫介绍网页(4个页面)

HTML静态网页成品作业(HTML+CSS)——故宫介绍网页(4个页面)

&#x1f389;不定期分享源码&#xff0c;关注不丢失哦 文章目录 一、作品介绍二、作品演示三、代码目录四、网站代码HTML部分代码 五、源码获取 一、作品介绍 &#x1f3f7;️本套采用HTMLCSS&#xff0c;未使用Javacsript代码&#xff0c;共有4个页面。 二、作品演示 三、代…
阅读更多...
【教学类-36-09】20240622钓鱼（通义万相）-A4各种大小的鱼

【教学类-36-09】20240622钓鱼（通义万相）-A4各种大小的鱼

背景需求&#xff1a; 用通义万相获得大量的简笔画鱼的图片&#xff0c;制作成不同大小&#xff0c;幼儿用吸铁石钓鱼的纸片&#xff08;回形针&#xff09;&#xff0c;涂色、排序等 补一张通义万相的鱼图 素材准备 &#xff08;一&#xff09;优质的鱼图片 &#xff08;二&a…
阅读更多...
（2024）豆瓣电影TOP250爬虫详细讲解和代码

（2024）豆瓣电影TOP250爬虫详细讲解和代码

&#xff08;2024&#xff09;豆瓣电影TOP250爬虫详细讲解和代码 爬虫目的 获取 https://movie.douban.com/top250 电影列表的所有电影的属性。并存储起来。说起来很简单就两步。 第一步爬取数据第二步存储 爬虫思路 总体流程图 由于是分页的&#xff0c;要先观察分页的规…
阅读更多...
VS Code安装及环境配置（超详细）

VS Code安装及环境配置（超详细）

VS Code简介 Visual Studio Code&#xff08;简称 VS Code &#xff09;是 Microsoft 于2015年4月发布的一款代码编辑器&#xff0c;以界面简洁、轻量著称。 它是一款免费开源的现代化轻量级代码编辑器&#xff0c;支持几乎所有主流开发语言的语法高亮、智能代码补全、自定义…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023